Dato un input di un programma scritto in oOo CODE , emette il codice BF che rappresenta.

Ecco una breve descrizione di come funziona oOo CODE:

• Innanzitutto, vengono rimossi tutti i caratteri non alfabetici (tutto ciò che non rientra nell'intervallo A-Za-z).

  Ad esempio, prendi il programma PROgRam reVERsES giVeN iNPut sEqUENcE(un esempio dato sulla pagina wiki di esolangs che fa esattamente quello che ti aspetteresti). Dopo questo primo passo, ora abbiamo PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Quindi, dividi tutti i personaggi rimanenti in gruppi di 3. Ora abbiamo PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. Se esiste un gruppo finale di 1 o 2 caratteri, scartalo.

• Converti ogni gruppo di 3 lettere in un comando BF basato sulla seguente tabella:

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

  Cioè, se la prima lettera di un gruppo è in minuscolo, la seconda in maiuscolo e la terza in minuscolo, si tradurrebbe in comando [.

  Con il nostro esempio, questo diventa finalmente il programma BF ,[>,]<[.<]+, che in effetti inverte il suo input.

Dato che si tratta di code-golf , vincerà il codice più breve in byte.

Casi test:

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

oOo, 1569 1515 byte

Doveva essere fatto. Provalo qui .

golfed:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Tradotto in Brainfuck (con interruzioni di riga per maggiore chiarezza):

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

Ungolfed con spiegazione:

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

Grazie per l'interessante sfida!

CJam, 36 35 byte

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

Provalo qui.

Spiegazione

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 byte

Salvato 1 byte grazie a @ dev-null

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

Ho provato molte varianti di questo, ma questo sembra essere il più breve. Funziona anche con input vuoti!

Come funziona

In primo luogo, con x.replace(/[a-z]/gi,c=>, troviamo prendere ogni lettera cnell'input. Abbiamo impostato ae bal ""all'altra estremità della chiamata di funzione, poiché la funzione ignora eventuali parametri passati al secondo. amemorizzerà una stringa binaria per determinare quale carattere stiamo attualmente creando e bmemorizzerà il risultato.

Ora per la parte confusa: prima, con (a+=+(c<'a')), aggiungiamo 0a ase cè maiuscolo; 1altrimenti. Questa espressione restituisce il nuovo valore a, così poi possiamo controllare se ha raggiunto tre caratteri di lunghezza con verificando se il carattere 2 dell'indice esiste: [2]?. In caso contrario, terminiamo semplicemente la funzione con :0.

Se aora ha tre caratteri, è un numero binario compreso tra 000e 111. Possiamo convertirlo in un numero decimale aggiungendo "0b"all'inizio, quindi forzando il motore a analizzarlo come numero con '0b'+a-0.

Tuttavia, dobbiamo ancora ripristinare ala stringa vuota. Non possiamo semplicemente farlo '0b'+(a="")-0perché ciò significherebbe che la stringa analizzata è giusta 0b. Fortunatamente, quando analizzata come un numero, la stringa vuota diventa 0, quindi possiamo sostituire 0con (a="").

Ora abbiamo il nostro numero, e noi possiamo solo aggiungere il carattere in quel indice in "><[]-+.,"a b. Al termine della sostituzione, utilizziamo &&bper restituirlo dalla funzione. (Beh, a meno che il risultato di .replacesia vuoto, ciò accade solo con input vuoto e restituisce comunque la stringa vuota.)

05AB1E , 35 32 byte

Codice:

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

Usando un trucco molto intelligente di Martin Büttner, da questa risposta . Spiegazione:

á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

Provalo online!

Utilizza la codifica CP-1252 .

Retina , 79 75 71 70 byte

Grazie a randomra per il salvataggio di 1 byte.

i`[^a-z]

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

Provalo online!

Spiegazione

i`[^a-z]

Iniziamo rimuovendo tutto ciò che non è una lettera.

M!`...

Ciò divide la stringa in blocchi di tre caratteri restituendo tutte le corrispondenze di 3 caratteri (non sovrapposte). Questo scarta automaticamente qualsiasi blocco finale incompleto.

m`^
;

Prepara a ;per ogni riga. Lo useremo come marker per la conversione di base 2. A proposito, tratteremo semplicemente le lettere maiuscole come 1e le lettere minuscole come 0.

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

Questo fa una divertente conversione da base 2 a unaria. Ad ogni passaggio semplicemente raddoppiamo i caratteri a sinistra di ;e spostiamo ;quello a destra. Perché funziona? Ricorda che interpreteremo lettere minuscole come 0e maiuscole come 1. Ogni volta che elaboriamo una lettera, raddoppiamo semplicemente il totale corrente (a sinistra) finora - le doppie lettere minuscole sono giuste 2*0=0, quindi possono essere completamente ignorate e le lettere maiuscole rappresentano il numero binario finora, quindi raddoppiarle è ciò che vogliamo. Quindi aggiungiamo la lettera corrente al totale corrente che rappresenta 0o 1corrispondentemente.

T`l

Rimuovi tutte le lettere minuscole / zero.

.+
$.&

Abbina ogni riga e sostituiscila con il numero (decimale) di caratteri in quella riga. A causa di ;ciò trasforma il numero unario nel suo equivalente decimale + 1.

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

Traslitterazione che sostituisce 1-8 con il comando corrispondente.

¶

Rimuovere gli avanzamenti di riga.

MATL , 38 32 byte

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

Provalo 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 byte

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

Provalo online!

Come funziona

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 byte

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

Rimuove semplicemente le non lettere, converte le lettere maiuscole in 1 e le lettere minuscole in 0, si divide in gruppi di tre, ignora un gruppo finale di 1 o 2 e decodifica i gruppi.

Modifica: salvato 16 byte grazie a @ dev-null, anche se il codice non funziona più quando viene passata la stringa vuota.

Python 3, 91 byte

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

Hmm ... sembra un po 'lungo, specialmente la seconda riga. b=[b,2*b+(c<'a')][c.isalpha()]è leggermente peggio però.

Pyth, 40 byte

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

Provalo qui!

Potrebbe salvare 2 byte se riesco a visualizzare il risultato come elenco di caratteri anziché come stringa.

Spiegazione

Filtra tutte le non lettere, converte maiuscole in 1 e minuscole in 0, si divide in blocchi di 3, interpreta ogni blocco come numero binario e lo utilizza come indice in una stringa che contiene tutti i comandi BF.

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

                                ingresso filtro fz # con T
                                 ! # logico no
                                  rIT2 # T == swapcase (T), vero se T non è una lettera
                        m # risultato del filtro della mappa con d
                         ? rId0 # if d == toLower (d)
                              Z1 # 0 per lettere minuscole, 1 per lettere maiuscole
                       c 3 # Suddiviso in blocchi di 3, l'ultimo elemento è più corto se necessario
                 filtro f # con T
                  ! # logico no
                   % lT3 # len (t) mod 3 -> conserva solo elementi di lunghezza 3
  m # mappa con d
              id2 # Converti da binario a decimale
   @ "> <[] - +.," # Ottieni il comando BF risultante
jk # Unisciti a una stringa

Jolf, 31 34 byte

Provalo qui! Sostituisci ►con \x10e ♣con \x05. Poiché ho implementato la funzione chop in modo errato, guadagno 3 byte. :(

►Μ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 byte

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

Ungolfed:

|=  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. usa ++ murn per eliminare tutti i caratteri nell'input che non possono essere analizzati con "alf" (alfabeto)
2. analizzare l'elenco con un combinatore che genera ogni 3 caratteri alla volta in un elenco, sostituendo le lettere minuscole con "0" e le maiuscole con "1"
3. Trasmetti il ​​risultato in (unit (list list)) e scartalo con la forza per ottenere il risultato analizzato più lontano, per lavorare solo con più di tre senza crash
4. Mappa sulla lista, analizzando ogni gruppo come se fosse binario
5. Utilizzare ogni numero nell'elenco come indice nel testo '> <[] - +.,' E ricollocare l'elenco su un nastro.

Hoon non ha le espressioni regolari appropriate, ma solo una libreria combinatrice di parser, quindi è purtroppo piuttosto prolisso. La scansione ++ si arresta anche in modo anomalo se l'intero flusso di input non viene analizzato, quindi devo usare ++ rose, forzarlo in un'unità e scartarlo per il valore di "analisi più lontana". Fa anche un uso pesante per il curry e la mappatura su liste (++ turn), quindi alias i nomi delle funzioni su variabili di una lettera.

Hoon è il linguaggio di programmazione di Urbit, un progetto di reimplementazione dell'ardesia pulito. È puramente funzionale, tipicamente statico, vagamente lisp-like e si compila su Nock. Nock è una macchina virtuale basata su combinatore che viene eseguita su un modello di memoria bignum ad albero binario.

Quando si avvia Urbit, si viene rilasciati in: dojo, la shell e Hoon sostitu. Per eseguire lo snippet, digita semplicemente:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

e quindi incolla la funzione standalone sulla riga successiva.

Gelatina , 27 byte

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

Provalo online! Si noti che le barre rovesciate devono essere salvate nella stringa di input per il secondo ultimo test case.

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 byte

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. Pulito
2. Trim
3. rimodellare in una matrice 3xn m con UC = 1, lc = 0
4. (4 2 1) * m + 1 risulta in un elenco di indici
5. Indice ai caratteri corretti

Perl, 76 73 72 + 1 = 73 byte

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

Richiede la -nbandiera:

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

Usando il trucco con la conversione base-2 .

Come funziona:

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

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

Questa è una funzione anonima che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Ungolfed:

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 byte

Un grande uso di string.gsub()questo, un'altra volta mi avrebbe permesso di creare un puntatore di un carattere su questa funzione per guadagnare alcuni byte. Inoltre, è il mio primo programma lua senza spazi! : D

Questo programma prende il suo input tramite argomento della riga di comando e genera un programma BrainFuck, un comando per riga.

Modifica: salvato 1 byte grazie a @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 e spiegazioni

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 byte

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

Proverò a golf di più.

Mathematica, 192 byte

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

Funzione anonima che accetta la stringa desiderata come argomento. Passaggi dell'algoritmo (piuttosto semplice):

1. Pulisci la corda
2. Sostituisci UC -> "1", lc -> "0"
3. Trasforma la stringa in un elenco binario
4. Suddividere l'elenco in tre e interpretare ogni blocco come un numero base-2
5. Sostituisci i numeri con i simboli appropriati e ricollegali in una stringa.

Rubino 117 114 113 111 111 86 79 Byte

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

• tr(?^+m='a-zA-Z','')imposta m su 'a-zA-Z'e rimuove le non lettere
• .tr(m,?0*26+?1) converte le lettere minuscole in 0, le maiuscole in 1
• .scan(/.../) tagliare la stringa in gruppi di 3 e scartare l'ultimo gruppo se ha meno di 3
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} converte ogni numero binario in un carattere

Perl 6, 81 byte

Probabilmente questo può essere fatto meglio, ma questo è il mio tentativo

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

uso

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

Ungolfed

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 byte

Programma completo, golf (legge dallo standard input):

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

Abbastanza ungolfed:

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

Si noti che @A... Z[in ASCII, e allo stesso modo per `a... z}.

Japt v2.0a0 -P, 27 byte

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

Salvato 3 byte grazie a @Shaggy

Provalo

Pyke, 31 byte, non competitivo

Pyke è più vecchio della sfida, ma ho aggiunto alcune funzionalità per renderlo più competitivo: la funzione di blocco. Ho usato lo stesso trucco usato da @Martin Büttner .

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

Provalo qui!

JavaScript, 148 byte

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 byte

Cosa, nessuna risposta TI-BASIC? Tempo per me di sistemarlo!

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

Input è il codice oOo in Ans.
L'output è il codice BF tradotto .

Esempi:

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

Senza golf: (Newline e commenti aggiunti)

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"

Appunti:

• TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.