1. Список говнокодов пользователя lazy_8

    Всего: 7

  2. Куча / Говнокод #28291

    −4

    1. 1
    Передайте  Камрану Амини что он Большое Хуйло

    lazy_8, 22 Июля 2022

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

  3. Си / Говнокод #28274

    +1

    1. 1
    2. 2
    3. 3
    4. 4
    int my_strcmp(const char *out, const char *in   ){
  for( ;*(in) , *(out) &&  *(in) == *(out); *out++,*in++  );
	   return   *in <= *out ?  *out > *in   : -1   ;
	}

    Бульк

    lazy_8, 06 Июля 2022

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

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

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 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)

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

    0

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

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

    lazy_8, 19 Апреля 2019

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

  6. Куча / Говнокод #21914

    −70

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    ВЫНЕСЕНИЕ ИНВАРИАНТНОГО КОДА ЗА ПРЕДЕЛЫ ЦИКЛА

Инвариантным называется код, не изменяющийся в ходе выполнения цикла. А раз так, – 
то какой смысл выполнять его в каждой итерации – не лучше ли вынести такой код за пределы цикла?
Рассмотрим следующий пример:

for(a = 0;a  <(b*2);  a++)

printf("%x\n",a*(b/2));

Выражения (b*2) и (b/2) очевидно представляют собой инвариант, и оптимизированный код будет выглядеть так:

tmp_1=b*2;

tmp_2=b/2;

for(a=0;a<tmp_1;a++)

printf("%x\n",tmp_2+=tmp_2);

Это экономит одну операцию деления и две операции умножения на каждую итерацию, что очень и очень неплохо!
Компиляторы Microsoft Visual C++ и WATCOM успешно распознают инвариантный код и выносят его за пределы цикла, 
а вот Borland C++ увы, нет.

    Всегда было интересно узнать кто-нибудь чему-нибудь научился на книжках KPNC ?

    lazy_8, 29 Декабря 2016

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

  7. Си / Говнокод #19834

    −49

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    int minimal_array(int array[], int flag_array[] , int intro_run) {
	int step;
	int end = -1;
	int Minimum = 8;
	for(step = 0; step <= 7; ++step) {
		if( array[step] <= Minimum &&  array[step] >=  1 &&   flag_array[step] ==  1     ) {
			Minimum = array[step];
			end = step;
		}
	}
	if(     intro_run >= (chess * chess - 4) ||      intro_run <=  (chess * chess - 2  ) ) {
		for(step = 0; step <= 7; ++step) {
			if(    array[step] ==  0 &&   flag_array[step] ==  1     ) {
				end = step;
			}
		}
	}
	return end;
}
int   check_point(   int row, int column,  int bord[][chess]	) {
	int p;
	row >= 0 && row <= chess - 1 && column >= 0 && column <= chess -1 && bord[row][column]  == 0 ? (p = 1 ) : (p = 0);
	return p;
}
int cor_hor(int hor_out  ) {
	static	int	  horizont[chess] = {2,1,-1,-2,-2,-1,1,2 };
	return 	   horizont[hor_out];
}
int cor_ver(int ver_out) {
	static	int  	verti[chess] = { -1, -2,-2,-1,1,2,2,1  };
	return  verti[ver_out];
}
int minimum_possible(int cur_Column,int cur_Row, int extro_board[][chess],int run) {
	int   check_point(   int row, int column,  int bord[][chess]	),
	         cor_hor(int in  ),
	         cor_ver(int ni),
	         extro_stop = 0,
	         intro_board[chess][chess] = {0 },
	                                     extro_array[8] = {0 },
	                                             step_row[8] = {0 },
	                                                     step_column[8] = {0 },
	                                                             intro_array[8] = {0 },
	                                                                     extro_number_shift,
	                                                                     extro_shag = 0,
	                                                                     extro_Row  ,
	                                                                     extro_Column ,
	                                                                     cycle_all= 0 ,
	                                                                     step = 0;
	memcpy( intro_board      ,extro_board,  sizeof(intro_board  ));
	for( extro_number_shift = -1; extro_stop <= 8; ) {
		extro_Row += cor_ver(extro_number_shift),extro_Column += cor_hor(extro_number_shift);
		if(check_point(  extro_Row  ,extro_Column ,  intro_board	)  == 1) {
			intro_board[extro_Row][extro_Column]  = ++extro_shag;
			++extro_array[extro_number_shift];
			step_row[extro_number_shift]   =   extro_Row ;
			step_column[extro_number_shift] =  extro_Column ;
		} else {
			++extro_stop;
		}
		extro_Column = cur_Column;
		extro_Row = cur_Row;
		++extro_number_shift ;
	}
	while(cycle_all <=  7)	{
		if(extro_array[cycle_all] == 1) {
			memcpy( intro_board,extro_board,sizeof(intro_board  ));
			intro_board[cur_Row][cur_Column] = 1;
			for( extro_stop = 0,  extro_number_shift  = -1  ; extro_stop  !=   8;) {
				extro_Row +=  cor_ver(extro_number_shift) ,extro_Column += cor_hor(extro_number_shift );
				if(    check_point(  extro_Row  ,extro_Column ,  intro_board	)  == 1) {
					intro_board[extro_Row][extro_Column]  = extro_shag++;
					++intro_array[cycle_all];
				} else {
					extro_stop++;
				}
				extro_Row =     step_row[cycle_all];
				extro_Column  =     step_column[cycle_all] ;
				++extro_number_shift;
			}
		}
		++cycle_all;
	}
	return      	 minimal_array(intro_array   ,extro_array , run )   ;
}

    обход доски конем метод варнсдорфа ч.2 набор функций

    lazy_8, 17 Апреля 2016

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

  8. Си / Говнокод #19833

    −49

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    #include<stdio.h>
#include <stdlib.h>
#include<string.h>
#define chess 18
int minimum_possible(int cur_Column,int cur_Row, int extro_board[][chess], int run ),
    check_point(   int row, int column,  int bord[][chess]	),
    cor_hor(int hor_out  ),
    cor_ver(int ver_out);
int main(void) {
	int  step = 1 ,
	     y,x,
	     moveNumber = 1,
	     currentColumn,
	     currentRow,
	     board[chess][chess] = {0 } , p = 1;
	while( p  ) {
		printf("enter the coordinates of the knight y  x: ");
		scanf("%d %d",&currentColumn ,  &currentRow   );
		if (currentColumn <  0  ||  (currentColumn > (chess - 1)   )  ||  (currentRow  <  0 ||  (currentRow > (chess - 1))    ) )  {
			puts("correct the coordinates of the knight from 0 to 11 for x and y");
		} else {
			p = 0;
		}
	}
	while(  	moveNumber  != -1   )  {
		board[currentRow][ currentColumn]  = step++;
		moveNumber =     minimum_possible(currentColumn,currentRow ,board , step ) ;
		currentRow +=   cor_ver(moveNumber);
		currentColumn +=   cor_hor(moveNumber);
	}
	for(x = 0; x <= chess - 1; x++) {
		puts(" ");
		for(y = 0 ; y <= chess - 1; y++)
			printf("%3d ", board[x][y]);
	}
	return 0;
}

    обход доски конем метод варнсдорфа ч.1

    lazy_8, 17 Апреля 2016

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