Си — Говнокод.ру

Си / Говнокод #25613

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

bool End_Range (FILE * f){
  int tmp;
  tmp = fgetc(f);
  tmp = fgetc(f);
  if (tmp != '\'') fseek(f,-2,1);
  else fseek(f,1,1);
  return tmp == '\'' ? true : false;
}

void Natural_Merging_Sort (char *name){
  int s1, s2, a1, a2, mark;  FILE *f, *f1, *f2;  s1 = s2 = 1;
  while ( s1 > 0 && s2 > 0 ){
   	 mark = 1; s1 = 0; s2 = 0;
    	 f = fopen(name,"r"); f1 = fopen("nmsort_1","w"); 
		 f2 = fopen("nmsort_2","w"); fscanf(f,"%d",&a1);
   	 if ( !feof(f) ) fprintf(f1,"%d ",a1);
   	 if ( !feof(f) ) fscanf(f,"%d",&a2);
    	 while ( !feof(f) ){
     		 if ( a2 < a1 ) {switch (mark) {
          				case 1:{fprintf(f1,"' "); mark = 2; s1++; break;}
         				case 2:{fprintf(f2,"' "); mark = 1; s2++; break;}
        		  }}
if ( mark == 1 ) { fprintf(f1,"%d ",a2); s1++; }
      	else { fprintf(f2,"%d ",a2); s2++;}
      	a1 = a2; fscanf(f,"%d",&a2);
    	}
    if ( s2 > 0 && mark == 2 ) { fprintf(f2,"'");}
    if ( s1 > 0 && mark == 1 ) { fprintf(f1,"'");}
    fclose(f2); fclose(f1); fclose(f);
    cout << endl;
    Print_File(name);
    Print_File("nmsort_1");
    Print_File("nmsort_2");
    cout << endl;
  f = fopen(name,"w");  f1 = fopen("nmsort_1","r");
    f2 = fopen("nmsort_2","r");
    if ( !feof(f1) ) fscanf(f1,"%d",&a1);
    if ( !feof(f2) ) fscanf(f2,"%d",&a2);
    bool file1, file2;
    while ( !feof(f1) && !feof(f2) ){	file1 = file2 = false;
      	while ( !file1 && !file2 ) {
        		if ( a1 <= a2 ) { fprintf(f,"%d ",a1); 
				  file1 = End_Range(f1); fscanf(f1,"%d",&a1);	}
        else { fprintf(f,"%d ",a2); file2 = End_Range(f2);
          fscanf(f2,"%d",&a2);	}
      } 
while ( !file1 ) {		fprintf(f,"%d ",a1);
        file1 = End_Range(f1);  fscanf(f1,"%d",&a1);	}
 while ( !file2 ) {	fprintf(f,"%d ",a2);  
				file2 = End_Range(f2); fscanf(f2,"%d",&a2);	}
    }	file1 = file2 = false;
    while ( !file1 && !feof(f1) ) {	fprintf(f,"%d ",a1);
      		file1 = End_Range(f1); fscanf(f1,"%d",&a1);	}
    while ( !file2 && !feof(f2) ) {	fprintf(f,"%d ",a2);
      		file2 = End_Range(f2); fscanf(f2,"%d",&a2);	}
    fclose(f2); fclose(f1); fclose(f);
  }	 remove("nmsort_1");  remove("nmsort_2");
}

Потеряли пульт от телевизора? Найди его бинарным поиском!!!

dethless, 19 Мая 2019

Комментарии (12)

Си / Говнокод #25612

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

namespace belugina
{
void Simple_Merging_Sort (char *name){ 
	 int a1, a2, k, i, j, kol, tmp;  
	FILE *f, *f1, *f2;  
	kol = 0;  
	if ( (f = fopen(name,"r")) == NULL )    
		printf("\nИсходный файл не может быть прочитан...");  
	else {    while ( !feof(f) ) {      
		fscanf(f,"%d",&a1);      
		kol++;    
		}   
	 fclose(f);  
	} 
k = 1;  
while ( k < kol ){ 
	f = fopen(name,"r");    
	f1 = fopen("smsort_1","w");    
	f2 = fopen("smsort_2","w");   
	if ( !feof(f) ) fscanf(f,"%d",&a1);    
	while ( !feof(f) ){     
		 for ( i = 0; i < k && !feof(f) ; i++ ){        
			fprintf(f1,"%d ",a1); fscanf(f,"%d",&a1); }      
		for ( j = 0; j < k && !feof(f) ; j++ ){        
			fprintf(f2,"%d ",a1);  fscanf(f,"%d",&a1);}   
	 }   
	 fclose(f2);    fclose(f1);    fclose(f); 
f = fopen(name,"w");   f1 = fopen("smsort_1","r");    
	f2 = fopen("smsort_2","r");    
	if ( !feof(f1) ) fscanf(f1,"%d",&a1);   
	if ( !feof(f2) ) fscanf(f2,"%d",&a2);    
	while ( !feof(f1) && !feof(f2) ){     
	 	i = 0;      j = 0;     
	 	while ( i < k && j < k && !feof(f1) && !feof(f2) ) {        
			if ( a1 < a2 ) {          
			fprintf(f,"%d ",a1); fscanf(f1,"%d",&a1);i++;}        
			else {          
			fprintf(f,"%d ",a2);fscanf(f2,"%d",&a2); j++;}      
	   	} 
while ( i < k && !feof(f1) ) {        
		     fprintf(f,"%d ",a1);  fscanf(f1,"%d",&a1); i++;}      
		while ( j < k && !feof(f2) ) {        
		     fprintf(f,"%d ",a2);   fscanf(f2,"%d",&a2);  j++;}   
 	 }    
	while ( !feof(f1) ) {      
		fprintf(f,"%d ",a1);      fscanf(f1,"%d",&a1);    }    
	while ( !feof(f2) ) {      
		fprintf(f,"%d ",a2);      fscanf(f2,"%d",&a2);    }   
	fclose(f2);    fclose(f1);    fclose(f);    k *= 2;  
	}  
	remove("smsort_1");  remove("smsort_2");
} 
}

Вектор это не динамический массив.

dethless, 19 Мая 2019

Комментарии (4)

Си / Говнокод #25602

−1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22

// вообще, есть одна говнистая особенность сишки:
// нельзя вернуть из функции массив хуйпойми какой длины, выделив память чисто на стеке
// Вот например:

char *a_ret (size_t len)
{
  char *ret = alloca(len);
  memset(ret, 'a', len);
  return ret; // так нельзя
}

// т.е. надо делать как-нибудь вот так
char *a_ret (size_t len)
{
  char *ret = malloc(len);
  if (ret == NULL)
  {
    exit(ENOMEM);
  }
  memset(ret, 'a', len);
  return ret;
}

Но это ж на самом-то деле говно какое-то. Дергать аллокаторы какие-то, ради каких-то мелких кусков байтиков.
Почему не сделать хуйни, чтоб вызываемая функция как бы приосталавливалась и просила ту функцию, которая ее вызывает, чтоб она вот такой-то alloca() сделала нужного размера в своем стекфрейме, а потом туда вот та вызванная функция байтики уже вхерачивала? Ну т.е. можно сделать отдельный свой стек для локальных переменных тех функций, которые должны уметь такую хуйню делать (т.е. просить вызвавшую их функцию "а сделай ка там себе alloca(123) и дай мне указатель, а я в него насру")
Вообще хуйня какая-то, сишка слишком сильно сковывает всякой своей хуйней, соглашениями вызовов, всякими ABI там. То ли дело ассемблер!

j123123, 15 Мая 2019

Комментарии (93)

Си / Говнокод #25599

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <conio.h>

static unsigned char bigArray[256] = {['0'] = 0, ['1'] = 1, ['2'] = 2, ['3'] = 3,
                                      ['4'] = 4, ['5'] = 5, ['6'] = 6, ['7'] = 7,
                                      ['8'] = 8, ['9'] = 9, ['A'] = 10, ['B'] = 11,
                                      ['C'] = 12, ['D'] = 13, ['E'] = 14, ['F'] = 15 };
void StringToByte(const char src[], unsigned char dst[]) 
{
	int q, u = 0;
	for (q = 0; src[q]; q+=2) 
	{
		dst[u] = bigArray[src[q]] << 4;
		if (!src[q+1]) 
			return;
		dst[u++] |= bigArray[src[q+1]];
	}
}

int main()
{
	char string[] = "112255ACBF";
	unsigned char bytes[5];
	StringToByte(string, bytes);
	int i;
	for (i = 0; i!=sizeof(bytes); i++)
		printf("%x ", (int)bytes[i]);
	return 0;
}

Ебическая С-ла.

Psionic, 13 Мая 2019

Комментарии (93)

Си / Говнокод #25596

−1

1

// Чому можливо писати "2[i]" а можливо i "i[2]"?

а?

DypHuu_niBEHb, 10 Мая 2019

Комментарии (41)

Си / Говнокод #25593

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14

#define paehal int i = 0; char arr[30000]; memset(arr, 0, sizeof(arr));
#define go i++;
#define  nozad i--;
#define plusegg arr[i]++;
#define minusegg arr[i]--; 
#define vivodeg putchar(arr[i]);	
#define tipavhile while(arr[i]){	
#define nevhile }
int main() {
setlocale(0, "");
paehal
plusegg plusegg plusegg plusegg plusegg tipavhile plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg  go nozad minusegg nevhile go vivodeg go plusegg plusegg plusegg tipavhile go plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg go minusegg nevhile go vivodeg 
return 0;
}

брайнфак на минималках
выводит a!

pozhiloy, 07 Мая 2019

Комментарии (47)

Си / Говнокод #25585

0

1
2

(cell)data += sizeof(cell) - 1;
    (cell)data &= ~(sizeof(cell) - 1);

Блядь, ёбаный tcc! Другие конпилеры отказываются такое конпилить. Теперь дохуя переписывать.

Hu3KoypoBHeBblunemyx, 03 Мая 2019

Комментарии (169)

Си / Говнокод #25561

−1

1
2
3
4
5
6
7
8
9

//"вирус" в стиле кулхацкеров
#include <stdlib.h>
int main() {
int i = 1;
while( i == 1)  {
	system("start calc");
}
return 0;
}

pozhiloy, 22 Апреля 2019

Комментарии (63)

Си / Говнокод #25555

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

void  converting(char *in, char *out, node *PTR, char (checking_stack)(node), void (push)(node *topPTR, char value), int (pop)(node *fix), int (isOper)(char c), int (precedence_intro)(char data_1, char  data_2, int(intro_precedence_power)(int res_1, int  res_2)), int(intro_precedence_power)(int res_1, int  res_2)) {

	int k = 0, j = 0, d = 0;
	
	push(PTR, '(');
	
	for (k = 0; checking_stack((node)PTR) != 0; k++) {
	
		if (isdigit(in[k])) {
			
			out[j++] = in[k];

		}

		if (in[k] == '(') {

			push(PTR, in[k]);

		}

		if (isOper(in[k]) == 1) {

			while (precedence_intro((*PTR)->alpha, in[k], intro_precedence_power) != -1) {

				out[j++] = pop(PTR);
			}

			push(PTR, in[k]);
		}
		
		if (in[k] == ')') {

			d = pop(PTR);
			for (; d != '('; d = pop(PTR)) {
				out[j++] = d;
			}
		}
	}
}





int precedence(char data_1, char   data_2, int(intro_precedence_power)(int res_1, int  res_2))  {
 char collection[] = "+1-1*2/2^3";	
 
 char	buf_1 = (char)strcspn(  collection , &data_1) + 1;
 char	buf_2 = (char)strcspn(collection, &data_2) + 1;

	return   intro_precedence_power(atoi(&collection[buf_1]), atoi(&collection[buf_2]));
}

int precedence_power(int res_1, int  res_2) {
	if (res_1 < res_2) {
		return   -1;
	}
	else	if (res_1 == res_2) {
		return 	  0;
	}
	else	if (res_1 > res_2) {
		return	  1;
	}
	return 0;
}

Якобы вычисляет обратною польскою нотацию номер два

lazy_8, 19 Апреля 2019

Комментарии (7)

Си / Говнокод #25554

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define  MAX 300

struct stack {
	char alpha;
	struct stack *nxtPTR;

};

typedef struct stack  Stack;
typedef  Stack *node;
void  message(void);
char out_print(char word[]);
int precedence_power(int res_1, int  res_2);
int pop(node *topPtr);
void push_stack(node *topPTR, char value);
int pop(node  *topPTR);
char check_stack(node data);
int isOperator(char c);
int precedence(char data_1, char   data_2, int(intro_precedence_power)(int res_1, int  res_2));
void  converting(char *in, char *out, node *PTR, char (checking_stack)(node), void (push)(node *topPTR, char value), int (pop)(node *fix), int (isOper)(char c), int (precedence_intro)(char data_1, char  data_2, int(intro_precedence_power)(int res_1, int  res_2)), int(intro_precedence_power)(int res_1, int  res_2));
void  please_enter(void );

int main(void) {
	
	char infix[MAX];
	char postfix[MAX];
	node topPTR = NULL;
	
	fgets(infix, sizeof(infix), stdin);
    int	m = strlen(infix);

	infix[m] = ')';

	memset(postfix, 0, MAX);
	

  

	converting( infix, postfix, &topPTR, check_stack, push_stack, pop, isOperator, precedence, precedence_power);
	out_print(postfix);
	
	puts(" ");
	
return 0;
}

char out_print(char word[]) {

if( word[0]  != '\0' ){
	 	printf( "%c " ,  word[0]    ) ; 
return    out_print(word + 1  )  ;
}

}

void push_stack(node *topPTR, char value) {
	node newPTR = malloc(sizeof(Stack));

	if (newPTR != NULL) {

		newPTR->alpha = value;
		newPTR->nxtPTR = *topPTR;

		*topPTR = newPTR;
	}

	else {

		puts("error");

	}
}

int pop(node *fix) {

int value = (*fix)->alpha;

	node temp = *fix;
	*fix = (*fix)->nxtPTR;
	free(temp);

	return value;
}

char check_stack(node data) {
	return data->alpha;
}

int isOperator(char c) {
	return c == '/' || c == '*' || c == '-' || c == '+'  || c == '^'  ;
}

вычисляет обратною польскою нотацию номер раз