Dada una entrada de un programa escrito en oOo CODE , genera el código BF que representa.

Aquí hay una breve descripción de cómo funciona oOo CODE:

• Primero, se eliminan todos los caracteres no alfabéticos (todo lo que no está en el rango A-Za-z).

  Por ejemplo, tome el programa PROgRam reVERsES giVeN iNPut sEqUENcE(un ejemplo dado en la página wiki de esolangs que hace exactamente lo que esperaría). Después de este primer paso, ahora tenemos PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Luego, divide todos los personajes restantes en grupos de 3. Ahora tenemos PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. Si hay un grupo final de 1 o 2 caracteres, deséchelo.

• Convierta cada grupo de 3 letras en un comando BF basado en la siguiente tabla:

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

  Es decir, si la primera letra de un grupo es minúscula, la segunda es mayúscula y la tercera es minúscula, se traduciría al comando [.

  Con nuestro ejemplo, esto finalmente se convierte en el programa BF ,[>,]<[.<]+, que de hecho invierte su entrada.

Como se trata de code-golf , ganará el código más corto en bytes.

Casos de prueba:

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

oOo, 1569 1515 bytes

Tenia que estar hecho. Probar aquí .

Golfizado:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Traducido a Brainfuck (con saltos de línea para mayor claridad):

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

Sin golfing con explicación:

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

¡Gracias por el interesante desafío!

CJam, 36 35 bytes

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

Pruébalo aquí.

Explicación

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 bytes

Guardado 1 byte gracias a @ dev-null

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

He probado muchas variantes de esto, pero esta parece ser la más corta. ¡También funciona en entradas vacías!

Cómo funciona

Primero, con x.replace(/[a-z]/gi,c=>, encontramos tomar cada letra cen la entrada. Hemos establecido ay bque ""en el otro extremo de la llamada a la función, ya que la función pasa por alto los parámetros pasados al segundo. aalmacenará una cadena binaria para determinar qué carácter estamos creando actualmente y balmacenará el resultado.

Ahora para la parte confusa: primero, con (a+=+(c<'a')), agregamos un 0a asi ces mayúscula; 1de otra manera. Esta expresión devuelve el nuevo valor de a, por lo que podemos comprobar si se ha llegado a tres caracteres de longitud con comprobando si existe el carácter en el índice 2: [2]?. Si no, simplemente terminamos la función con :0.

Si aahora tiene tres caracteres de longitud, es un número binario entre 000y 111. Podemos convertir esto a un número decimal agregando "0b"al principio, luego forzando al motor a analizarlo como un número con '0b'+a-0.

Sin embargo, aún necesitamos restablecer ala cadena vacía. No podemos hacerlo '0b'+(a="")-0porque eso significaría que la cadena analizada es justa 0b. Afortunadamente, cuando se analiza como un número, la cadena vacía se convierte en 0, por lo que podemos reemplazarla 0por (a="").

Ahora tenemos nuestro número, y sólo podemos añadir el carácter de ese índice en "><[]-+.,"a b. Después de que se realiza el reemplazo, usamos &&bpara devolverlo de la función. (Bueno, a menos que el resultado de .replaceesté vacío, lo que solo sucede en la entrada vacía y de todos modos devuelve la cadena vacía).

05AB1E , 35 32 bytes

Código:

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

Usando un truco muy inteligente de Martin Büttner, de esta respuesta . Explicación:

á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

Pruébalo en línea!

Utiliza la codificación CP-1252 .

Retina , 79 75 71 70 bytes

Gracias a randomra por guardar 1 byte.

i`[^a-z]

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

Pruébalo en línea!

Explicación

i`[^a-z]

Comenzamos eliminando todo lo que no es una carta.

M!`...

Esto divide la cadena en fragmentos de tres caracteres al devolver todas las coincidencias (no superpuestas) de 3 caracteres. Esto descarta automáticamente cualquier fragmento final incompleto.

m`^
;

Anteponer una ;a cada línea. Usaremos esto como un marcador para la conversión de base-2. Hablando de eso, simplemente trataremos las letras mayúsculas como 1y las letras minúsculas como 0.

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

Esto hace una divertida conversión de base-2 a unario. En cada paso simplemente duplicamos los caracteres a la izquierda del ;y movemos el ;de la derecha. ¿Por qué funciona esto? Recuerde que interpretaremos minúsculas como 0y mayúsculas como 1. Cada vez que procesamos una letra, simplemente duplicamos el total acumulado (a la izquierda) hasta el momento: las letras minúsculas dobles son justas 2*0=0, por lo que pueden ignorarse por completo y las letras mayúsculas representan el número binario hasta el momento, por lo que duplicarlas es lo que nosotros queremos. Luego agregamos la letra actual a ese total acumulado que representa 0o 1correspondientemente.

T`l

Elimine todas las letras minúsculas / ceros.

.+
$.&

Haga coincidir cada línea y reemplácela con el número (decimal) de caracteres en esa línea. Debido a ;esto, el número unario se convierte en su equivalente decimal + 1.

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

Transliteración que sustituye 1-8 con el comando correspondiente.

¶

Eliminar avances de línea.

MATL , 38 32 bytes

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

Pruébalo en línea!

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

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

¡Pruébelo en línea!

Cómo funciona

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 bytes

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

Simplemente elimina las no letras, convierte las letras mayúsculas en 1 y las minúsculas en 0, se divide en grupos de tres, ignora un grupo final de 1 o 2 y decodifica los grupos.

Editar: se guardaron 16 bytes gracias a @ dev-null, aunque el código ya no funciona cuando se pasa la cadena vacía.

Python 3, 91 bytes

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

Hmm ... parece un poco largo, especialmente la segunda línea. b=[b,2*b+(c<'a')][c.isalpha()]aunque es un poco peor.

Pyth, 40 bytes

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

Pruébalo aquí!

Podría ahorrar 2 bytes si puedo generar el resultado como una lista de caracteres en lugar de una cadena.

Explicación

Filtra todas las no letras, convierte las mayúsculas a 1 y las minúsculas a 0, las divide en fragmentos de 3, interpreta cada fragmento como número binario y lo utiliza como índice en una cadena que contiene todos los comandos BF.

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

                                Entrada de filtro fz # con T
                                 ! # lógico no
                                  rIT2 # T == swapcase (T), verdadero si T no es una letra
                        m # resultado del filtro de mapa con d
                         ? rId0 # if d == toLower (d)
                              Z1 # 0 para minúsculas, 1 para mayúsculas
                       c 3 # Dividido en trozos de 3, el último elemento es más corto si es necesario
                 filtro f # con T
                  ! # lógico no
                   % lT3 # len (t) mod 3 -> mantener solo elementos de longitud 3
  m # mapa con d
              id2 # Convertir de binario a decimal
   @ "> <[] - +.," # Obtiene el comando BF resultante
jk # Únete a una cadena

Jolf, 31 34 bytes

Pruébalo aquí! Reemplazar ►con \x10y ♣con \x05. Debido a que implementé la función chop incorrectamente, gano 3 bytes. :(

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

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

Sin golf:

|=  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. use ++ murn para deshacerse de todos los caracteres en la entrada que no se pueden analizar con "alf" (alfabeto)
2. analizar la lista con un combinador que genera cada 3 caracteres a la vez en una lista, reemplazando las minúsculas con '0' y las mayúsculas con '1'
3. Transmita el resultado a (unidad (lista de cintas)) y desenvuélvalo a la fuerza para obtener el resultado analizado más avanzado, para trabajar con solo múltiples de tres sin chocar
4. Mapa sobre la lista, analizando cada grupo como si fuera binario
5. Use cada número de la lista como índice en el texto '> <[] - +.,' Y vuelva a convertir la lista en una cinta.

Hoon no tiene expresiones regulares adecuadas, solo una biblioteca de combinador de analizador, por lo que es tristemente bastante detallado. ++ scan también se bloquea si no se analiza el flujo de entrada completo, por lo que tengo que usar ++ rose, forzarlo en una unidad y desenvolverlo para obtener el valor de "análisis más lejano". También hace un uso intensivo del currículum y el mapeo sobre listas (++ turn), por lo que alias los nombres de las funciones a las variables de una letra.

Hoon es el lenguaje de programación para Urbit, un proyecto de reimplementación de pizarra limpia. Es puramente funcional, estáticamente tipado, vagamente parecido a un lisp, y se compila a Nock. Nock es una máquina virtual basada en combinador que se ejecuta sobre un modelo de memoria bignum de árbol binario.

Cuando inicia Urbit, se lo deja caer en: dojo, el shell y Hoon repl. Para ejecutar el fragmento simplemente escriba:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

y luego pegue la función independiente en la siguiente línea.

Jalea , 27 bytes

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

Pruébalo en línea! Tenga en cuenta que las barras invertidas necesitan escapar en la cadena de entrada para el segundo último caso de prueba.

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 bytes

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. Limpiar
2. Podar
3. remodelar en una matriz 3xn m con UC = 1, lc = 0
4. (4 2 1) * m + 1 da como resultado una lista de índice
5. Indice los caracteres correctos

Perl, 76 73 72 + 1 = 73 bytes

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

Requiere la -nbandera:

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

Usando el truco con la conversión de base 2 .

Cómo funciona:

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

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

Esta es una función anónima que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable.

Sin golf:

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 bytes

Gran uso de string.gsub()aquí, una vez más podría haberme permitido crear un puntero de un carácter en esta función para ganar algunos bytes. Además, ¡es mi primer programa lua sin espacios! :RE

Este programa toma su entrada a través del argumento de la línea de comandos y genera un programa BrainFuck, un comando por línea.

Editar: Guardado 1 Byte gracias 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 y explicaciones

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 bytes

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

Intentaré jugar más al golf.

Mathematica, 192 bytes

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

Función anónima que toma la cadena deseada como argumento. Pasos en el algoritmo (bastante sencillo):

1. Limpiar la cuerda
2. Reemplace UC -> "1", lc -> "0"
3. Convertir la cadena en una lista binaria
4. Divida la lista en tres e interprete cada fragmento como un número de base 2
5. Reemplace los números con sus símbolos apropiados y vuelva a unirse en una cadena.

Rubí 117 114 113 111 86 79 Bytes

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

• tr(?^+m='a-zA-Z','')establece m en 'a-zA-Z'y elimina no letras
• .tr(m,?0*26+?1) convierte minúsculas a 0, mayúsculas a 1
• .scan(/.../) fragmente la cadena en grupos de 3 y descarte el último grupo si tiene menos de 3
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} convierte cada número binario en un carácter

Perl 6, 81 bytes

Esto probablemente se puede hacer mejor, pero esta es mi intención.

{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")
,[>,]<[.<]+

Sin golf

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 bytes

Programa completo, golfizado (lecturas de entrada estándar):

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

Algo no golfista:

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

Tenga en cuenta que @A... Z[en ASCII, y lo mismo para `a... z}.

Japt v2.0a0 -P, 27 bytes

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

Guardado 3 bytes gracias a @Shaggy

Intentalo

Pyke, 31 bytes, no competitivo

Pyke es más antiguo que el desafío, pero agregué algunas características para hacerlo más competitivo: la función de fragmento. Usé el mismo truco que @Martin Büttner .

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

Pruébalo aquí!

JavaScript, 148 bytes

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 bytes

¿Qué, no hay respuestas de TI-BASIC? ¡Es hora de que arregle eso!

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

La entrada es el oOo código en Ans.
La salida es el código BF traducido .

Ejemplos:

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

Sin golf:
(Nuevas líneas y comentarios añadidos)

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"

Notas:

• TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.