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

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

+1

01
02
03
04
05
06
07
08
09
10
11

#include <stdio.h>

int main()
{
	for (int x; scanf("%d", &x);) {
    	#define x x += x
    	x & (x-1);
    	printf("%d\n", x);
	}
	return 0;
}

https://ideone.com/SxgTL0

-3 -28
-2 -20
-1 -12
0 -4
1 4
2 12
3 20

Ничо нипанятна...

yet_another_one_shit, 01 Мая 2018

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

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

+1

1

x & (x-1);

Написавший это утверждает, что меняется содержимое памяти, но как происходят эти мистические изменения он объяснить не может.

Ioann_Zid, 01 Мая 2018

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

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

−10

1

Вопрос

Кто знает, как динамически выделить память, заполнить её нужными инструкциями, и исполнить этот код, не испытав при этом анальной боли и не получить Segmentation Fault ?

yet_another_one_shit, 23 Апреля 2018

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

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

0

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

// ...
int datastack [ 4096 ] ;
int *dp = datastack ;

int push ( int x ) {
    return *dp++ = x ;
}

int pop() {
    return *--dp ;
}

// ...

void execute() {
    ((void(*)())pop())() ;
}

// ...

Мама! Мама! Я покакал!

yet_another_one_shit, 20 Апреля 2018

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

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

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

char *r_or_mem() {
    if ( get_mod() == 3 )
        return regs [ ( size << 3 ) | ( look & 7 ) ] ;
    else {
        static char buf [ 32 ] ;
        char *s = buf ;
        *s++ = '[' ;
        if ( ! ( look & 4 ) ) {
            *s++ = 'B' ;
            *s++ = ( look & 2 ) ? 'P' : 'X' ;
            *s++ = '+' ;
            *s++ = ( look & 1 ) ? 'D' : 'S' ;
            *s++ = 'I' ;
            if ( mod ) *s++ = '+' ;
        } else {
            if ( ( look & 7 ) == 6 && ! mod ) mod = 2 ;
            else {
                if ( look & 2 ) {
                    *s++ = 'B' ;
                    *s++ = ( look & 1 ) ? 'X' : 'P' ;
                } else {
                    *s++ = ( look & 1 ) ? 'D' : 'S' ;
                    *s++ = 'I' ;
                }
                if ( mod ) *s++ = '+' ;
            }
        }
        if ( mod ) {
            read_value ( s , mod == 2 ) ;
            s = s + strlen ( s ) ;
        }
        *s++ = ']' ;
        *s = 0 ;
        return buf ;
    }
}

void checkorder() {
    if ( ! dest ) {
        char *tmp = op1 ;
        op1 = op2 ;
        op2 = tmp ;
    }
}

void rm ( char *s ) {
    sprintf ( decoded , "%s\t" , s ) ;
    decoded += strlen ( decoded ) ;
    get_ds() ;
    read() ;
    op1 = get_reg() ;
    op2 = r_or_mem() ;
    checkorder() ;
    sprintf ( decoded , "%s , %s" , op1 , op2 ) ;
}

Чассть моего дизассемблера для 16-анального x86, что читает операндыы.

yet_another_one_shit, 19 Апреля 2018

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

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

+5

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

#include <stdio.h>

struct struct2 {
	struct struct1 a ;
} ;

struct struct1 {
	struct struct2 a ;
	int b ;
} ;


int main(){
	struct struct1 a ;
	scanf ( "%d" , &a.a.a.b ) ;
	printf ( "%d" , a.b ) ;
	return 0;
}

Все, кроме TCC для C4droid, отказались это компилировать, не пробовал только Visual Studio

yet_another_one_shit, 17 Апреля 2018

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

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

0

1
2
3
4
5
6
7
8
9

#include <stdio.h>
 
int main(void) {
	int i = 0;
	loop:
	i > 10 || printf("%d\n", i++) && goto loop;
	printf("end\n");
	return 0;
}

Зачем удолили #24105?

3.14159265, 14 Апреля 2018

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

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

+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
54
55
56
57
58

#include <stdio.h>
#include <string.h>
#include <sodium.h>
#include <stdlib.h>
#include <unistd.h>

void reverse(char s[]);
void itoa(int n, char s[]);

int main()
{
	if(sodium_init() < 0) {
		printf("Паника! Библиотека не может быть инициализирована, небезопасно использовать.\n");
		return 1;
	}

	#define STR_LEN 30
	char str[STR_LEN];
	
	for(unsigned long i = 0; i < STR_LEN; ++i) {
		if(randombytes_uniform(2) == 0)
			str[i] = 48;
		else
			str[i] = 49;
	}
	
	printf("%s\n", str);
	while(1) {
		for (unsigned long i = 0; i < strlen(str); i+=2)
		{
			if(str[i] == '0' && str[i+1] == '0' && str[i+2] == '0')
				str[i+1] = '1';
			else if(str[i] == '1' && str[i+1] == '0' && str[i+2] == '0')
				str[i] = '0', str[i+2] = '1';
			else if(str[i] == '1' && str[i+1] == '0' && str[i+2] == '0')
				str[i+2] = '1', str[i] = '0';
			else if(str[i] == '1' && str[i+1] == '1' && str[i+2] == '1')
				str[i+1] = '0', str[i] = '0';
			else if(str[i] == '0' && str[i+1] == '1' && str[i+2] == '1')
				str[i] = '1';
			else if(str[i] == '1' && str[i+1] == '0' && str[i+2] == '1')
				str[i] = '0', str[i+1] = '1';
			else if(str[i] == '0' && str[i+1] == '0' && str[i+2] == '1')
				str[i] = '1', str[i+1] = '1', str[i+2] = '0';
			else if(str[i] == '0' && str[i+1] == '1' && str[i+2] == '0')
				str[i+2] = '1';
			else if(str[i] == '1' && str[i+1] == '1' && str[i+2] == '1')
				str[i] = '0', str[i+2] = '0';
			else if(str[i] == '1' && str[i+1] == '1' && str[i+2] == '0')
				str[i+1] = '0';

		}
		printf("%s\n", str);
		sleep(1);
	}

	return 0;
}

10 простых правил и бесконечный вывод триллиардов иттерация которые никогда не кнчатся! ЭТО НОНСЕНС

fuckercoder, 11 Апреля 2018

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

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

+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

// https://github.com/Samsung/ADBI/blob/3e424c45386b0a36c57211da819021cb1929775a/idk/include/division.h#L138

/* Long division by 10. */
static unsigned long long int div10l(unsigned long long int v) {

    /* It's a kind of magic.  We achieve 64-bit (long) division by dividing the two 32-bit halfs of the number 64-bit
     * number.  The first (most significant) half can produce a rest when dividing, which has to be carried over to the
     * second half.  The rest_add table contains values added to the second half after dividing depending on the rest
     * from the first division.  This allows evaluation of a result which is almost correct -- it can be either the
     * expected result, or the expected result plus one.  The error can be easily detected and corrected.
     */
    
    /* one dream */
    static unsigned long long int rest_add[] = {
        0x00000000, 0x1999999a, 0x33333334, 0x4ccccccd, 0x66666667,
        0x80000001, 0x9999999a, 0xb3333334, 0xcccccccd, 0xe6666667
    };
    
    /* one soul */
    unsigned long long int a = div10((unsigned int)(v >> 32));
    unsigned long long int b = div10((unsigned int)(v & 0xffffffff));
    
    /* one prize */
    int ri = (v >> 32) - a * 10;
    
    /* one goal */
    unsigned long long int ret = (a << 32) + b + rest_add[ri];
    
    /* one golden glance */
    if (ret * 10L > v) {
        //printf("OGG %llu %llu\n", ret * 10, v);
        --ret;
    }
    
    /* of what should be */
    return ret;
}

Деление на 10. Но зачем? Неужели компилятор настолько туп, что сам не может этого сделать?
И да, эти туповатые комментарии one dream, one soul это отсылка к песне Queen - A Kind of Magic https://youtu.be/0p_1QSUsbsM

j123123, 03 Марта 2018

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

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

+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

typedef unsigned int uint;

uint inc(uint i) {
    return i+1;
}
uint dec(uint i) {
    return i-1;
}
uint add(uint a, uint b) {
    return 0==b ? a : add(inc(a),dec(b));
}

inline uint _mul(uint a, uint b, uint r) {
    return 0==b ? r : _mul(a,b-1,r+a);
}
uint mul(uint a, uint b) {
    return _mul(a,b,0);
}

uint dec_mul(uint a, uint b, uint r) {
    return 0==b ? r : dec_mul(a,dec(b),r+a);
}

//gcc 7 здесь сходит с ума на O3, шланг невозмутимо ставит  imul    edi, esi
uint crazy_mul(uint a, uint b, uint r) {
    return 0==b ? r : crazy_mul(a,dec(b),add(r,a));
}
//арифметическая прогрессия. 
inline uint _sum(uint a,uint s) {
    return a==0 ? s :_sum(a-1,s+a);
}
//gcc: сложна нипанятна
uint sum(uint a) {
    return _sum(a,0);
}
//шланг:
//        imul    rcx, rax
//        shr     rcx
uint sum1(uint a) {
    uint s=0;
    for (int i=0;i<a;++i){
        s+=i;
    }
    return s;
}

Смотрим как компиляторы решают разные упоротые рекурентные задачки.
https://godbolt.org/g/4JZuPr

3.14159265, 27 Февраля 2018

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

Говнокод: по колено в коде.