Biorąc pod uwagę program napisany w oOo CODE , wypisz reprezentowany przez niego kod BF.

Oto krótki opis działania oOo CODE:

• Najpierw usuwane są wszystkie znaki niealfabetyczne (wszystko poza zakresem A-Za-z).

  Weźmy na przykład program PROgRam reVERsES giVeN iNPut sEqUENcE(przykład podany na stronie wiki esolangs, który robi dokładnie to, czego można oczekiwać). Po tym pierwszym kroku mamy teraz PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Następnie podziel wszystkie pozostałe postacie na grupy po 3. Mamy teraz PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. Jeśli istnieje końcowa grupa 1 lub 2 znaków, odrzuć ją.

• Konwertuj każdą grupę 3 liter na polecenie BF na podstawie poniższej tabeli:

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

  Oznacza to, że jeśli pierwsza litera grupy jest pisana małymi literami, druga jest pisana wielkimi literami, a trzecia jest pisana małymi literami, tłumaczy się na polecenie [.

  W naszym przykładzie ostatecznie staje się to programem BF ,[>,]<[.<]+, który faktycznie odwraca swoje dane wejściowe.

Ponieważ jest to code-golf , wygra najkrótszy kod w bajtach.

Przypadki testowe:

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

oOo, 1569 1515 bajtów

Musiało być zrobione. Wypróbuj tutaj .

Gra w golfa:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Przetłumaczone na Brainfuck (z podziałami dla zachowania przejrzystości):

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

Nieoznakowany z wyjaśnieniem:

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

Dzięki za interesujące wyzwanie!

CJam, 36 35 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

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.

JavaScript (ES6), 94 93 91 85 84 83 bajty

Zapisano 1 bajt dzięki @ dev-null

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

Próbowałem wielu wariantów tego, ale wydaje się to być najkrótsze. Działa również przy pustym wejściu!

Jak to działa

Po pierwsze, za pomocą x.replace(/[a-z]/gi,c=>znajdujemy każdą literę cw danych wejściowych. Postawiliśmy ai baby ""na drugim końcu wywołania funkcji, ponieważ funkcja ignoruje wszelkie parametry obok drugiego. azapisze ciąg binarny do określania, który znak tworzymy obecnie i bzapisze wynik.

Teraz część myląca: po pierwsze, do (a+=+(c<'a')), dodajemy a 0do wielkiej litery aif jeśli c; 1Inaczej. To wyrażenie zwraca nową wartość a, więc możemy sprawdzić, czy osiągnął trzy znaki długości z sprawdzając czy postać w indeksie 2 istnieje: [2]?. Jeśli nie, po prostu kończymy funkcję za pomocą :0.

Jeśli ama teraz trzy znaki, jest to liczba binarna między 000a 111. Możemy przekonwertować to na liczbę dziesiętną, dodając "0b"na początku, a następnie zmuszając silnik do parsowania go jako liczby '0b'+a-0.

Jednak nadal musimy zresetować ado pustego ciągu. Nie możemy tego zrobić, '0b'+(a="")-0ponieważ oznaczałoby to, że analizowany ciąg jest po prostu 0b. Na szczęście, gdy analizowany jako liczba, pusty łańcuch staje 0, więc możemy wymienić 0z (a="").

Teraz mamy nasz numer i możemy po prostu dołączyć znak pod tym indeksem "><[]-+.,"do b. Po zakończeniu zamiany używamy, &&baby zwrócić go z funkcji. (Cóż, chyba że wynik .replacejest pusty, co dzieje się tylko przy pustych danych wejściowych i zwraca pusty ciąg znaków.)

05AB1E , 35 32 bajtów

Kod:

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

Wykorzystując bardzo sprytną sztuczkę Martina Büttnera z tej odpowiedzi . Wyjaśnienie:

á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

Wypróbuj online!

Wykorzystuje kodowanie CP-1252 .

Siatkówka , 79 75 71 70 bajtów

Dzięki randomra za zapisanie 1 bajtu.

i`[^a-z]

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

Wypróbuj online!

Wyjaśnienie

i`[^a-z]

Zaczynamy od usunięcia wszystkiego, co nie jest literą.

M!`...

To dzieli ciąg na fragmenty trzech znaków, zwracając wszystkie (nie nakładające się) dopasowania 3-znakowe. To automatycznie odrzuca każdy niekompletny końcowy fragment.

m`^
;

Przygotuj a ;do każdej linii. Użyjemy tego jako znacznika konwersji base-2. Mówiąc o tym, po prostu będziemy traktować wielkie litery jako, 1a małe litery jako 0.

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

Robi to zabawną konwersję base-2 na jednoargumentową konwersję. Na każdym kroku po prostu podwajamy postacie po lewej stronie ;i przesuwamy tę ;w prawo. Dlaczego to działa? Pamiętaj, że będziemy interpretować małe 0i duże litery jako 1. Ilekroć przetwarzamy literę, po prostu podwajamy do tej pory sumę bieżącą (po lewej) - podwójne małe litery są po prostu 2*0=0, więc można je całkowicie zignorować, a duże litery reprezentują dotychczas liczbę binarną, więc podwojenie ich jest czego chcemy. Następnie dodajemy bieżącą literę do bieżącej sumy, która reprezentuje 0lub 1odpowiednio.

T`l

Usuń wszystkie małe litery / zera.

.+
$.&

Dopasuj każdy wiersz i zastąp go (dziesiętną) liczbą znaków w tym wierszu. Z ;tego powodu zamienia liczbę jednoznaczną na jej ekwiwalent dziesiętny + 1.

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

Transliteracja, która zastępuje 1-8 odpowiednim poleceniem.

¶

Usuń linie.

MATL , 38 32 bajtów

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

Wypróbuj online!

'><[]-+.,'      % 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

Japt, 37 36 bajtów

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

Przetestuj online!

Jak to działa

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.

JavaScript (ES6), 111 95 bajtów

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

Po prostu usuwa nie-litery, konwertuje wielkie litery na 1s, a małe na 0, dzieli na grupy trzy, ignoruje końcową grupę 1 lub 2 i dekoduje grupy.

Edycja: Zapisano 16 bajtów dzięki @ dev-null, chociaż kod nie działa już po przekazaniu pustego ciągu.

Python 3, 91 bajtów

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

Hmm ... wygląda na trochę długą, zwłaszcza drugą linię. b=[b,2*b+(c<'a')][c.isalpha()]jest jednak nieco gorszy.

Pyth, 40 bajtów

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

Wypróbuj tutaj!

Mógłbym zapisać 2 bajty, jeśli mogę wypisać wynik jako listę znaków zamiast łańcucha.

Wyjaśnienie

Filtruje wszystkie nie-litery, konwertuje wielkie litery na 1 i małe litery na 0, dzieli na 3 części, interpretuje każdą część jako liczbę binarną i używa tego jako indeksu w ciągu zawierającym wszystkie polecenia BF.

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

                                filtr wejściowy fz # z T
                                 ! # logiczne nie
                                  rIT2 # T == swapcase (T), prawda, jeśli T nie jest literą
                        m # wynik filtrowania mapy za pomocą d
                         ? rId0 # if d == toLower (d)
                              Z1 # 0 dla małych liter, 1 dla wielkich liter
                       c 3 # Podziel na 3-częściowe, w razie potrzeby ostatni element jest krótszy
                 filtr f # z T
                  ! # logiczne nie
                   % lT3 # len (t) mod 3 -> zachowaj tylko elementy o długości 3
  m # mapa z d
              id2 # Konwertuj z binarnego na dziesiętny
   @ "> <[] - +.," # Pobierz wynikowe polecenie BF
jk # Dołącz do ciągu

Jolf, 31 34 bajtów

Wypróbuj tutaj! Wymień ►się \x10i ♣z \x05. Ponieważ źle zaimplementowałem funkcję chop, zyskuję 3 bajty. :(

►Μ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 bajtów

=+([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 '><[]-+.,')))))

Nie golfowany:

|=  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. użyj ++ murn, aby pozbyć się wszystkich znaków na wejściu, których nie można sparować z „alf” (alfabet)
2. parsuj listę za pomocą kombinatora, który wysyła co 3 znaki naraz do listy, zastępując małe litery „0” i wielkie litery „1”
3. Rzuć wynik na (jednostka (taśma listy)) i siłą rozpakuj go, aby uzyskać jak najdokładniejszy przeanalizowany wynik, aby pracować tylko z wieloma trójkami bez awarii
4. Mapuj listę, analizując każdą grupę tak, jakby była binarna
5. Użyj każdej liczby na liście jako indeksu w tekście „> <[] - +.,” I wyrzuć listę z powrotem na taśmę.

Hoon nie ma odpowiednich wyrażeń regularnych, tylko bibliotekę parsera, więc jest niestety dość gadatliwa. Skanowanie ++ zawiesza się również, jeśli cały strumień wejściowy nie jest analizowany, więc muszę użyć ++ rose, przekonać go do jednostki i rozpakować dla wartości „najdalszego parsowania”. Jest również bardzo użyteczne do curryowania i mapowania list (zwrot ++), więc alias nazw funkcji do zmiennych literowych.

Hoon jest językiem programowania dla Urbit, projektu reimplementacji czystych łupków. Jest to czysto funkcjonalne, typowo statyczne, niejasno podobne do seplenienia i kompiluje się do Nocka. Nock to maszyna wirtualna oparta na kombinatorze, która działa na modelu pamięci bignum drzewa binarnego.

Kiedy uruchamiasz Urbit, zostajesz przeniesiony do: dojo, powłoki i repliki Hoon. Aby uruchomić fragment, po prostu wpisz:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

a następnie wklej samodzielną funkcję w następnym wierszu.

Galaretka , 27 bajtów

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

Wypróbuj online! Zauważ, że ukośniki odwrotne wymagają ucieczki w ciągu wejściowym dla drugiego ostatniego przypadku testowego.

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 bajtów

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. Czysty
2. Trym
3. przekształcić w macierz 3xn mz UC = 1, lc = 0
4. (4 2 1) * m + 1 powoduje wyświetlenie listy indeksów
5. Indeks do odpowiednich znaków

Perl, 76 73 72 + 1 = 73 bajty

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

Wymaga -nflagi:

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

Wykorzystanie lewy z konwersją base-2 .

Jak to działa:

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

Julia, 107 bajtów

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

Jest to anonimowa funkcja, która przyjmuje ciąg i zwraca ciąg. Aby go wywołać, przypisz go do zmiennej.

Nie golfowany:

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

Lua, 120 bajtów

Wielkie zastosowanie string.gsub()tutaj, jeszcze raz mógłbym pozwolić na utworzenie wskaźnika jednoznakowego na tej funkcji, aby uzyskać trochę bajtów. To także mój pierwszy program lua bez spacji! :RE

Ten program pobiera dane wejściowe za pomocą argumentu wiersza polecenia i wyświetla program BrainFuck, po jednym poleceniu na wiersz.

Edycja: Zapisano 1 bajt dzięki @Oleg V. Volkov

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

Ungolf i wyjaśnienia

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)

Python 2, 112 bajtów

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

Spróbuję bardziej zagrać w golfa.

Mathematica, 192 bajty

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

Anonimowa funkcja, która przyjmuje żądany ciąg jako argument. Kroki w (dość prostym) algorytmie:

1. Wyczyść sznurek
2. Zamień UC -> „1”, lc -> „0”
3. Zamień ciąg w listę binarną
4. Podziel listę na trzy części i zinterpretuj każdy fragment jako liczbę podstawową 2
5. Zamień cyfry na odpowiednie symbole i ponownie połącz w ciąg.

Ruby 117 114 113 111 86 79 bajtów

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

• tr(?^+m='a-zA-Z','')ustawia m na 'a-zA-Z'i usuwa nieliterowe litery
• .tr(m,?0*26+?1) konwertuje małe litery na 0, wielkie litery na 1
• .scan(/.../) podziel ciąg na grupy po 3 i odrzuć ostatnią grupę, jeśli ma mniej niż 3
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} przekonwertować każdą liczbę binarną na znak

Perl 6, 81 bajtów

Prawdopodobnie można to zrobić lepiej, ale to moja decyzja

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

Stosowanie

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

Bez golfa

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 bajtów

Pełny program, gra w golfa (odczytuje ze standardowego wejścia):

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

Nieco golfisty:

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

Należy pamiętać, że @A... Z[w ASCII, a także dla `a... z}.

Japt v2.0a0 -P, 27 bajtów

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

Zaoszczędź 3 bajty dzięki @Shaggy

Spróbuj

Pyke, 31 bajtów, niekonkurencyjny

Pyke jest starszy niż wyzwanie, ale dodałem kilka funkcji, aby uczynić go bardziej konkurencyjnym - funkcja fragmentu. Użyłem tej samej sztuczki, co @Martin Büttner .

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

Wypróbuj tutaj!

JavaScript, 148 bajtów

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 bajtów

Co, brak odpowiedzi TI-BASIC? Czas, abym to naprawił!

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

Wejście to kod oOo w Ans.
Dane wyjściowe to przetłumaczony kod BF .

Przykłady:

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

Bez gry w golfa:
(dodano nowe linie i komentarze)

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"

Uwagi:

• TI-BASIC jest językiem tokenizowanym. Liczba znaków nie jest równa liczbie bajtów.