1. Си / Говнокод #15980

    +131

    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
    #include <stdio.h>
    #include <stdint.h>
    
    #define ARR_L 11
    #define INS_P (arr[0])
    #define MOD_L(a) ((a) % ARR_L)
    #define INS_P_M (MOD_L(INS_P))
    #define ARR_ACS(a) (arr[MOD_L(a)]) //access to arr
    
    
    void foo (uint8_t *arr)
    {
      if (ARR_ACS(0) == 0)
      {
        printf("%u ", ARR_ACS(1));
        ARR_ACS(1) += ARR_ACS(2);
        ARR_ACS(0) = 1;
      }
      else
      {
        printf("%u ", ARR_ACS(2));
        ARR_ACS(2) += ARR_ACS(1);
        ARR_ACS(0) = 0;
      }
    
    }
    
    int main(void) {
      uint8_t arr[ARR_L] = {1,1,1,0,0,0,0,0,0,0,0};
      for (size_t a = 0; a < 13; a++)
      {
        foo(arr);
      }
      return 0;
    }

    Считалка чисел Фибоначчи на основе фигни, придуманной в http://govnokod.ru/15967
    Надо сделать метаязык для удобного составления набора инструкций для этой штуки. И еще надо осилить длинную арифметику, ну это вообще круто будет

    Запостил: j123123, 14 Мая 2014

    Комментарии (9) RSS

    • Можно еще обфусцировать это через тернарные операции, чтобы круче выглядело
      void foo (uint8_t *arr)
      {
        printf("%u ", ARR_ACS(ARR_ACS(0) == 0 ? 1 : 2));
        ARR_ACS(ARR_ACS(0) == 0 ? 1 : 2) += ARR_ACS(ARR_ACS(0) == 0 ? 2 : 1);
        ARR_ACS(0) = ARR_ACS(0) == 0 ? 1 : 0;
      }
      Ответить
      • Для усиления бреда:
        #define ARR_ACST(a, b, c) ARR_ACS(0) == a ? b : c
        #define ARR_ACSS(a, b, c) ARR_ACS(ARR_ACST(a, b, c))
        
        void foo(uint8_t *arr)
        {
            printf("%u ", ARR_ACSS(0, 1, 2));
            ARR_ACSS(0, 1, 2) += ARR_ACSS(0, 2, 1);
            ARR_ACS(0) = ARR_ACST(0, 1, 0);
        }
        Ответить
    • Длинная арифметика медленная. Пили 100500-битный процессор.
      Ответить
      • > Пили 100500-битный процессор.
        Который будет еще медленнее. Т.к. мелкие числа будет гонять через 100500битные регистры.
        Ответить
        • Можно регистры на куски понарезать, ну как эти RAX EAX AX AH AL в x86-64
          Ответить
          • Ну дык у x86_64 этих ступеней всего 4, а систему команд это уже неплохо раздувает, равно как и схемотехнику... А тут таких ступеней будет овердохуя...
            Ответить
        • Мелкие через мелкие, не мелкие через не мелкие.
          Ответить

    Добавить комментарий