1. Python / Говнокод #24129

    0

    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
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    def calc ( x ) :
        if type ( x ) is not list :
            return x
        if len ( x ) == 0 :
            return x
        while type ( x [ 0 ] ) is list :
            x = x [ 0 ] + x [ 1: ]
        c = x [ 0 ]
        print ( x )
        if c == 'I' :
            if len ( x ) <= 1 :
                return x
            return calc ( x [ 1: ] )
        elif c == 'K' :
            if len ( x ) <= 2 :
                return x
            return calc ( [ x[1] ] + x [ 3: ] )
        elif c == 'W' :
            if len ( x ) <= 2 :
                return x
            return calc ( x[1:3] + x[ 2: ] )
        elif c == 'S' :
            if len ( x ) <= 3 :
                return x
            return calc ( [ x[1] , x [3] , [ x[2] , x[3] ] ] + x [ 4: ] )
        elif c == 'B' :
            if len ( x ) <= 3 :
                return x
            return calc ( [ x[1] , [ x[2] , x[3] ] ] + x[4:] )
        elif c == 'C' :
            if len ( x ) <= 3 :
                return x
            return calc ( [ x[1] , x[3] , x[2] ] + x[ 4 : ] )
        return [ c ] + calc ( x [ 1: ] )
    
    
    def parse ( s , n = 0 ) :
      res = []
      i = n
      while i < len ( s ) :
        if s [ i ] == '(' :
          t = parse ( s , i + 1 )
          res.append ( t [ 0 ] )
          i = t [ 1 ] - 1
        elif s [ i ] == ')' :
          return ( res , i + 1 )
        else :
          res.append ( s [ i ] )
        i += 1
      return ( res , i )
    
    print ( '>> ' , end = '' )
    while True :
        for i in calc ( parse ( input() ) [ 0 ] ) :
            print ( i , end = '' )
        print ( '\n>> ' , end = '' )

    Вычисляэ комбинаторныэ термы, и выдаё промежности, типа:

    >> S(SKK)(SKK)x
    ['S', ['S', 'K', 'K'], ['S', 'K', 'K'], 'x']
    ['S', 'K', 'K', 'x', [['S', 'K', 'K'], 'x']]
    ['K', 'x', ['K', 'x'], [['S', 'K', 'K'], 'x']]
    ['x', [['S', 'K', 'K'], 'x']]
    ['S', 'K', 'K', 'x']
    ['K', 'x', ['K', 'x']]
    ['x']
    xx

    Запостил: yet_another_one_shit, 16 Апреля 2018

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

    • Тебе помогут только долгие и уПОРНые тренировки
      Ответить
    • Човаки, я тут понял, что мне неча выкладывать, я никогда не писал говна.
      Ответить
    • >> COCuCKA
      ['C', 'O', 'C', 'u', 'C', 'K', 'A']
      ['O', 'u', 'C', 'C', 'K', 'A']
      ['u', 'C', 'C', 'K', 'A']
      ['C', 'C', 'K', 'A']
      ['C', 'A', 'K']
      OuCAK
      >> KAKAWKA
      ['K', 'A', 'K', 'A', 'W', 'K', 'A']
      ['A', 'A', 'W', 'K', 'A']
      ['A', 'W', 'K', 'A']
      ['W', 'K', 'A']
      ['K', 'A', 'A']
      ['A']
      AAA
      >> PISYA
      ['P', 'I', 'S', 'Y', 'A']
      ['I', 'S', 'Y', 'A']
      ['S', 'Y', 'A']
      PSYA
      >> COCOCO PETUSHOK
      ['C', 'O', 'C', 'O', 'C', 'O', ' ', 'P', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['O', 'O', 'C', 'C', 'O', ' ', 'P', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['O', 'C', 'C', 'O', ' ', 'P', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['C', 'C', 'O', ' ', 'P', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['C', ' ', 'O', 'P', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      [' ', 'P', 'O', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['P', 'O', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['O', 'E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['E', 'T', 'U', 'S', 'H', 'O', 'K']
      ['T', 'U', 'S', 'H', 'O', 'K']
      ['U', 'S', 'H', 'O', 'K']
      ['S', 'H', 'O', 'K']
      ['H', 'K', ['O', 'K']]
      ['K', ['O', 'K']]
      OO POETUHK['O', 'K']
      >>
      Ответить
      • А давайте все юзернеймы с ГК протестируем!
        Ответить
        • >> CHayT
          ['C', 'H', 'a', 'y', 'T']
          ['H', 'y', 'a', 'T']
          ['y', 'a', 'T']
          ['a', 'T']
          ['T']
          HyaT
          Ответить
        • >> CTEPTOP
          ['C', 'T', 'E', 'P', 'T', 'O', 'P']
          ['T', 'P', 'E', 'T', 'O', 'P']
          ['P', 'E', 'T', 'O', 'P']
          ['E', 'T', 'O', 'P']
          ['T', 'O', 'P']
          ['O', 'P']
          ['P']
          TPETOP
          >>


          ЗЫ. print из функции calc можно убрать, он отладочный.
          Ответить
    • Нихуя не понял
      Ответить
      • Чиво, Пусичька?
        Ответить
      • https://ru.wikipedia.org/wiki/Комбинаторная_логика

        I, K, W, S, B, C — это операторы комбинаторной логики. Программа упрощает их композицию.
        Ответить
        • I x = x
          K x y = x
          S x y z = x z (y z)
          C f g x = (f x) g
          B f g x = f (g x)
          W x y = (x y) y
          U x y = y (x x y)
          ω x = x x 
          Ω = ω ω
          YX = X(Y X)
          Ответить
          • Добавил U-комбинатор:
            elif c == 'U' :
                    if len ( x ) <= 2 :
                        return x
                    return calc ([x[2],  [x[1] , x[1] , x[2]]] + x[3:] )

            Кто бы ещё Y-комбинатор добавил...
            Ответить
            • Сейчас добавим:
              elif c == 'Y' :
                      if len ( x ) <= 1 :
                          return x
                      return calc (['S',['K',['S','I','I']],['S',['S',['K','S'],'K'],['K',['S','I','I']]]] + x[2:])
              Ответить
              • На первом же слове с буквой "Y" упал:
                RecursionError: maximum recursion depth exceeded while getting the repr of an object
                Ответить
                • Тем не менее, уходит в рекурсию не всегда:
                  >> YOBA
                  B[[['K', ['S', 'I', 'I']], 'B'], ['I', [['S', ['S', ['K', 'S'], 'K'], ['K', ['S', 'I', 'I']]], 'B']]]A
                  Ответить
          • Есть ещё какие-нибудь широко распространённые обозначения кобенаторов, чтобы ещё несколько букв добавить?
            Ответить
        • Оджного йота-комбинатора должно быть достаточно каждому.
          Ответить
    • Очеловечил:
      def calc(x):
          if type(x) is not list:
              return x
          if len(x) == 0:
              return x
          while type(x[0]) is list:
              x = x[0] + x[1:]
          c = x[0]
          if c == 'I':
              if len(x) <= 1:
                  return x
              return calc(x[1:])
          elif c == 'K':
              if len(x) <= 2:
                  return x
              return calc([x[1]] + x[3:])
          elif c == 'W':
              if len(x) <= 2:
                  return x
              return calc(x[1:3] + x[2:])
          elif c == 'S':
              if len(x) <= 3:
                  return x
              return calc([x[1], x[3], [x[2], x[3]]] + x[4:])
          elif c == 'B':
              if len(x) <= 3:
                  return x
              return calc([x[1], [x[2], x[3]]] + x[4:])
          elif c == 'C':
              if len(x) <= 3:
                  return x
              return calc([x[1], x[3], x[2]] + x[4:])
          return [c] + calc(x[1:])
      
      def parse(s, n = 0):
          res = []
          i = n
          while i < len(s):
              if s[i] == '(':
                  t = parse(s, i + 1)
                  res.append(t[0])
                  i = t[1] - 1
              elif s [ i ] == ')':
                  return (res, i + 1)
              else:
                  res.append(s[i])
              i += 1
          return (res, i)
      
      def termrepr(x):
          if len(x) == 0:
              return ''
          if type(x[0]) is list:
              return '(' + termrepr(x[0]) + ')' + termrepr(x[1:])
          else:
              return x[0] + termrepr(x[1:])
      
      print('>> ', end = '')
      while True:
          print(termrepr(calc(parse(input())[0])))
          print('\n>> ', end = '')


      ***

      >> PETUSHOK
      PETUHK(OK)
      
      >> SSSSSSSSS
      SS((((((SS)S)S)S)S)S)

      Но всё равно, этот код – говно.
      Ответить
      • Спасибо. Добавил U и Y:
        elif c == 'U' :
                if len ( x ) <= 2 :
                    return x
                return calc ([x[2],  [x[1] , x[1] , x[2]]] + x[3:] )
            elif c == 'Y' :
                if len ( x ) <= 1 :
                    return x
                return calc (['S',['K',['S','I','I']],['S',['S',['K','S'],'K'],['K',['S','I','I']]]] + x[2:])


        Проверяем:

        >> YOBA
        B(((K(SII))B)(I((S(S(KS)K)(K(SII)))B)))A

        Совсем другое дело!
        Ответить
    • >> CANNIBAL CORPSE
      ANNAL OPRSE
      Ответить
      • >> ROSKOMGOVNO
        ROMGOVNO
        Ответить
        • > ROSKOMGOVNO
          Помоему тут баг, комбинаторы же применяются только когда они в начале выражения(если не ошибаюсь). Можно исправить, но тогда им будет неинтересно коверкать слова.
          Ответить
          • Да, тут с порядком действий что-то не так. Мы ничего не знаем про O. Если O — это тоже комбинатор, то всё сложно. В идеале должны стоять скобки, чтобы было видно, что к чему применяется, но тогда будет скучно.
            Ответить
          • Будем считать, что O — это омега-большая-кобенатор: Ω = ω ω, где ω x = x x.

            Тогда:
            elif c == 'O':
                    if len(x) <= 1:
                        return x
                    return calc([x[1], x[1], [x[1], x[1]]] + x[2:])


            >> ROSKOMGOVNO
            RMMMMGVVVVNO
            Ответить
    • Уменьшил число строк и упростил добавление новых кобенаторов:
      combinators = {
         'I': lambda x: x if len(x) < 1 else (x[0],) + calc(x[1:]),
         'K': lambda x: x if len(x) < 2 else calc((x[0],) + x[2:]),
         'W': lambda x: x if len(x) < 2 else calc(x[0:2] + x[2:]),
         'S': lambda x: x if len(x) < 3 else calc((x[0], x[2], (x[1], x[2])) + x[3:]),
         'B': lambda x: x if len(x) < 3 else calc((x[0], (x[1], x[2])) + x[3:]),
         'C': lambda x: x if len(x) < 3 else calc((x[0], x[2], x[1]) + x[3:]),
         'U': lambda x: x if len(x) < 2 else calc((x[1], (x[0], x[0], x[1])) + x[2:]),
      }
      
      def calc(x):
          if type(x) is not tuple or len(x) == 0:
              return x
          while type(x[0]) is tuple:
              x = x[0] + x[1:]
          #print(x)
          return combinators.get(x[0], lambda _: (x[0],) + calc(x[1:]))(x[1:])
      
      def parse(s, n = 0):
          res = ()
          i = n
          while i < len(s):
              if s[i] == '(':
                  t, j = parse(s, i + 1)
                  res += (t,)
                  i = j - 1
              elif s[i] == ')':
                  return (res, i + 1)
              else:
                  res += (s[i],)
              i += 1
          return (res, i)
      
      def termrepr(x):
          if len(x) == 0:
              return ''
          if type(x[0]) is tuple:
              return '(' + termrepr(x[0]) + ')' + termrepr(x[1:])
          else:
              return x[0] + termrepr(x[1:])
      
      print('>> ', end = '')
      while True:
          print(termrepr(calc(parse(input())[0])))
          print('\n>> ', end = '')

      Споки-ноки!
      Ответить
      • x = x[0] + x[1:]

        Лолшто?
        Ответить
        • # а шо не так?
          x = ((0,1), 2, 3)
          x = x[0] + x[1:] # топерича x = (0,1,2,3)
          Ответить
          • А ну да. Формат данных какой-то ебанутый.
            Ответить
      • >> SKOLKOVO
        LOO
        Ответить
      • BAGRATIONOVSK → AGRATONOVK
        BAKAL → AA
        BARNAUL → ARNAL
        BAKHCHISARAI → AHHSARA
        BAKHMUT → AHT
        BELOGORSK → ELOGORK
        BERDICHEV → ERDCHEV
        BERDYANSK → ERDYANK
        BIROBIDZHAN → (RO)(DZ)HAN
        BOBRUISK → OR(IIS)K
        BOGUCHAR → OGHARH
        BOLGAR → OLGAR
        BORISOGLEBSK → ORSOGLESK
        BRANDENBURG → RANDEN(RG)
        BROVARI → ROVAR
        BRAUNSCHWEIG → RANNHHEG
        BREMERHAVEN → REMERHAVEN
        BUGULMA → зацикливает (BUGURT тоже зацикливает)
        BUDAPEST → PDADAPET
        BUCURESTI → RRREERRTT(((EE(RR(CU)))(TT(SS(EE(RR(CU)) ))))I)EERR((((EE(RR(CU)))(TT(SS(EE(RR(CU ))))))I)(((EE(RR(CU)))(TT(SS(EE(RR(CU))) )))I)I)
        Ответить
    • Поебанулись совсем со своими кобенаторами
      Ответить

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