이 도전은 나의 첫 비의 언어 인 백핸드 를 축하하기 위해 만들어졌습니다 !

백핸드는 비선형 포인터 흐름이있는 1 차원 언어입니다. 포인터는 한 번에 세 단계 씩 이동하며 세 번째 명령마다 실행됩니다.

프로그램 1..1..+..O..@은 종료하기 전에 1 + 1을 추가하고 2를 출력합니다. 중간 명령어는 건너 뛰므로 1<>1()+{}O[]@정확히 같은 프로그램입니다.

포인터가 테이프 끝에서 떨어지려고 할 때 대신 방향을 바꾸고 다른 방향으로 1.@1.O+.갑니다. 같은 프로그램도 마찬가지입니다. 종료 명령은 한 번만 계산합니다. 이를 통해 다음과 같이 대부분의 선형 프로그램을 압축 할 수 있습니다1O+1@

여기서 과제는 문자열을 취하는 프로그램이나 함수를 작성하고 프로그램이 백핸드와 같이 해석 될 때 실행될 명령을 출력하는 것입니다 (실제 백핸드 명령을 처리 할 필요는 없습니다). 포인터가 문자열의 마지막 문자에 도달 할 때까지만 출력해야합니다 (이 시점에서 실행은 일반적으로 뒤로 이동합니다).

그러나 기다려라 , 그게 전부가 아니다! 프로그램 자체가 이러한 방식으로 해석되면 결과 코드는 다음 중 하나를 출력해야합니다.

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

그리고 물론 백핸드로 작성된 참조 프로그램 ( 이것은 약간 버그가있을 수 있습니다. 알겠습니다.

규칙.

• 표준 허점 은 금지되어 있습니다
• 첫 번째 프로그램의 입력 (바이트이며, 인쇄 가능한 ASCII 줄 바꿈이 포함됩니다 0x20- 0x7E뿐만 아니라 0x0A로)
• 두 번째 프로그램을 첫 번째 바이트에서 UTF-8 문자로 변환할지 여부를 선택할 수 있습니다.
• 두 번째 프로그램 :
  • 대소 문자는 중요 하지 않으므로pErFectLy OKay 원하는 경우 출력이 될 수 있습니다 .
  • 후행 / 선행 공백 (줄 바꿈, 탭, 공백)도 괜찮습니다.
  • 두 번째 프로그램은 첫 번째와 같은 언어 여야하지만 반드시 같은 형식 일 필요는 없습니다 (프로그램 / 기능)
  • 여분의 문구에 대한 의견 제안이 너무 짧지 않은 한 기쁘다.
• 이것이 code-golf 이므로 귀하의 목표는 귀하의 언어에 대한 최단 답변을 얻는 것입니다!
• 2 주 안에 최단 백핸드 답변에 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' 

파이썬 (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')

펄 6 , 101 86 바이트

와우, 첫 번째 프로그램을 대폭 개선하여 nwellnhof 덕분에 -25 바이트

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

온라인으로 사용해보십시오!

더 많은 사람들이 이와 같은 반등을 활용하기를 바랍니다. 백핸드 프로그램은

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

어떤 의견에 대한 의견 {"(Mostly) works"}.

05AB1E , 43 40 38 37 바이트

@Emigna 덕분에 -2 바이트 (40 → 38) .

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

온라인으로 사용해보십시오 . (추신 :에서 언어를 전환 05AB1E (레거시) 에 05AB1E 테스트 케이스에 대해 0123456789. 레거시 버전은 빠른이지만, 앞에 0이 번호 입력에 대한 잘못된 결과를 보여줍니다.)

'백핸드'프로그램은 다음과 같습니다.

„ÃеÝ[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. „ÃеÝ: 스택이됩니다 ["perfectly okay"]
2. [: 무한 루프 시작
3. (첫 번째 루프 반복) N©: STACK이["perfectly okay", 0]
4. (첫 번째 루프 반복) I: ["perfectly okay", 0]입력이 없으므로 STACK이 유지됩니다.
5. (첫 번째 루프 반복) #: STACK이되고 ["perfectly okay"]루프는 계속됩니다
6. (첫 번째 루프 반복) N: STACK이["perfectly okay", 0]
7. (첫 번째 루프 반복) #: STACK이되고 ["perfectly okay"]루프는 계속됩니다
8. (두 번째 루프 반복) N©: STACK이["perfectly okay", 1]
9. (두 번째 루프 반복) I: ["perfectly okay", 1]입력이 없으므로 STACK이 유지됩니다.
10. (두 번째 루프 반복) #: STACK이되고 (truthy) ["perfectly okay"]때문에 루프가 중단됩니다.1
11. 스택 맨 위를 STDOUT에 내재적으로 인쇄합니다. perfectly okay

TIO의 디버거가 활성화 된 단계는 여기를 참조하십시오.

내이 05AB1E 팁을 참조하십시오 (섹션 어떻게 사전을 사용하는 방법을? ) 이유를 이해 할 수 „€€Ã€„Ѐ€µ'€Ý있는 the pointed, dm one그리고 been하고 „ÃеÝ있다 perfectly okay.

이전 38 바이트 버전 :

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

온라인으로 사용해보십시오 . (추신 :에서 언어를 전환 05AB1E (레거시) 에 05AB1E 테스트 케이스에 대한 0123456789및 @레거시 버전은 빠르고이지만, 앞의 0 또는 단일 문자 입력과 번호 입력에 대한 잘못된 결과를 보여줍니다.).

'백핸드'프로그램은 다음과 같습니다.

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

( q종료점은 프로그램을 종료하고 다른 모든 것을 운영하지 않는 곳)

온라인으로 사용해보십시오.

파이썬 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]

온라인으로 사용해보십시오!

자바 스크립트 (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:

메인 프로그램에서 루프 스위치를 피해야합니다.

알려진 문제 :

• 매우 큰 입력. Runic의 IP 스택 제한으로 인해 매우 큰 입력 문자열을 누르면 IP가 완료되기 전에 만료됩니다. 추가 IP를 스폰하고 병합하여 최소화 할 수 있습니다 (예 : abcdefghijklmnopqrstuvwxyz자체 소스 전체를 처리 하지만 처리 하지는 않음). 병합 횟수에 관계없이 제한이 있습니다. 최대 58 바이트의 입력을 그대로 처리 할 수 ​​있습니다 (또한 IP 수를 늘리려면 더 많은 공간을 사용하지 않고 IP를 병합하는 방법을 알아야합니다). 입력 최대 길이를 78로 올리는 루프 리턴 라인 ( 압축되지 않은 버전에서 U시작하는 라인 의 오른쪽에 \y<<또는 하나 y<<는 압축 된 버전에서 위의 왼쪽에있는) 에 두 개의 IP 항목을 더 넣을 수 있습니다.
• 공백이있는 입력 문자열에는 공백이 없어야합니다 (예 :) 1\ \ 1\ \ +\ \ O\ \ @. 이는 언어 입력 구문 분석의 한계입니다.
• 0s로 시작하는 정수처럼 보이는 문자열로 구성된 입력을 제공 할 수 없습니다 (스택의 숫자로 바뀌면 0손실 됨). 다시 말하지만, 언어 입력 구문 분석의 한계.

작동 원리

기입:

1. 4 개의 명령어 포인터 결합
2. 입력을 읽고, 문자로 나누고, 개행을 추가하고, 역순으로 입력하고 메인 루프를 입력하십시오.

메인 루프 (스택에 튀어 나오는 것 앞에는 dup이옵니다) :

1. 스택 상단 인쇄
2. 개행과 비교하십시오. True : 루프를 전환하고 스택을 왼쪽으로 두 번 회전시킵니다.
3. 와 비교하십시오 @. 참 : 종료 (종료 명령 실행)
4. 스택을 오른쪽으로 회전
5. 개행과 비교하십시오. 참 : 종료 (가장 오른쪽 명령 실행)
6. 스택을 오른쪽으로 회전
7. 개행과 비교하십시오. True : 루프를 전환하고 스택을 왼쪽으로 회전시킵니다.
8. 스택을 오른쪽으로 회전
9. 루프 맨 위로 돌아 가기

보조 루프 :

• 메인 루프와 동일, 왼쪽으로 회전하면서 스위치 만 오른쪽으로 회전