- 1
- 2
- 3
- 4
- 5
const size_t page_num = 2000000;
const size_t page_size = sysconf(_SC_PAGE_SIZE);
assert(page_size == 4096);
const size_t buf_len = page_num * page_size;
size_t tmp = 0;
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
const size_t page_num = 2000000;
const size_t page_size = sysconf(_SC_PAGE_SIZE);
assert(page_size == 4096);
const size_t buf_len = page_num * page_size;
size_t tmp = 0;
Того рот ебал, пыхамакаки в деле
+1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define SQARESZ 3
void rotateclockwise(char *ptra, size_t sz)
{
char (*a_ar)[sz] = (void *)ptra;
char b_ar[sz][sz];
for (size_t y = 0; y < sz; y++)
{
for (size_t x = 0; x < sz; x++)
{
b_ar[y][x] = a_ar[sz-1-x][y];
}
}
memcpy(a_ar, b_ar, sz*sz);
}
void print_ar(char *ptra, size_t sz)
{
char (*a_ar)[sz] = (void *)ptra;
for (size_t y = 0; y < sz; y++)
{
for (size_t x = 0; x < sz; x++)
{
printf("%i ", a_ar[y][x]);
}
printf("\n");
}
}
int main()
{
char a[SQARESZ][SQARESZ] =
{
{1,2,3},
{4,5,6},
{7,8,9}
};
print_ar((char *)a, SQARESZ);
printf("\n");
rotateclockwise((char *)a, SQARESZ);
print_ar((char *)a, SQARESZ);
printf("\n");
rotateclockwise((char *)a, SQARESZ);
print_ar((char *)a, SQARESZ);
printf("\n");
rotateclockwise((char *)a, SQARESZ);
print_ar((char *)a, SQARESZ);
printf("\n");
rotateclockwise((char *)a, SQARESZ);
print_ar((char *)a, SQARESZ);
printf("\n");
return 0;
}
https://habr.com/post/317300/ В C++17 до сих пор нет нормальных многомерных массивов, которые были в Fortran начиная с Fortran 90
> UPD от 2016-12-10 14:03. Посмотрел на этот коммент от @selgjos, поэкспериментировал с компилятором и понял, что с помощью C99 VLA всё-таки можно добиться нужного мне эффекта.
> В общем, окей, в C есть нужные мне массивы. Как и в Fortran. А в C++ их по-прежнему нет.
+4
typedef void proc();
proc nop{}
void swap(int *a, int *b) {*a^=*b^=*a^=*b;}
void sort_(int *arr, unsigned len)
{
(proc*[]){nop, swap}[*arr > arr[1]](arr, arr+1);
(proc*[]){nop, sort_}[len > 2](arr+1, len-1);
}
void sort(int *arr, unsigned len)
{
(proc*[]){sort_, nop}[len <= 1](arr, len);
(proc*[]){nop, sort}[len > 2](arr, len-1);
}
По поводу апнутого #19105.
Ветвление легко имитируеься массивом функий, цикол —– рукурсией. Получилось даже короче и понятнее чем обычный код.
+2
#include <stdio.h>
typedef int return;
typedef char *break;
typedef return continue(return argc, break *argv);
continue main
{
break s = "Именно поэтому я за \"Си\"";
puts(s);
}
В моём любимом tcc работает
0
enum crap
{
shit = 0,
fuck,
dick,
ass,
turd,
fart,
};
static char *crap_to_str(int crap)
{
switch (crap)
{
case shit:
{
return "shit";
}
case fuck:
{
return "fuck";
}
case dick:
{
return "dick";
}
case ass:
{
return "ass";
}
case turd:
{
return "turd";
}
case fart:
{
return "fart";
}
default:
{
return "!!!UNKNOWN CRAP!!!";
}
}
}
Есть ли возможность через какую-нибудь плюсовую метушню с шаблонами, констэспрами и препроцессором нагенерировать подобную хрень из готового определения структуры?
0
#include <stdio.h>
#include <conio.h>
int main()
{
int c;
while (1)
{
c=getch();
printf("%c",c/20);
}
return 0;
}
Шифратор 228
+3
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
enum {
HOST = INADDR_LOOPBACK,
PORT = 6666,
MAX_BUF = 1024
};
struct sock {
int sockfd;
int addrlen;
struct sockaddr_in addr;
} host, client;
int check(int x, char*msg)
{
if (!~x) {
perror(msg);
exit(1);
}
return x;
}
#define QUOTE_(...) #__VA_ARGS__
#define QUOTE(...) QUOTE_(__VA_ARGS__)
#define CHECK(...) check(__VA_ARGS__, QUOTE(line __LINE__: __VA_ARGS__))
int main(int argc, char**argv)
{
struct sock host, client;
host.sockfd = CHECK(socket(AF_INET, SOCK_STREAM, 0)),
host.addr = (struct sockaddr_in){AF_INET, htons(PORT), htonl(HOST)};
CHECK(bind(host.sockfd, &(struct sockaddr)host.addr, sizeof(host.addr)));
CHECK(listen(host.sockfd, 1));
CHECK(client.sockfd = accept(host.sockfd, (void*)&client.addr, &client.addrlen));
printf("connected: %s\n", inet_ntoa(client.addr.sin_addr));
struct {int len; char buf[MAX_BUF];} msg;
while (CHECK(msg.len = recv(client.sockfd, msg.buf, MAX_BUF - 1, 0)) && msg.len) {
msg.buf[msg.len] = 0;
printf("%s", msg.buf);
send(client.sockfd, msg.buf, msg.len, 0);
}
close(client.sockfd);
close(host.sockfd);
return 0;
}
Почему если закоментить 36-ю строчку адрес килента 0.0.0.0?
+4
#include <stdio.h>
#include <inttypes.h>
#include <stddef.h>
void printuint64(const uint64_t state);
uint64_t game_of_life8x8(const uint64_t old);
uint8_t getbit(uint64_t in, uint8_t y, uint8_t x);
uint8_t getbit(uint64_t in, uint8_t y, uint8_t x)
{
return !!((in) & (1ULL << ((y&0b111) + (x&0b111)*8)) );
}
uint64_t setbit(uint8_t y, uint8_t x, uint8_t bit)
{
if (bit)
{
return 1ULL << ((y&0b111) + (x&0b111)*8);
}
return 0;
}
uint64_t game_of_life8x8(const uint64_t old)
{
uint64_t new_state = 0;
#define GETBIT(y,x,val) getbit(val, y, x)
#define SETBIT(y,x,bit) setbit(y,x,bit)
#define SUMAROUND(y,x,val) ( \
GETBIT(y+1,x,val) + GETBIT(y-1,x,val) \
+ GETBIT(y,x+1,val) + GETBIT(y,x-1,val) \
+ GETBIT(y+1,x+1,val) + GETBIT(y+1,x-1,val) \
+ GETBIT(y-1,x+1,val) + GETBIT(y-1,x-1,val) \
)
#define CELLSTATE(y,x,val) \
(GETBIT(y,x,old) == 1 ? \
( ((SUMAROUND(y,x,val) == 2 ) || ( SUMAROUND(y,x,val) == 3 )) ? 1 : 0) \
: \
( ( SUMAROUND(y,x,val) == 3 ) ? 1 : 0 ) \
)
#define SETCELL_SH(y,x,val) SETBIT(y,x,CELLSTATE(y,x,val))
#define FILL_LINE(y) \
SETCELL_SH(y,7,old) | SETCELL_SH(y,6,old) | SETCELL_SH(y,5,old) | \
SETCELL_SH(y,4,old) | SETCELL_SH(y,3,old) | SETCELL_SH(y,2,old) | \
SETCELL_SH(y,1,old) | SETCELL_SH(y,0,old)
new_state = FILL_LINE(7) | FILL_LINE(6) | FILL_LINE(5)
| FILL_LINE(4) | FILL_LINE(3) | FILL_LINE(2)
| FILL_LINE(1) | FILL_LINE(0);
return new_state;
}
void printuint64(const uint64_t state)
{
for (size_t i = 7; i != SIZE_MAX; i--)
{
for (size_t j = 7; j != SIZE_MAX; j--)
{
printf("%u", !!((state >> (j+i*8)) & 1) );
}
printf("\n");
}
}
int main(void)
{
// Glider
uint64_t state =
(( 0b01000000ULL ) << 8*7 ) |
(( 0b00100000ULL ) << 8*6 ) |
(( 0b11100000ULL ) << 8*5 ) |
(( 0b00000000ULL ) << 8*4 ) |
(( 0b00000000ULL ) << 8*3 ) |
(( 0b00000000ULL ) << 8*2 ) |
(( 0b00000000ULL ) << 8*1 ) |
(( 0b00000000ULL ) << 8*0 );
for (size_t i = 0; i < 50; i++)
{
printuint64(state);
state = game_of_life8x8(state);
printf("\n");
}
return 0;
}
Conway's game of life внутри uint64_t (8 на 8) с периодическими граничными условиями.
0
UCSR0A |= TXC0_MASK;
UDR0 = value;
while ((UCSR0A & TXC0_MASK) == 0)
;
The TXCn flag ... can be cleared by writing a one to its location.
Cleared by writing one, Carl.
+1
#include <stdio.h>
#include <inttypes.h>
#include <string.h>
typedef struct
{
uint8_t arr[10];
uint8_t pos;
uint8_t is_swap;
} arr10;
arr10 bubble_sort_recursion(arr10 a);
void bubble_sort (uint8_t arr[static 10]);
void bubble_sort (uint8_t arr[static 10])
{
arr10 a;
memcpy(a.arr, arr, sizeof(a.arr));
a.pos = 0;
a.is_swap = 0;
a = bubble_sort_recursion(a);
memcpy(arr, a.arr, sizeof(a.arr));
}
arr10 bubble_sort_recursion(arr10 a)
{
if (a.pos != 9)
{
if (a.arr[a.pos] > a.arr[a.pos + 1])
{
uint8_t tmp = a.arr[a.pos + 1];
a.arr[a.pos + 1] = a.arr[a.pos];
a.arr[a.pos] = tmp;
a.is_swap = 1;
}
a.pos++;
return bubble_sort_recursion(a);
}
else
{
if (a.is_swap == 0)
{
return a;
}
else
{
a.pos = 0;
a.is_swap = 0;
return bubble_sort_recursion(a);
}
}
}
int main(void)
{
uint8_t arr[10] = {244, 90, 254, 109, 33, 85, 69, 81, 126, 71};
bubble_sort(arr);
printf("%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8,
arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9]);
return 0;
}
Рекурсивная сортировка пузырьком