Этот вызов создан в честь моего первого эзотерического языка, Backhand !

Backhand - это одномерный язык с нелинейным потоком указателей. Указатель перемещается по три шага за раз, выполняя только каждую третью инструкцию.

Программа 1..1..+..O..@добавит 1 + 1 и вывод 2 до завершения. Промежуточные инструкции пропущены, поэтому 1<>1()+{}O[]@точно такая же программа.

Когда указатель собирается сойти с конца ленты, он вместо этого меняет направление и переходит в другую сторону, 1.@1.O+.как и та же программа. Обратите внимание, что он считает команду завершения только один раз. Это позволяет нам сжимать большинство линейных программ, таких как1O+1@

Ваша задача здесь состоит в том, чтобы написать программу или функцию, которая принимает строку и выводит инструкции, которые были бы выполнены, если бы программа была интерпретирована как Backhand (вам не нужно обрабатывать какие-либо фактические инструкции Backhand). Вы должны выводить только до тех пор, пока указатель не окажется на последнем символе строки (после чего выполнение обычно будет идти назад).

Но подождите , это еще не все! Когда ваша программа интерпретируется таким образом, результирующий код должен вывести одно из следующих:

• (Mostly) works
• Turing complete
• 'Recreational' (кавычки могут быть или 'или ", но не оба)
• Perfectly okay
• Only a few bugs

Например, если у вас есть исходный код code 2 backhand, программа ce cankb od2ahdдолжна вывести одну из этих фраз.

Тестовые случаи:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

И справочная программа, написанная, конечно же, в Backhand ( это может быть немного глючно. Хорошо, я думаю, что я это исправил).

Правила.

• Стандартные лазейки запрещены
• Ввод первой программы будет содержать только ASCII для печати и переноса строк (то есть байты 0x20- 0x7Eтак же как 0x0A)
• Вы можете выбрать, будет ли ваша вторая программа преобразована из вашей первой байтами или символами UTF-8.
• Вторая программа:
  • Дело не имеет значения, поэтому ваш вывод может быть, pErFectLy OKayесли хотите.
  • Любое количество конечных / ведущих пробелов (перевод строки, табуляция, пробелы) также в порядке.
  • Вторая программа должна быть того же языка, что и первая, но не обязательно того же формата (программа / функция)
  • Я рад включить предложения из комментариев на дополнительные фразы (если они не слишком короткие)
• Так как это код-гольф , ваша цель - получить кратчайший ответ для вашего языка!
• Через две недели я присуду 200 наград за самый короткий ответ.

R 187 байт

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

Попробуйте онлайн!

Единственный пробел в конце необходим, чтобы \nникогда не печататься, когда программа применяется к себе.

объяснение

Часть 1:

Ungolfed:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

Часть 2:

Функция производит это, когда она действует на всю программу:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Python 2 , 163 130 127 121 115 99 96 байт

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

Попробуйте онлайн!

Выходы:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Perl 6 , 101 86 байт

Вау, -25 байт благодаря nwellnhof, радикально улучшив первую программу

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

Попробуйте онлайн!

Я надеюсь, что больше людей воспользуются преимуществом такого отскока. Backhandded программа является

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

Который комментирует просто {"(Mostly) works"}.

05AB1E , 43 40 38 37 байтов

-2 байта (40 → 38) благодаря @Emigna .

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

Попробуйте онлайн . (PS: переключить язык с 05AB1E (прежняя версия) на 05AB1E для контрольного примера 0123456789. версия работает быстрее, но показывает неверные результаты для вводов с ведущими нулями.)

Программа «backhandded» станет:

„ÃеÝ[N© I#N#

Который будет выводиться perfectly okayв полном нижнем регистре.

Попробуйте онлайн.

Пояснение базовой программы:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

Пояснение «закулисная» программа:

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

Шаг за шагом происходит следующее:

1. „ÃеÝ: STACK становится ["perfectly okay"]
2. [: Запустить бесконечный цикл
3. (первая итерация цикла) N©: STACK становится["perfectly okay", 0]
4. (первая итерация цикла) I: STACK остается["perfectly okay", 0] потому что нет ввода
5. (первая итерация цикла) #: STACK становится["perfectly okay"] , и цикл продолжается
6. (первая итерация цикла) N: STACK становится["perfectly okay", 0]
7. (первая итерация цикла) #: STACK становится["perfectly okay"] , и цикл продолжается
8. (вторая итерация цикла) N©: STACK становится["perfectly okay", 1]
9. (вторая итерация цикла) I: STACK остается["perfectly okay", 1] потому что нет ввода
10. (вторая итерация цикла) #: STACK становится ["perfectly okay"], и цикл прерывается из-за 1(правдивости)
11. Неявно печатает вершину стека в STDOUT: perfectly okay

Смотрите шаги здесь с включенным отладчиком на TIO.

Смотрите этот 05AB1E наконечник шахты (раздел Как использовать словарь? ) , Чтобы понять , почему „€€Ã€„Ѐ€µ'€Ýэто the pointed, dm oneи beenи „ÃеÝесть perfectly okay.

Старая 38-байтовая версия:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

Попробуйте онлайн . (PS: переключите язык с 05AB1E (устаревший) на 05AB1E для тестовых случаев 0123456789и@ . Унаследованная версия работает быстрее, но показывает неверные результаты для вводов с ведущими нулями или .)

Программа «backhandded» станет:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(Где qвыходит из программы и делает все остальное без операции.)

Попробуйте онлайн.

Python 2 , 130 байт

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

Попробуйте онлайн!

JavaScript (ES6), 130 байт

Ранняя попытка. Не очень сытно.

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

Попробуйте онлайн!

Когда код обрабатывается сам по себе, следующие символы изолируются:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

который дает:

f=>"Perfectly okay"//…

Желе , 34 байта

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

Полная программа или монадическая ссылка, принимающая список символов, которые печатаются или выдаются (соответственно).

Попробуйте онлайн! Или посмотрите набор тестов .

Код, разобранный от руки, тогда:

Jȧ“N2s]Ỵ»ị@€

Полная программа или ниладическая ссылка печатаются или выдаются (соответственно) по Тьюрингу .

Как?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

тогда код, разобранный слева направо:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Рунические чары , 294 байта

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

Попробуйте онлайн!

Несжатая (и почти читаемая) версия:

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

Попробуйте онлайн!

Это ... как можно ближе.

Дальнейшее его сжатие потребовало бы определения способа обработки различных точек перестановки циклов, чтобы они не сталкивались с другими объектами. Первая строка (которая является единственной частью, которую необходимо передать как входные данные для себя) должна оставаться отдельной: вся строка не может поместиться во второй строке, не вызывая проблем ( _для требуемых пробелов):

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

Это ?не может быть удалено от того, !которое само по себе не может быть удалено от\ и ни одно из допустимых сообщений не позволяет ни одному из этих трех символов в этой позиции.

Альтернативой может быть использование перенаправления потока, но это приводит к проблеме в нижней строке:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

Как мы должны избегать переключателя цикла в основной программе.

Известные вопросы:

• Чрезвычайно большие входы. Из-за ограничений IP-стека в Runic, нажатие на очень большие входные строки приведет к истечению срока действия IP-адреса до его завершения. Это можно минимизировать, создавая дополнительные IP-адреса и объединяя их (например, он обрабатывает, abcdefghijklmnopqrstuvwxyzно не весь собственный источник). И есть предел, независимо от того, сколько происходит слияний. Может обрабатывать до 58 байтов ввода как есть (кроме того, для увеличения количества IP-адресов необходимо выяснить, как заставить их объединяться, не занимая больше места). Можно разместить еще две записи IP на линии возврата петли (справа от Uстроки, начинающейся \y<<в несжатой версии, или одну слева от строки выше y<<в сжатой версии), увеличив максимальную длину ввода до 78.
• Входные строки с пробелами должны быть экранированы (например 1\ \ 1\ \ +\ \ O\ \ @). Это ограничение синтаксического анализа ввода языка.
• Невозможно предоставить входные данные, состоящие из строк, которые выглядят как целые числа, начинающиеся с любого числа 0s (например, при преобразовании в число в стеке значение 0теряется). Опять же, ограничение синтаксического анализа ввода языка.

Как это устроено

Вступление:

1. Объедините 4 указателя инструкций
2. Чтение ввода, разбиение на символы, добавление новой строки, реверс, ввод основного цикла.

Основной цикл (все, что появляется в стеке, предшествует дублированию):

1. Распечатать верхнюю часть стопки
2. Сравните с новой строкой. True: переключать циклы и вращать стек влево дважды.
3. Сравните с @. Верно: прекратить. (Завершить команду выполнено)
4. Повернуть стек вправо
5. Сравните с новой строкой. Верно: прекратить. (Выполнена самая правая команда)
6. Повернуть стек вправо
7. Сравните с новой строкой. True: переключать циклы и вращать стопку влево трижды.
8. Повернуть стек вправо
9. Вернуться к началу цикла

Вторичный цикл:

• Идентичен основному контуру, только переключатель вращается вправо с поворотом влево