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

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

−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

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

int main(void)
{
  char a[8], b[8];
  char *a_ptr = a+8;
  char *b_ptr = b;
  printf("a_ptr = %p, b_ptr = %p\n", a_ptr, b_ptr);
  if (a_ptr != b_ptr)
  {
    printf("a_ptr != b_ptr\n");
  }
  else
  {
    printf("a_ptr == b_ptr\n");
  }
  
  
  if ((uintptr_t)a_ptr != (uintptr_t)b_ptr)
  {
    printf("(uintptr_t)a_ptr != (uintptr_t)b_ptr\n");
  }
  else
  {
    printf("(uintptr_t)a_ptr == (uintptr_t)b_ptr\n");
  }
  return EXIT_SUCCESS;
}

Что по-вашему тут происходит?

j123123, 02 Февраля 2019

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

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

+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
59
60
61
62
63
64
65
66
67
68
69
70

/*
* Place the right command in the parameter AY temperature fine adjust
* Uses number from PPD less 11.
*/
switch (header->cupsCompression)
{
case 1 :
  strcpy(Fadjt,"{AY;-10,");
  break;
case 2 :
  strcpy(Fadjt,"{AY;-09,");
  break;
case 3 :
  strcpy(Fadjt,"{AY;-08,");
  break;
case 4 :
  strcpy(Fadjt,"{AY;-07,");
  break;
case 5 :
  strcpy(Fadjt,"{AY;-06,");
  break;
case 6 :
  strcpy(Fadjt,"{AY;-05,");
  break;
case 7 :
  strcpy(Fadjt,"{AY;-04,");
  break;
case 8 :
  strcpy(Fadjt,"{AY;-03,");
  break;
case 9 :
  strcpy(Fadjt,"{AY;-02,");
  break;
case 10 :
  strcpy(Fadjt,"{AY;-01,");
  break;
case 11 :
  strcpy(Fadjt,"{AY;+00,");
  break;
case 12 :
  strcpy(Fadjt,"{AY;+01,");
  break;
case 13 :
  strcpy(Fadjt,"{AY;+02,");
  break;
case 14 :
  strcpy(Fadjt,"{AY;+03,");
  break;
case 15 :
  strcpy(Fadjt,"{AY;+04,");
  break;
case 16 :
  strcpy(Fadjt,"{AY;+05,");
  break;
case 17 :
  strcpy(Fadjt,"{AY;+06,");
  break;
case 18 :
  strcpy(Fadjt,"{AY;+07,");
  break;
case 19 :
  strcpy(Fadjt,"{AY;+08,");
  break;
case 20 :
  strcpy(Fadjt,"{AY;+09,");
  break;
case 21 :
  strcpy(Fadjt,"{AY;+10,");
  break;
}

cykablyad, 31 Января 2019

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

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

+2

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

void add_SSE(uint8_t a[static 7], uint8_t b[static 7], uint8_t out[static 7])
{
  uint64_t a_64 = 0;
  uint64_t b_64 = 0;
  for (size_t i = 0; i < 7; i++) // можно наанроллить
  {
    a_64 |= (uint64_t)a[i] << (i*9);
    b_64 |= (uint64_t)b[i] << (i*9);
  }
  
  uint64_t c_64 = a_64 + b_64;
  
  for (size_t i = 0; i < 7; i++) // можно наанроллить
  {
    out[i] = (uint64_t)c_64 >> (i*9);
  }
}

SSE

j123123, 28 Января 2019

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

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

−3

1
2
3
4

void print_line(char *s){
    for(int i = 0; i < strlen(s); i++) putchar(s[i]);
    putchar('\n');
}

Почему C работает медленнее чем JavaScript ?

o8603054, 17 Января 2019

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

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

−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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

void sort8(uint64_t a[8])
{
  uint64_t a0;
  uint64_t a1;
  uint64_t a2;
  uint64_t a3;
  uint64_t a4;
  uint64_t a5;
  uint64_t a6;
  uint64_t a7;
 
  SORT2(a[0], a[1], a0, a1);
  SORT2(a[2], a[3], a2, a3);
  SORT2(a[4], a[5], a4, a5);
  SORT2(a[6], a[7], a6, a7);

  uint64_t a_tmp[8];

  MERGE_2_4(a0, a1, a2, a3, a_tmp[0], a_tmp[1], a_tmp[2], a_tmp[3]);
  MERGE_2_4(a4, a5, a6, a7, a_tmp[4], a_tmp[5], a_tmp[6], a_tmp[7]);

  uint64_t *ptra1 = &a_tmp[0];
  uint64_t *ptra2 = &a_tmp[4];
  
  for (size_t i = 0; i < 4; i++)
  {
    if (*ptra1 < *ptra2)
    {
      a[i] = *ptra1;
      ptra1++;
    }
    else
    {
      a[i] = *ptra2;
      ptra2++;
    }
  }

  for (size_t i = 4; i < 8; i++)
  {
    if (ptra1 == &a_tmp[4])
    {
      while (ptra2 != &a_tmp[8])
      {
        a[i++] = *ptra2;
        ptra2++;
      }
      break;
    }
    
    if (ptra2 == &a_tmp[8])
    {
      while (ptra1 != &a_tmp[4])
      {
        a[i++] = *ptra1;
        ptra1++;
      }
      break;
    }


    if (*ptra1 < *ptra2)
    {
      a[i] = *ptra1;
      ptra1++;
    }
    else
    {
      a[i] = *ptra2;
      ptra2++;
    }

  }
}

Мерж сорт, специализированный на 8 элементов. Вот доказательство корректности https://paste.debian.net/hidden/cce6d31a/

j123123, 13 Января 2019

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

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

0

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

void decode_chunk(const char* s, uint8_t* out)
{
    __m128i a = _mm_loadu_si128((const __m128i*)s);

    __m128i u = _mm_and_si128(a, _mm_set1_epi8(0x74));
    u = _mm_add_epi8(u, _mm_set1_epi8(0x04));
    u = _mm_srli_epi32(u, 0x03);
    u = _mm_and_si128(u, _mm_set1_epi8(0x0F));
    u = _mm_shuffle_epi8(_mm_set_epi32(0xB9B9B9B9, 0xBFBFBFBF, 0x04041013, 0x00000000), u);
    a = _mm_add_epi8(a, u);

    __m128i m1 = _mm_set1_epi32(0xFF00FF00);
    __m128i m2 = _mm_set1_epi32(0xFFFF0000);
    a = _mm_shuffle_epi8(a, _mm_set_epi32(0x00010203, 0x04050607, 0x08090A0B, 0x0C0D0E0F));
    a = _mm_or_si128(_mm_srli_epi32(_mm_and_si128(m1, a), 2), _mm_andnot_si128(m1, a));
    a = _mm_or_si128(_mm_srli_epi32(_mm_and_si128(m2, a), 4), _mm_andnot_si128(m2, a));
    a = _mm_shuffle_epi8(a, _mm_set_epi32(0x80808080, 0x00010204, 0x05060809, 0x0A0C0D0E));

    _mm_storeu_si128((__m128i*)out, a);
}

Байтоёбский парсинг base64 (16 символов → 12 байт).

По мотивам http://govnokod.ru/12822#comment173404

bormand, 09 Января 2019

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

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

+1

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100

int etm_readl_cp14(u32 reg, unsigned int *val)
{
	switch (reg) {
	case ETMCR:
		*val = etm_read(ETMCR);
		return 0;
	case ETMCCR:
		*val = etm_read(ETMCCR);
		return 0;
	case ETMTRIGGER:
		*val = etm_read(ETMTRIGGER);
		return 0;
	case ETMSR:
		*val = etm_read(ETMSR);
		return 0;
	case ETMSCR:
		*val = etm_read(ETMSCR);
		return 0;
	case ETMTSSCR:
		*val = etm_read(ETMTSSCR);
		return 0;
	case ETMTEEVR:
		*val = etm_read(ETMTEEVR);
		return 0;
	case ETMTECR1:
		*val = etm_read(ETMTECR1);
		return 0;
	case ETMFFLR:
		*val = etm_read(ETMFFLR);
		return 0;
	case ETMACVRn(0):
		*val = etm_read(ETMACVR0);
		return 0;
	case ETMACVRn(1):
		*val = etm_read(ETMACVR1);
		return 0;
	case ETMACVRn(2):
		*val = etm_read(ETMACVR2);
		return 0;
	case ETMACVRn(3):
		*val = etm_read(ETMACVR3);
		return 0;
	case ETMACVRn(4):
		*val = etm_read(ETMACVR4);
		return 0;
	case ETMACVRn(5):
		*val = etm_read(ETMACVR5);
		return 0;
	case ETMACVRn(6):
		*val = etm_read(ETMACVR6);
		return 0;
	case ETMACVRn(7):
		*val = etm_read(ETMACVR7);
		return 0;
	case ETMACVRn(8):
		*val = etm_read(ETMACVR8);
		return 0;
	case ETMACVRn(9):
		*val = etm_read(ETMACVR9);
		return 0;
	case ETMACVRn(10):
		*val = etm_read(ETMACVR10);
		return 0;
	case ETMACVRn(11):
		*val = etm_read(ETMACVR11);
		return 0;
	case ETMACVRn(12):
		*val = etm_read(ETMACVR12);
		return 0;
	case ETMACVRn(13):
		*val = etm_read(ETMACVR13);
		return 0;
	case ETMACVRn(14):
		*val = etm_read(ETMACVR14);
		return 0;
	case ETMACVRn(15):
		*val = etm_read(ETMACVR15);
		return 0;
	case ETMACTRn(0):
		*val = etm_read(ETMACTR0);
		return 0;
	case ETMACTRn(1):
		*val = etm_read(ETMACTR1);
		return 0;
	case ETMACTRn(2):
		*val = etm_read(ETMACTR2);
		return 0;
	case ETMACTRn(3):
		*val = etm_read(ETMACTR3);
		return 0;
	case ETMACTRn(4):
		*val = etm_read(ETMACTR4);
		return 0;
	case ETMACTRn(5):
		*val = etm_read(ETMACTR5);
		return 0;
	case ETMACTRn(6):
		*val = etm_read(ETMACTR6);
		return 0;
	...

Вроде и да, а вроде и нет

Ksyrx, 06 Января 2019

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

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

0

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;

Того рот ебал, пыхамакаки в деле

dicklover, 26 Декабря 2018

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

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

+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
59
60
61
62
63
64

#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++ их по-прежнему нет.

j123123, 26 Декабря 2018

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

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

+4

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

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.
Ветвление легко имитируеься массивом функий, цикол —– рукурсией. Получилось даже короче и понятнее чем обычный код.

Morgoth, 26 Декабря 2018

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

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