To wyzwanie powstało z okazji mojego pierwszego ezoterycznego języka, Backhand !

Język odręczny jest językiem jednowymiarowym z nieliniowym przepływem wskaźnika. Wskaźnik przesuwa się o trzy kroki naraz, wykonując tylko co trzecią instrukcję.

Program 1..1..+..O..@doda 1 + 1 i wyjście 2 przed zakończeniem. Instrukcje pośrednie są pomijane, więc 1<>1()+{}O[]@jest to dokładnie ten sam program.

Gdy wskaźnik ma zamiar zejść z końca taśmy, zamiast tego zmienia kierunek i przesuwa się w drugą stronę, podobnie jak [email protected]+.ten sam program. Zauważ, że liczy tylko instrukcję końcową tylko raz. To pozwala nam kompresować większość programów liniowych, takich jak1O+1@

Wyzwanie polega tutaj na napisaniu programu lub funkcji, która pobierze ciąg znaków i wyświetli instrukcje, które zostałyby wykonane, gdyby program był interpretowany jak Backhand (nie trzeba obsługiwać żadnych rzeczywistych instrukcji Backhand). Wyprowadzasz dane wyjściowe, dopóki wskaźnik nie wyląduje na ostatnim znaku ciągu (w tym momencie wykonanie normalnie byłoby cofane).

Ale czekaj , to nie wszystko! Gdy sam program jest interpretowany w ten sposób, wynikowy kod powinien wypisać jedno z poniższych:

• (Mostly) works
• Turing complete
• 'Recreational' (cytaty mogą być 'albo ", ale nie oba)
• Perfectly okay
• Only a few bugs

Na przykład, jeśli twój kod źródłowy to code 2 backhand, to program ce cankb od2ahdpowinien wypisać jedną z tych fraz.

Przypadki testowe:

"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)
"---!---!"       -> "-!-----!"

I program referencyjny napisany oczywiście w Backhand ( może to być trochę wadliwy. Ok, myślę, że to naprawiłem).

Zasady

• Standardowe luki są zabronione
• Dane wejściowe pierwszego programu będą zawierać tylko drukowalne ASCII i znaki nowej linii (to znaczy bajty 0x20- 0x7Ea także 0x0A)
• Możesz wybrać, czy drugi program ma być konwertowany z pierwszego bajtu, czy ze znaków UTF-8.
• Drugi program:
  • Wielkość liter nie ma znaczenia, więc wynik może być, pErFectLy OKayjeśli chcesz.
  • Każda ilość spacji końcowych / wiodących białych znaków (nowa linia, tabulatory, spacje) jest również w porządku.
  • Drugi program powinien być w tym samym języku co pierwszy, choć niekoniecznie ten sam format (program / funkcja)
  • Z przyjemnością dołączam sugestie z komentarzy do dodatkowych zwrotów (o ile nie są zbyt krótkie)
• Ponieważ jest to golf golfowy , Twoim celem jest uzyskanie najkrótszej odpowiedzi dla Twojego języka!
• Za dwa tygodnie przyznam 200 nagród za najkrótszą odpowiedź odręczną.

R 187 bajtów

 # 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='') 

Wypróbuj online!

Pojedyncza spacja na końcu jest potrzebna, aby \nnigdy nie została wydrukowana, gdy program zostanie zastosowany do siebie.

Wyjaśnienie

Część 1:

Nie golfowany:

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

Część 2:

Funkcja generuje to, gdy działa na cały program:

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

Python 2 , 163 130 127 121 115 99 96 bajtów

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)

Wypróbuj online!

Wyjścia:

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

Perl 6 , 101 86 bajtów

Wow, -25 bajtów dzięki nwellnhof dzięki drastycznemu ulepszeniu pierwszego programu

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

Wypróbuj online!

Mam nadzieję, że więcej osób skorzysta z takiego odbicia. Program Backhanded to

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

Które komentarze do just {"(Mostly) works"}.

05AB1E , 43 40 38 37 bajtów

-2 bajty (40 → 38) dzięki @Emigna .

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

Wypróbuj online . (PS: Zmień język z 05AB1E (starsza wersja) na 05AB1E dla przypadku testowego 0123456789. Starsza wersja jest szybsza, ale pokazuje niepoprawne wyniki dla wprowadzania liczb z wiodącymi zerami.)

Program „backhanded” będzie wyglądał następująco:

„ÃеÝ[N© I#N#

Które będą wyświetlać się perfectly okaymałymi literami.

Wypróbuj online.

Objaśnienie programu podstawowego:

„€€Ã€           # 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

Objaśnienie programu „odręcznie”:

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

Krok po kroku dzieje się:

1. „ÃеÝ: STOSOWANIE staje się ["perfectly okay"]
2. [: Uruchom nieskończoną pętlę
3. (pierwsza iteracja w pętli) N©: STOSOWANIE staje się["perfectly okay", 0]
4. (pierwsza iteracja w pętli) I: STOSOWANIE pozostaje, ["perfectly okay", 0]ponieważ nie ma danych wejściowych
5. (pierwsza iteracja pętli) #: STOSOWANIE staje się ["perfectly okay"], a pętla trwa
6. (pierwsza iteracja w pętli) N: STOSOWANIE staje się["perfectly okay", 0]
7. (pierwsza iteracja pętli) #: STOSOWANIE staje się ["perfectly okay"], a pętla trwa
8. (druga iteracja pętli) N©: STOSOWANIE staje się["perfectly okay", 1]
9. (druga iteracja pętli) I: STOSOWANIE pozostaje, ["perfectly okay", 1]ponieważ nie ma danych wejściowych
10. (druga iteracja pętli) #: STOSOWANIE staje się ["perfectly okay"], a pętla pęka z powodu 1(prawdy)
11. Domyślnie drukuje górę stosu do STDOUT: perfectly okay

Zobacz kroki tutaj z włączonym debuggerem na TIO.

Zobacz tę końcówkę 05AB1E kopalni (sekcja Jak używać słownika? ) , Aby zrozumieć, dlaczego „€€Ã€„Ѐ€µ'€Ýsą the pointed, dm onei beeni „ÃеÝjest perfectly okay.

Stara 38-bajtowa wersja:

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

Wypróbuj online . (PS: Przełącz język z 05AB1E (starsza wersja) na 05AB1E dla przypadków testowych 0123456789i @. Starsza wersja jest szybsza, ale pokazuje niepoprawne wyniki dla wprowadzania liczb z wiodącymi zerami lub wejściami jednoznakowymi.)

Program „backhanded” będzie wyglądał następująco:

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

(Tam, gdzie qwychodzi z programu i sprawia, że ​​wszystko inne przestaje działać).

Wypróbuj online.

Python 2 , 130 bajtów

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]

Wypróbuj online!

JavaScript (ES6), 130 bajtów

Wczesna próba. Niezbyt satysfakcjonujące.

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)

Wypróbuj online!

Gdy kod jest przetwarzany sam, izolowane są następujące znaki:

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

co daje:

f=>"Perfectly okay"//…

Galaretka , 34 bajty

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

Pełny program lub łącze monadyczne akceptujące listę znaków, które są drukowane lub dają (odpowiednio).

Wypróbuj online! Lub zobacz pakiet testowy .

Następnie parsowany kod odręczny to:

Jȧ“N2s]Ỵ»ị@€

Pełny program lub niladyczne drukowanie łącza lub tworzenie (odpowiednio) Turinga zakończone .

W jaki sposób?

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)

wówczas przeanalizowany kod odręczny to:

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)

Runiczne Zaklęcia , 294 bajty

>; "  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

Wypróbuj online!

Wersja nieskompresowana (i prawie czytelna):

>; "  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

Wypróbuj online!

To ... jest tak blisko, jak tylko mogę.

Dalsze kompresowanie wymagałoby wymyślenia sposobu obsługi różnych punktów wymiany pętli bez kolizji z innymi rzeczami. Pierwszy wiersz (który jest jedyną częścią, którą należy przekazać jako dane wejściowe do siebie) musi pozostać osobny: cały ciąg nie może zmieścić się w drugim wierszu bez powodowania problemów (w _przypadku wymaganych spacji):

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:                             ↑

Tego ?nie można oderwać od tego, !co samo nie może być odsuwane od \i żaden z dozwolonych komunikatów nie pozwala na żadną z tych trzech postaci w tej pozycji.

Alternatywą byłoby użycie przekierowania przepływu, ale prowadzi to do problemu w dolnej linii:

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

Ponieważ musimy unikać przełączania pętli w programie głównym.

Znane problemy:

• Niezwykle duże nakłady. Z powodu ograniczeń stosu adresów IP Runic, pchanie bardzo dużych ciągów wejściowych spowoduje wygaśnięcie IP przed zakończeniem. Można to zminimalizować, odradzając dodatkowe adresy IP i łącząc je (na przykład obsługuje, abcdefghijklmnopqrstuvwxyzale nie całe własne źródło). I istnieje limit niezależnie od liczby połączeń. Może obsłużyć do 58 bajtów danych wejściowych w stanie obecnym (dodatkowo zwiększenie liczby adresów IP wymaga wymyślenia, jak je połączyć, bez zajmowania więcej miejsca). Może zmieścić dwa kolejne wpisy IP w linii powrotu pętli (po prawej Ustronie linii rozpoczynającej się \y<<w wersji nieskompresowanej lub jeden w lewo powyżej linii y<<w wersji skompresowanej), zwiększając maksymalną długość wejściową do 78.
• Ciągi wejściowe ze spacjami muszą mieć spacje (np 1\ \ 1\ \ +\ \ O\ \ @.). Jest to ograniczenie analizy składniowej języka.
• Nie można dostarczyć danych wejściowych składających się z ciągów, które wyglądają jak liczby całkowite rozpoczynające się od dowolnej liczby 0s (tak jak po przekształceniu w liczbę na stosie, 0gubi się). Ponownie, ograniczenie analizy wejściowej języka.

Jak to działa

Wejście:

1. Połącz 4 wskaźniki instrukcji
2. Czytaj dane wejściowe, dziel na znaki, dodaj nowy wiersz, odwróć, wejdź do głównej pętli.

Główna pętla (wszystko, co wyskakuje na stosie, poprzedza duplikat):

1. Wydrukuj górę stosu
2. Porównaj z nową linią. To prawda: zamień pętle i dwukrotnie obróć stos w lewo.
3. Porównaj z @. Prawda: zakończ. (Wykonaj polecenie Zakończ)
4. Obróć stos w prawo
5. Porównaj z nową linią. Prawda: zakończ. (Wykonano polecenie z prawej strony)
6. Obróć stos w prawo
7. Porównaj z nową linią. To prawda: trzy razy przełączaj pętle i obracaj stos w lewo.
8. Obróć stos w prawo
9. Wróć do początku pętli

Pętla wtórna:

• Identycznie jak w głównej pętli, przełącznik obraca tylko w prawo, a obraca w lewo