oOo CODE로 작성된 프로그램의 입력이 있으면 해당 프로그램 이 나타내는 BF 코드를 출력하십시오.

다음은 oOo CODE 작동 방식에 대한 간단한 설명입니다.

• 먼저, 알파벳이 아닌 모든 문자가 제거됩니다 (범위 내에없는 모든 것 A-Za-z).

  예를 들어, 프로그램 PROgRam reVERsES giVeN iNPut sEqUENcE(예상 한 것을 정확하게 수행하는 esolangs wiki 페이지에 제공된 예)을 보자. 이 첫 단계가 끝나면 이제 PROgRamreVERsESgiVeNiNPutsEqUENcE.

• 다음으로 나머지 모든 문자를 3 개의 그룹으로 나눕니다 PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. 1 ~ 2 자의 후행 그룹이 있으면이를 버립니다.

• 다음 표를 기준으로 3 자로 구성된 각 그룹을 BF 명령으로 변환하십시오.

  ooo  >
  ooO  <
  oOo  [
  oOO  ]
  Ooo  -
  OoO  +
  OOo  .
  OOO  ,
  

  즉, 그룹의 첫 번째 문자가 소문자이고 두 번째 문자가 대문자이고 세 번째 문자가 소문자이면 명령으로 변환됩니다 [.

  이 예에서, 이것은 결국 BF 프로그램이되어 ,[>,]<[.<]+입력을 반대로합니다.

이것이 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

테스트 사례 :

<empty string> -> <empty string>
A -> <empty string>
Ab -> <empty string>
Abc -> -
AbcD -> -
AbcDe -> -
AbcDef -> --
1A_b%c*D[]e\\\f! -> --
PROgRamreVERsESgiVeNiNPutsEqUENcE -> ,[>,]<[.<]+

oOo, 1569 1515 바이트

해야했다. 여기에서 시도하십시오 .

골프 :

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Brainfuck로 번역 (명확성을 위해 줄 바꿈) :

>>>+>>>>>+>>,[>>++++++++[<++++++++>-]<+<[->-[>]<<]<[->+>[->+<]>+>>+++++[<+++++>-
]<++<[->-[>]<<]<[->+>[->+<]>+>+++++++<[->-[>]<<]<[->+>[->+<]>+>>+++++[<+++++>-]<
++<[->-[>]<<]<[->>[-]<<]<[-<<<<<<<<<<<+>>>>>>>>>>>>>>[-]<<<<]]<[->>>[-]<<<<]]<[-
<<<<<<<<<+>>>>+>>>>>>>>[-]<<<<]]<[->>>[-]<<<<]<<<<<<<[>[>>>>>++++++[<+++++++>-]<
++<<<[>[>[<->-]<[>>++<<-]<->]<[>+>[>-<<->-]<[>>+<<-]<-]<->]<[>+>>>>++++[<++++>-]
<<<[>>>+++++[<++++++>-]<+<[>++<<->-]<[-]<->]<[>+>[<->-]<[>>++<<-]<-]<-]+>>>>.[-]
<<<<<-<-<-]]>>>>>>>>+>>,]

설명이없는 골퍼

this progrAm Translates ooo codE tO brainfUCK cOde. i guesS sINcE ThE ExAMpLE
tEXt WAs SeLf-doCUmENtINg, I ShOUlD PrOBaBLy Make This SElf-DOcUmeNtInG too.

oh, I shoUld menTIon ThaT i WRotE tHe OriginAl BrainFuCk code EnTirElY By haNd.
If you waNt TO sEE tHE bRAiNfUck cODe, RUn THiS PrOGrAm wiTh itSElf AS iNPuT!

baSiCaLly, thiS proGram seTS up MemOrY As fOlLoWs: the fIrSt thrEe Bytes aRe
"ValId" FLags (V0, v1, V2), theN tHErE'S a BArRIeR (A 1) fOLlOweD bY tHree
"vaLue" bIts (b0, b1, b2). THe rEst Of THe aRrAy Is basiCaLly juSt ScratcH
sPacE. tO Save SpAce, i'm slIdINg THe POiNTeR fOrwaRD bY OnE In EAcH ItEratIon
uNTil THe POiNteR hItS the baRrieR, at whiCH poInt ThE ProGrAm Prints out tHe
ConvERteD chArACteR.

tHe ProgrAm eXteNsiVelY usEs tHe cLevEr "gReaTEr-Than" comparison operator
described by dheeraj ram aT
hTtp://sTAckOveRflOw.cOm/QUeSTioNs/6168584/BrAinfuck-comparE-2-nUmbeRS. i hAppEn
tO reAlLY lIKe tHiS iMplemEntAtiOn bEcaUse It iS boTh cOMpAct and nestablE,
wHich is critical for my bf code tO wOrk pROpeRly.

I seT up ThE ReQUisItE sTructure, then pErForm A BunCh oF neSteD cOMpaRisOns
ThaT loOk rOugHlY like tHis:

    if(in >= 65 /* capital a */) {
        if(In <= 90 /* CApITaL Z */) {
            vI = 1
            Bi = 1
        } ELsE {
            iF(in >= 97 /* lOWeRCaSE a */) {
                IF(iN <= 122 /* LoWErCAsE z */) {
                    vi = 1
                }
            }
        }
    }

At thE End OF tHEsE coMpaRisOnS, if the V (valid) Bit iS Set, the ProgRAm sTePs
the poiNtER rIghTwaRDs. if IT hiTS the barRIer, It Then gOeS into A big sEt of
nEstED condiTionALs tHaT test the AcCumUlaTEd vaLUe bITs, anD ConSTruct thE
CorReSpondInG character to pRiNT oUT. tHEn It ReseTS bACk TO tHE iNitiAl stATe.

fInaLly, It Reads anotheR iNPuT ChARaCTeR aNd goES bACk TO lOOpINg.

SO tHere You hAVe iT - An Ooo To BrainFuCK cOnvErtER writtEn in OOo (aNd
BrAinfUCk, bY ExtensiON!). siNcE i havE a Few moRe chARacterS to sPAre In This
progRaM, HeRe's A coUPle oF StrESs teST paTTernS:

0123456789ABcDefghijklmnopQRstUvWxyzABcdEfgHijKlmNopQRstuvWXyz!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 
 ~}|{`_^]\[@?>=<;:/.-,+*)('&%$#"!zyXWvutSRqPOnmlkjihgfedcbazyxwvutsrqPoNmlkjihGFEdCBa9876543210

흥미로운 도전에 감사드립니다!

CJam, 36 35 바이트

l{el_eu-},'_f<0+3/W<2fb"><[]-+.,"f=

여기에서 테스트하십시오.

설명

l               e# Read input.
{el_eu-},       e# Discard all characters that don't change in a lower/upper case
                e# transformation, i.e. non-letters.
'_f<            e# Compare with '_' to determine case as 0 or 1.
0+              e# Append a zero.
3/              e# Split into chunks of 3.
W<              e# Discard last chunk.
2fb             e# Convert each chunk from base 2.
",.+-][<>"f=    e# Select the corresponding character for each chunk.

자바 스크립트 (ES6), 94 93 91 85 84 83 바이트

@ dev-null 덕분에 1 바이트 절약

x=>x.replace(/[a-z]/gi,c=>(a+=c<'a'|0)[2]?b+="><[]-+.,"['0b'+a-(a="")]:0,a=b="")&&b

나는 이것의 많은 변형을 시도했지만 이것이 가장 짧은 것 같습니다. 빈 입력에서도 작동합니다!

작동 원리

먼저와 함께 입력에서 x.replace(/[a-z]/gi,c=>각 문자 c를 가져옵니다. 우리는 설정 a과 b에 ""함수가 두 번째 과거 매개 변수를 무시하기 때문에, 함수 호출의 다른 쪽 끝에서. a현재 만들고있는 캐릭터를 결정하기위한 이진 문자열을 b저장하고 결과를 저장합니다.

이제 혼란 부분 : 처음에 (a+=+(c<'a')), 우리는을 추가 0로 a하는 경우 c대문자이다; 1그렇지 않으면. 이 표현식은의 새로운 값을 반환 a하므로 인덱스 2의 문자가 있는지 확인하여 길이가 3 자에 도달했는지 확인할 수 있습니다 [2]?. 그렇지 않으면 단순히로 함수를 종료합니다 :0.

a길이가 3자인 경우 000와 사이의 이진수 111입니다. "0b"시작 부분 에 추가 한 다음 엔진이을 (를) 사용하여 숫자로 구문 분석하도록 하여 이를 10 진수로 변환 할 수 있습니다 '0b'+a-0.

그러나 여전히 a빈 문자열 로 재설정해야 합니다. '0b'+(a="")-0구문 분석 된 문자열이 그냥임을 의미하기 때문에 우리는 할 수 없습니다 0b. 숫자로 구문 분석 할 때 우리가 교체 할 수 있도록 다행히, 빈 문자열, 0이 0와 함께 (a="").

이제 우리는 우리의 번호를 가지고, 우리는 그냥 그 인덱스에있는 문자를 추가 할 수 있습니다 "><[]-+.,"로 b. 교체가 완료되면 &&b함수에서 교체에 사용 합니다. (결과 .replace가 비어 있지 않으면 빈 입력에서만 발생하고 빈 문자열을 반환합니다.)

05AB1E , 35 32 바이트

암호:

á0«3÷\)vyS).uïJC",.+-][<>"Sr@?)\

이 대답 에서 Martin Büttner의 매우 영리한 트릭을 사용합니다 . 설명:

á0«                               # Remove all non-alphabetic characters and append a zero
   3÷\                            # Split into pieces of 3 and discard the last one
      )v                          # Wrap everything into an array and map over it
        yS).uï                    # Is uppercase? Converts AbC to [1, 0, 1]
              JC                  # Join and convert from binary to int
                ",.+-][<>"        # Push this string
                          S       # Split the string
                           r@     # Reverse the stack and get the character from that index
                             ?    # Pop and print without a newline
                              )\  # Wrap everything into an array and pop

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

CP-1252 인코딩을 사용합니다 .

망막 , 79 75 71 70 바이트

1 바이트를 절약 한 randomra에게 감사드립니다.

i`[^a-z]

M!`...
m`^
;
+`(.*);(.)
$1$1$2;
T`l
.+
$.&
T`d`_><[]\-+.,
¶

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

설명

i`[^a-z]

우리는 편지가 아닌 모든 것을 제거하는 것으로 시작합니다.

M!`...

이렇게하면 겹치지 않는 모든 3 자 일치 항목을 반환하여 문자열을 3 자 청크로 분할합니다. 불완전한 후행 청크는 자동으로 삭제됩니다.

m`^
;

;각 줄 앞에 a 를 붙 입니다. 이것을 base-2 변환의 마커로 사용합니다. 말하자면, 우리는 단순히 대문자를로 처리됩니다 1와 같은 문자의 경우 낮은 0.

+`(.*);(.)
$1$1$2;

이것은 재미있는베이스 -2에서 단항 변환을 수행합니다. 각 단계에서 문자를 왼쪽으로 두 배로 늘리고 오른쪽으로 ;이동합니다 ;. 왜 이것이 작동합니까? 우리가 소문자로 해석됩니다 기억 0하고 대문자 1. 우리가 문자를 처리 할 때마다 우리는 단순히 총계의 왼쪽 ( 2*0=0두 배)을 두 배로 늘 렸습니다 -두 배의 소문자는 그냥 무시되므로 대문자는 완전히 무시할 수 있으며 대문자는 지금까지 이진수를 나타냅니다. 우리가 원하는 것. 그런 다음 현재 문자를 해당 합계에 표시 0하거나 1그에 따라 추가합니다 .

T`l

소문자 / 0을 모두 제거하십시오.

.+
$.&

각 줄을 일치시키고 해당 줄의 (소수) 문자 수로 바꿉니다. 이로 인해 ;단항 숫자는 10의 등가 + 1로 바뀝니다.

T`d`_><[]\-+.,

1-8을 해당 명령으로 대체하는 음역.

¶

줄 바꿈을 제거하십시오.

MATL , 38 32 바이트

'><[]-+.,'jt3Y2m)3ZCtAZ)92<!XBQ)

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

'><[]-+.,'      % push string with BF commands
j               % read input as a string
t               % duplicate
3Y2             % predefined literal: string 'A...Za...z'
m               % true for elements of input string that are letters
)               % index into input string to keep only letters
3ZC             % 2D array whose columns are non-overlapping slices of length 3.
                % The last column is padded with zeros if needed
tA              % duplicate. True for columns that don't contain zeros 
Z)              % keep those columns only. This removes padded column, if any
92<             % 1 for upper case letters, 0 for lower case letters in the 2D array
!               % transpose so each group of 3 is a row
XBQ             % convert each row from binary to decimal and add 1
)               % index into string containing the BF commands. Implicitly display

apt, 37 36 바이트

Uo"%l" f'.³ £",><[]-+."gX®c ¤gJÃn2Ãq

온라인으로 테스트하십시오!

작동 원리

Uo"%l" f'.³ £  ",><[]-+."gX®   c ¤  gJÃ n2Ã q
Uo"%l" f'.³ mX{",><[]-+."gXmZ{Zc s2 gJ} n2} q

Uo"%l"      // Get rid of all non-letter chars in U.
f'.³        // Take each set of three chars in U.
mX{      }  // Map each item X in this group to:
XmZ{     }  //  Map each letter Z in X to:
Zc s2 gJ    //   Take the char code of Z as a binary string, and take the first char.
            //   This maps each character to 1 if it's UC, or 0 if it's lc.
        n2  //  Interpret the result as a binary number.
",><[]-+."g //  Get the item at this index in this string.
q           // Concatenate the result and implicitly output.

자바 스크립트 (ES6), 111 95 바이트

s=>s.match(/[A-Z]/gi).map(c=>+(c<'a')).join``.match(/.../g).map(g=>'><[]-+.,'['0b'+g|0]).join``

비 문자를 제거하고 대문자를 1로, 소문자를 0으로 변환하고, 3 개의 그룹으로 나누고, 1 또는 2의 후행 그룹을 무시하고 그룹을 디코딩합니다.

편집 : @ dev-null 덕분에 16 바이트가 절약되었지만 빈 문자열을 전달하면 코드가 더 이상 작동하지 않습니다.

파이썬 3, 91 바이트

b=1
for c in input():
 b=-~c.isalpha()*b+c.isupper()
 if b>7:print(end="><[]-+.,"[b-8]);b=1

흠 ... 특히 두 번째 줄이 길어 보입니다. b=[b,2*b+(c<'a')][c.isalpha()]그래도 약간 나빠요.

Pyth, 40 바이트

jkm@"><[]-+.,"id2f!%lT3cm?rId0Z1f!rIT2z3

여기 사용해보십시오!

문자열 대신 문자 목록으로 결과를 출력 할 수 있다면 2 바이트를 절약 할 수 있습니다.

설명

모든 비 문자를 필터링하고, 대문자를 1로, 소문자를 0으로 변환하고, 청크를 3으로 분할하고, 모든 청크를 이진수로 해석하고이를 모든 BF 명령을 포함하는 문자열의 인덱스로 사용합니다.

jkm @ "> <[]-+.,"id2f! % lT3cm? rId0Z1f! rIT2z3 # z = 입력

                                f를 사용한 fz # 필터 입력
                                 ! # 논리적이지 않음
                                  rIT2 # T == swapcase (T), T가 문자가 아닌 경우 true
                        m # d를 사용한 맵 필터 결과
                         ? rId0 # if d == toLower (d)
                              소문자의 경우 Z1 # 0, 대문자의 경우 1
                       c 3 # 3 덩어리로 나뉘며, 필요한 경우 마지막 요소가 짧습니다.
                 f # 필터 T
                  ! # 논리적이지 않음
                   % lT3 # len (t) mod 3-> 길이가 3 인 요소 만 유지
  d와 m # 맵
              id2 # 이진수에서 십진수로 변환
   @ "> <[]-+.,"# 결과 BF 명령 받기
jk # 문자열에 조인

줄프, 31 34 바이트

여기 사용해보십시오! 교체 ►로 \x10와 ♣함께 \x05. chop 함수를 잘못 구현했기 때문에 3 바이트를 얻습니다. :(

►ΜZeZcAAρi♣Epu1pl033d."><[]-+.,"ΙH
        ρi♣E                        remove all space in input
       A    pu1                     replace all uppercase letters with 1
      A        pl0                  replace all lowercase letters with 0
    Zc            3                 chop into groups of three
  Ze               3                keep groups of length three
 Μ                  d               map
                              ΙH   parse element as binary
                     ."><[]-=.,"    and return a member of that
►                                  join by nothing

Hoon , 212 바이트

=+([v=turn c=curr q=cold k=tape] |=(t/k `k`(v (v `(list k)`(need ((unit (list k)) p:(rose (murn t (c rush alf)) (star (stun [3 3] ;~(pose (q '0' low) (q '1' hig))))))) (c scan bin)) (c snag (rip 3 '><[]-+.,')))))

언 골프 드 :

|=  t/tape
^-  tape
%+  turn
  %+  turn  ^-  (list tape)
  %-  need  %-  (unit (list tape))
    =+  t=(murn t (curr rush alf))
    p:(rose t (star (stun [3 3] ;~(pose (cold '0' low) (cold '1' hig)))))
  (curr scan bin)
(curr snag (rip 3 '><[]-+.,'))

1. ++ murn을 사용하여 "alf"(알파벳)으로 구문 분석 할 수없는 입력의 모든 문자를 제거하십시오.
2. 소문자를 '0'으로, 대문자를 '1'로 바꾸어 한 번에 각 3자를 출력하는 조합기로 목록을 구문 분석하십시오.
3. 결과를 (단위 (목록 테이프))로 캐스팅하고 가장 많이 파싱 된 결과를 얻으려면 강제로 풀어서 충돌없이 3의 배수로 만 작업하십시오.
4. 각 그룹을 마치 이진 인 것처럼 파싱하여 목록에 매핑
5. 목록의 각 숫자를 텍스트 '> <[]-+.,'의 색인으로 사용하고 목록을 다시 테이프로 캐스트하십시오.

Hoon에는 적절한 정규 표현식이없고 파서 결합기 라이브러리 만 있으므로 슬프게도 장황합니다. 전체 입력 스트림이 구문 분석되지 않으면 ++ scan도 충돌하므로 ++ rose를 사용하여 단위로 강제 변환하고 "가장 먼 구문 분석"값으로 랩핑해야합니다. 또한 목록을 카레하고 매핑하는 데 많이 사용되므로 (++ turn) 함수 이름을 하나의 문자 변수에 별칭으로 지정합니다.

Hoon은 깔끔한 슬레이트 재 구현 프로젝트 인 Urbit의 프로그래밍 언어입니다. 순전히 기능적이고 정적으로 타이핑되고 모호한 모양이며, Nock로 컴파일됩니다. Nock는 이진 트리 Bignum 메모리 모델에서 실행되는 결합기 기반 VM입니다.

Urbit를 부팅하면 : dojo, shell and Hoon repl. 스 니펫을 실행하려면 다음을 입력하십시오.

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

다음 행에 독립형 기능을 붙여 넣습니다.

젤리 , 27 바이트

=Œs¬Tịµ=Œu;0s3ṖḄ€ị“<[]-+.,>

온라인으로 사용해보십시오! 마지막 두 번째 테스트 사례의 경우 입력 문자열에서 백 슬래시를 이스케이프해야합니다.

Implicit input: string s (list of characters)

=Œs             Compare with swapcase
¬               Not - this gives 1 for letters, 0 otherwise
Tị              Take characters at truthy indices
µ               Start a new monadic chain

Input: string s' (list of letters)

=Œu             Compare with uppercase
;0              Append 0
s3              Split into chunks of length 3
Ṗ               Pop last chunk
Ḅ€              Apply convert-from-binary to each chunk
ị“<[]-+.,>      For each number, 1-based index cyclically into the string "<[]-+.,>"

Matlab, 98 바이트

function t(s);s=s(isletter(s));s=s(1:end-mod(end,3));r='><[]-+.,';r([4 2 1]*reshape(s<92,3,[])+1)

1. 깨끗한
2. 손질
3. UC = 1, lc = 0 인 3xn Matrix m으로 재구성
4. (4 2 1) * m + 1은 색인리스트를 생성합니다
5. 올바른 문자 색인

펄, 76 73 72 + 1 = 73 바이트

$a.=y+A-Z++dfor/[A-Z]/gi;print substr"><[]-+.,",oct"0b$_",1for$a=~/.../g

-n플래그가 필요합니다 :

$ perl -n oOo.pl <<< 'PROgRamr{}\eVERsESgiVeNiNPutsEqUENcE'
,[>,]<[.<]+

base-2 변환과 함께 트릭 사용하기 .

작동 방식 :

                          # '-n' auto read first line into `$_`
            for/[A-Z]/gi; # Iterate over all letters a-z
$a.=y/A-Z//d              # Count number of uppercase letters (1 or 0)

                                  for$a=~/.../g # Split $b into hunks of 3 characters. And
                                                # remove any potential trailing characters.
      substr"><[]-+.,",oct"0b$_",1              # `oct("0b$binary")` will convert binary
                                                # to decimal.
print

줄리아, 107 바이트

s->"><[]-+.,"[map(j->parse(Int,j,2)+1,[map(i->i<'_'?'1':'0',m)for m=matchall(r"\w{3}",filter(isalpha,s))])]

이것은 문자열을 받아들이고 문자열을 반환하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

언 골프 드 :

function f(s)
    # Brainfuck commands
    bf = "><[]-+.,"

    # Filter out non-alphabetic characters from the input
    chars = filter(isalpha, s)

    # Get all non-overlapping groups of three characters
    groups = matchall(r"\w{3}", chars)

    # Construct binary strings by comparing to _
    binary = [map(i -> i < '_' ? '1' : '0', m) for m = groups]

    # Parse each binary string as an integer and add 1
    indices = map(j -> parse(Int, j, 2) + 1, binary)

    # Return the Brainfuck commands at the indices
    return bf[indices]
end

루아, 120 바이트

string.gsub()여기에서 큰 사용을 한 번 더하면이 함수에서 하나의 문자 포인터를 만들어 바이트를 얻을 수있었습니다. 또한 공백이없는 첫 번째 루아 프로그램입니다! :디

이 프로그램은 명령 줄 인수를 통해 입력을 받아 BrainFuck 프로그램을 한 줄에 하나씩 명령으로 출력합니다.

편집 : @Oleg V. Volkov 덕분에 1 바이트 절약

arg[1]:gsub("[%A]",""):gsub("%l",0):gsub("%u",1):gsub("...",function(c)x=1+tonumber(c,2)print(("><[]-+.,"):sub(x,x))end)

언 골프와 설명

arg[1]:gsub("[%A]","")    -- replace the non-letter character by an empty string
                          -- %A matches all the character not in %a (letters)
:gsub("%l",0)             -- replace lower case letters by 0s
:gsub("%u",1)             -- replace upper case letters by 1s
:gsub("...",function(c)   -- iterate over all groupe of 3 characters
  x=tonumber(c,2)+1       -- convert the 3-letter group from binary to decimal
  print(("><[]-+.,")      -- output the corresponding brainfuck command
             :sub(x,x))   
end)

파이썬 2, 112 바이트

''.join('><[]-+.,'[int('%d'*3%tuple(map(str.isupper,y)),2)]for y in zip(*[iter(filter(str.isalpha,input()))]*3))

더 골프하려고합니다.

매스 매 티카, 192 바이트

StringJoin[FromDigits[#,2]&/@Partition[ToCharacterCode@#-48,3]&[StringDelete[#,a_/;!LetterQ[a]]~StringReplace~{_?UpperCaseQ->"1",_?LowerCaseQ->"0"}]/.Thread[0~Range~7->Characters@"><[]-+.,"]]&

원하는 문자열을 인수로 취하는 익명 함수 (꽤 간단한) 알고리즘의 단계 :

1. 끈을 청소
2. UC-> "1", lc-> "0"교체
3. 문자열을 이진 목록으로 변환
4. 목록을 3 개로 분할하고 각 청크를 밑이 2 인 숫자로 해석하십시오.
5. 숫자를 적절한 기호로 바꾸고 문자열로 다시 결합하십시오.

루비 117 114 113 111 86 79 바이트

gets.tr(?^+m='a-zA-Z','').tr(m,?0*26+?1).scan(/.../){$><<"><[]-+.,"[$&.to_i 2]}

• tr(?^+m='a-zA-Z','')'a-zA-Z'비 문자를 m으로 설정 하고 제거합니다.
• .tr(m,?0*26+?1) 소문자를 0으로, 대문자를 1로 변환
• .scan(/.../) 청크 문자열을 3 개의 그룹으로 묶고 3보다 작은 경우 마지막 그룹을 버립니다.
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} 각 이진수를 문자로 변환

펄 6, 81 바이트

이것은 아마도 더 잘 이루어질 수 있지만, 이것이 나의 길입니다.

{m:g/:i<[a..z]>/;[~] ("><[]-+.,".comb[:2[$_]]for (+(91>$_.ord)for |$/).rotor(3))}

용법

> my &f = {m:g/:i<[a..z]>/;[~] ("><[]-+.,".comb[:2[$_]]for (+(91>$_.ord)for |$/).rotor(3))}
-> ;; $_? is raw { #`(Block|149805328) ... }
> f("PROgRamreVERsESgiVeNiNPutsEqUENcE")
,[>,]<[.<]+

언 골프

sub oOo ($_) {
    m:g/:i<[a..z]>/;  # Match all letters and put them in $/

    my @digits = (                
        for |$/ -> $c {           # For all $c in $/
            +(91>$c.ord)          # 1 if $c.ord < 91 else 0
        }
    );
    @digits.=rotor(3);            # Split the digits into chunks of 3

    my @chars = (
        for @digits -> @l {
            "><[]-+.,".comb[:2[@l]] # Take the character from "><[]-+.,"
                                    # at an index given by converting 
                                    # @l (a list of 3 binary digits)
                                    # from base 2 to base 10
        }
    );
    @chars.join # Join the list of chars into a string and return
}

C ++, 173 167 바이트

골프 전체 프로그램 (표준 입력에서 읽음) :

#include <cstdio>
main(){for(char*a="@[`{>-[.<+],",c,o=0,t=1;(c=getchar())>0;)if(c=c>*a&&c<a[1]?2:c>a[2]&&c<a[3]?1:0){o|=c>1?t:0;t*=2;if(t>4)putchar(a[o+4]),o=0,t=1;}}

언 골프 :

#include <cstdio>
main(){
    for(char*a="@[`{>-[.<+],",c,o=0,t=1;(c=getchar())>0;)
        if(c=c>*a&&c<a[1]?2:c>a[2]&&c<a[3]?1:0){
            o|=c>1?t:0;
            t*=2;
            if(t>4)putchar(a[o+4]),o=0,t=1;            
        }
}

ASCII 는 @A... Z[이고 마찬가지로 `a...도 z}있습니다.

Japt v2.0a0 -P, 27 바이트

r\L ò3 l3 Ëmè\A Íg"><[]-+.,

@Shaggy 덕분에 3 바이트 절약

시도 해봐

파이크, 31 바이트, 비경쟁

Pyke는 도전보다 오래되었지만, 경쟁 기능을 향상시키기 위해 몇 가지 기능을 추가했습니다. @Martin Büttner 와 같은 트릭을 사용했습니다.

#~l{)\`Lm<0+3cFb2"><[]-+.,"@)st

여기 사용해보십시오!

자바 스크립트, 148 바이트

function a(s){function b(c){return c.charCodeAt()&32}return (l=(s=s.replace(/[^a-z]/gi)).substr(3))?",.+-][<>"[b(s[0])*4+b(s[1])*2+b(s[2])]+a(l):""}

TI-BASIC, 311 288 바이트

TI-BASIC 답변이 없습니까? 내가 고칠 시간이야!

Ans→Str1:" →Str2:" →Str6:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str4:For(S,1,length(Str1:sub(Str1,S,1:If inString(Str4+"abcdefghijklmnopqrstuvwxyz",Ans:Str2+Ans→Str2:End:sub(Str2,2,length(Str2)-1→Str2:For(B,1,.1+3⁻¹length(Str2:sub(Str2,3B-2,3→Str3:1+sum({4,2,1}seq(0≠inString(Str4,sub(Str3,X,1)),X,1,3→L₁(B:End:For(C,1,.1+dim(L₁:Str6+sub("><[]-+.,",L₁(C),1→Str6:End:sub(Str6,2,length(Str6)-1→Str6

입력은의 oOo 코드입니다 Ans.
출력은 번역 된 BF 코드입니다.

예 :

"AbcDef
AbcDef
prgmCDGF18
--
"PROgRam reVERsES giVeN iNPut sEqUENcE
PROgRam reVERsES giVeN iNPut sEqUENcE
prgmCDGF18
.[>,]<[.<]+
"AbcDe
AbcDe
prgmCDGF18
-

언 골프 :
(개행 및 댓글 추가)

Ans→Str1                                                   ;store the input in "Str1"
" →Str2                                                    ;set "Str2" and "Str6" to a
" →Str6                                                    ; space character
                                                           ; (needed b/c TI-BASIC doesn't
                                                           ;  like concatenating empty
                                                           ;  strings)

"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str4                           ;store the uppercase alphabet
                                                           ; in "Str4"
For(S,1,length(Str1                                        ;loop over the input string
sub(Str1,S,1                                               ;get the current character
If inString(Str4+"abcdefghijklmnopqrstuvwxyz",Ans          ;if the character is in either
                                                           ; the uppercase or lowercase
                                                           ; alphabet
Str2+Ans→Str2                                              ;add it to "Str2", the code
                                                           ; string
End
sub(Str2,2,length(Str2)-1→Str2                             ;remove the space added earlier
For(B,1,.1+3⁻¹length(Str2                                  ;loop over each 3-char substring
                                                           ; and skip any extra chars
                                                           ; (.1 is added to force one
                                                           ;  loop)
sub(Str2,3B-2,3→Str3                                       ;store said substring in "Ans"
1+sum({4,2,1}seq(0≠inString(Str4,sub(Str3,X,1)),X,1,3→L₁(B ;convert to the respective
                                                           ; index in "><[]-+.,"
                                                           ; (1-indexed)
End
For(C,1,.1+dim(L₁                                          ;loop over each index
                                                           ; (.1 is added to force one
                                                           ;  loop)
Str6+sub("><[]-+.,",L₁(C),1→Str6                           ;add the char to the translation
                                                           ; string
End
sub(Str6,2,length(Str6)-1→Str6                             ;remove the added space and
                                                           ; store the result in "Str6"
                                                           ; and "Ans"
                                                           ;implicit print of "Ans"

노트:

• TI-BASIC은 토큰 화 된 언어입니다. 문자 수는 바이트 수와 같지 않습니다 .