- 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;
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+1
#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
Ничо нипанятна...
+1
x & (x-1);
Написавший это утверждает, что меняется содержимое памяти, но как происходят эти мистические изменения он объяснить не может.
−10
Вопрос
Кто знает, как динамически выделить память, заполнить её нужными инструкциями, и исполнить этот код, не испытав при этом анальной боли и не получить Segmentation Fault ?
0
// ...
int datastack [ 4096 ] ;
int *dp = datastack ;
int push ( int x ) {
return *dp++ = x ;
}
int pop() {
return *--dp ;
}
// ...
void execute() {
((void(*)())pop())() ;
}
// ...
Мама! Мама! Я покакал!
0
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, что читает операндыы.
+5
#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
0
#include <stdio.h>
int main(void) {
int i = 0;
loop:
i > 10 || printf("%d\n", i++) && goto loop;
printf("end\n");
return 0;
}
Зачем удолили #24105?
+1
#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 простых правил и бесконечный вывод триллиардов иттерация которые никогда не кнчатся! ЭТО НОНСЕНС
+2
// 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
+2
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