Цей виклик створений на святкуванні моєї першої езотеричної мови, бекхенд !

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:

Безголівки:

 # 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.

Спробуйте в Інтернеті!

Я сподіваюся, що більше людей скористаються подібним відскоком. Програма Backhanded є

#{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. Спадкова версія швидша, але показує неправильні результати для введення чисел з провідними нулями.)

Програма "бекхенд" стане:

„ÃеÝ[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(truthy)
11. Неналежненько друкує верхню частину стека до STDOUT: perfectly okay

Ознайомтеся з кроками, у яких увімкнено відладчик на TIO.

Дивіться цей 05AB1E наконечник шахти (розділ Як користуватися словником? ) , Щоб зрозуміти , чому „€€Ã€„Ѐ€µ'€Ýце the pointed, dm oneі beenта „ÃеÝє perfectly okay.

Стара 38-байтна версія:

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

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

Програма "бекхенд" стане:

„ÃÐµÝ 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€

Повна програма або монадичне посилання, що приймає список символів, які друкують або отримують (відповідно).

Спробуйте в Інтернеті! Або подивіться тестовий набір .

Код, який розбирає Backhand, є:

Jȧ“N2s]Ỵ»ị@€

Повна програма або друк з ніладієвої посилання або вихід (відповідно) Turing завершений .

Як?

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)

Код, який розбирається в backhand, є:

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-стеку в рунічному режимі, натискання дуже великих вхідних рядків призведе до закінчення терміну дії IP до завершення. Це можна звести до мінімуму, нерестуючи додаткові IP-адреси та об'єднавши їх (наприклад, він обробляє, abcdefghijklmnopqrstuvwxyzале не всю власну частину джерела). І існує межа незалежно від кількості злиття. Може обробляти до 58 байтів вхідних даних (крім того, збільшення кількості ІР вимагає з'ясувати, як змусити їх об'єднатись, не використовуючи більше місця). Може вмістити ще два IP-адреси в циклі повернення циклу (праворуч від Uрядка, що починається \y<<в нестисненій версії, або один зліва над рядком вище y<<у стисненій версії), збільшивши максимальну довжину введення до 78.
• Для введення рядків з пробілами потрібно уникати пробілів (наприклад 1\ \ 1\ \ +\ \ O\ \ @). Це обмеження синтаксичного розбору мови.
• Неможливо подати входи, що складаються з рядків, схожих на цілі числа, що починаються з будь-якої кількості 0s (як коли перетворюється на число в стеку, значення 0втрачається). Знову ж таки, обмеження розбору мови введення.

Як це працює

Вхід:

1. Поєднайте 4 вказівних інструкції
2. Прочитайте введення, розбийте символи, додайте новий рядок, поверніть назад, введіть основний цикл.

Основний цикл (усьому, що вискакує стек, передує дубль):

1. Роздрукуйте верхню частину стека
2. Порівняйте з новим рядком. Правда: перемикайте петлі та обертайте стек вліво двічі.
3. Порівняйте з @. Правда: припинити. (Команда припинити виконання)
4. Поверніть стек праворуч
5. Порівняйте з новим рядком. Правда: припинити. (Команда праворуч виконується)
6. Поверніть стек праворуч
7. Порівняйте з новим рядком. Правда: перемикайте петлі і обертайте стек вліво тричі.
8. Поверніть стек праворуч
9. Повернення до вершини циклу

Вторинна петля:

• Ідентично основній петлі, лише перемикач обертається праворуч, обертаючи ліворуч