Dada a entrada de um programa escrito em oOo CODE , imprima o código BF que ele representa.

Aqui está uma breve descrição de como oOO CODE funciona:

• Primeiro, todos os caracteres não alfabéticos são removidos (tudo que não estiver no intervalo A-Za-z).

  Por exemplo, considere o programa PROgRam reVERsES giVeN iNPut sEqUENcE(um exemplo dado na página wiki do esolangs que faz exatamente o que você esperaria). Após este primeiro passo, temos agora PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Em seguida, divida todos os caracteres restantes em grupos de 3. Agora temos PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. Se houver um grupo à direita de 1 ou 2 caracteres, descarte-o.

• Converta cada grupo de 3 letras em um comando BF com base na tabela a seguir:

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

  Ou seja, se a primeira letra de um grupo é minúsculas, o segundo é maiúscula, eo terceiro é minúscula, que se traduziria ao comando [.

  Com o nosso exemplo, isso finalmente se torna o programa BF ,[>,]<[.<]+, que de fato inverte sua entrada.

Como esse é o código-golfe , o código mais curto em bytes será vencedor.

Casos de teste:

<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

Tinha que ser feito. Experimente aqui .

Golfe:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Traduzido para Brainfuck (com quebras de linha para maior clareza):

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

Ungolfed com explicação:

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

Obrigado pelo desafio interessante!

CJam, 36 35 bytes

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

Teste aqui.

Explicação

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 graças a @ dev-null

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

Eu tentei muitas variantes disso, mas isso parece ser o mais curto. Também funciona com entrada vazia!

Como funciona

Primeiro, com x.replace(/[a-z]/gi,c=>, encontramos cada letra cna entrada. Montamos ae bpara ""na outra extremidade da chamada de função, já que a função ignora os parâmetros passados a segunda. aarmazenará uma string binária para determinar qual caractere estamos criando no momento e barmazenará o resultado.

Agora, a parte confusa: primeiro, com (a+=+(c<'a')), acrescentamos a 0a ase cestiver em maiúsculas; 1de outra forma. Essa expressão retorna o novo valor a, por isso, então podemos verificar se ele atingiu três caracteres de comprimento com, verificando se o personagem no índice 2 existe: [2]?. Caso contrário, simplesmente encerramos a função com :0.

Se aagora tem três caracteres, é um número binário entre 000e 111. Podemos converter isso em um número decimal anexando "0b"ao início e forçando o mecanismo a analisá-lo como um número com '0b'+a-0.

No entanto, ainda precisamos redefinir aa string vazia. Não podemos fazer '0b'+(a="")-0isso porque isso significaria que a string analisada é justa 0b. Felizmente, quando analisado como um número, a cadeia vazia se torna 0, para que possamos substituir o 0por (a="").

Agora temos o nosso número, e nós podemos apenas acrescentar o personagem nesse índice em "><[]-+.,"a b. Após a substituição, usamos &&bpara devolvê-lo da função (Bem, a menos que o resultado de .replaceesteja vazio, o que acontece apenas na entrada vazia e retorna a string vazia de qualquer maneira.)

05AB1E , 35 32 bytes

Código:

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

Usando um truque muito inteligente de Martin Büttner, desta resposta . Explicação:

á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

Experimente online!

Usa a codificação CP-1252 .

Retina , 79 75 71 70 bytes

Agradecemos a randomra por economizar 1 byte.

i`[^a-z]

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

Experimente online!

Explicação

i`[^a-z]

Começamos removendo tudo o que não é uma carta.

M!`...

Isso divide a string em pedaços de três caracteres, retornando todas as correspondências de 3 caracteres (sem sobreposição). Isso descarta automaticamente qualquer pedaço incompleto à direita.

m`^
;

Anexe um ;a cada linha. Usaremos isso como um marcador para a conversão de base 2. Falando nisso, simplesmente trataremos as letras maiúsculas 1e minúsculas como 0.

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

Isso faz uma divertida conversão de base 2 para unária. A cada passo, simplesmente dobramos os caracteres à esquerda ;e movemos o caracter ;para a direita. Por que isso funciona? Lembre-se de que interpretaremos letras minúsculas como 0e maiúsculas como 1. Sempre que processamos uma letra, simplesmente dobramos o total atual (à esquerda) até o momento - as letras minúsculas são justas 2*0=0, para que possam ser completamente ignoradas e as letras maiúsculas representam o número binário até agora, dobrando-as é o que nós queremos. Em seguida, adicionamos a letra atual ao total em execução que representa 0ou 1corresponde.

T`l

Remova todas as letras minúsculas / zeros.

.+
$.&

Combine cada linha e substitua-a pelo número (decimal) de caracteres nessa linha. Devido a ;isso, o número unário é convertido em seu equivalente decimal + 1.

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

Transliteração que substitui 1-8 pelo comando correspondente.

¶

Remova as alimentações de linha.

MATL , 38 32 bytes

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

Experimente 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

Japonês, 37 36 bytes

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

Teste online!

Como 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``

Simplesmente remove não letras, converte letras maiúsculas em 1s e minúsculas em 0s, divide-se em grupos de três, ignora um grupo à direita de 1 ou 2 e decodifica os grupos.

Editar: salvou 16 bytes graças a @ dev-null, embora o código não funcione mais quando passou a string vazia.

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 um pouco longo, especialmente a segunda linha. b=[b,2*b+(c<'a')][c.isalpha()]é um pouco pior ainda.

Pitão, 40 bytes

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

Experimente aqui!

Poderia salvar 2 bytes se eu puder exibir o resultado como lista de caracteres em vez de uma sequência.

Explicação

Filtra todas as não letras, converte maiúsculas em 1 e minúsculas em 0, divide-se em partes de 3, interpreta cada parte como número binário e a usa como índice em uma sequência que contém todos os comandos BF.

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

                                entrada de filtro fz # com T
                                 ! # lógico não
                                  rIT2 # T == swapcase (T), verdadeiro se T não for uma letra
                        resultado do filtro de mapa m # com d
                         ? rId0 # if d == toLower (d)
                              Z1 # 0 para letras minúsculas, 1 para letras maiúsculas
                       c 3 # Divida em partes de 3, o último elemento é mais curto, se necessário
                 filtro f # com T
                  ! # lógico não
                   % lT3 # len (t) mod 3 -> mantenha apenas elementos de comprimento 3
  mapa m # com d
              id2 # Converter de binário em decimal
   @ "> <[] - +.," # Obtenha o comando BF resultante
jk # Associar a uma sequência

Jolf, 31 34 bytes

Experimente aqui! Substitua ►por \x10e ♣com \x05. Como eu implementei a função chop incorretamente, ganho 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 '><[]-+.,')))))

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. use ++ murn para se livrar de todos os caracteres da entrada que não podem ser analisados ​​com "alf" (alfabeto)
2. analise a lista com um combinador que gera cada 3 caracteres por vez em uma lista, substituindo letras minúsculas por '0' e maiúsculas por '1'
3. Transmitir o resultado para (unidade (listar fita)) e desembrulhá-lo à força para obter o resultado mais analisado, para trabalhar apenas com múltiplos de três sem bater
4. Mapeie a lista, analisando cada grupo como se fosse binário
5. Use cada número da lista como um índice no texto '> <[] - +.,' E transmita a lista novamente para uma fita.

Hoon não possui expressões regulares apropriadas, apenas uma biblioteca combinadora de analisadores, por isso é muito detalhada. A varredura ++ também falha se o fluxo de entrada inteiro não for analisado, então eu tenho que usar ++ rose, coagir em uma unidade e desembrulhá-la para o valor "análise mais distante". Também faz uso pesado para currying e mapeamento sobre listas (turno ++), então eu alias os nomes das funções para variáveis ​​de uma letra.

Hoon é a linguagem de programação do Urbit, um projeto limpo de reimplementação de ardósia. É puramente funcional, de tipo estático, vagamente parecido com um cisco e compila com o Nock. Nock é uma VM baseada em combinador que é executada em cima de um modelo de memória bignum de árvore binária.

Quando você inicializa o Urbit, você entra em: dojo, o shell e o Hoon substituem. Para executar o snippet, digite:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

e cole a função autônoma na próxima linha.

Gelatina , 27 bytes

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

Experimente online! Observe que as barras invertidas precisam escapar na sequência de entrada para o segundo último caso de teste.

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. Limpar \ limpo
2. aparar
3. remodelar em uma matriz 3xn m com UC = 1, lc = 0
4. (4 2 1) * m + 1 resulta em uma lista de índices
5. Índice para os caracteres certos

Perl, 76 73 72 + 1 = 73 bytes

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

Requer a -nbandeira:

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

Usando o truque com conversão de base 2 .

Como 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 é uma função anônima que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

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 bytes

Grande uso string.gsub()daqui, mais uma vez poderia ter me permitido criar um ponteiro de um caractere nessa função para obter alguns bytes. Além disso, é o meu primeiro programa lua sem espaços! : D

Este programa recebe sua entrada via argumento da linha de comando e gera um programa BrainFuck, um comando por linha.

Edit: Saved 1 Byte graças 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 explicações

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))

Vai tentar jogar mais.

Mathematica, 192 bytes

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

Função anônima que usa a string desejada como argumento. Etapas no algoritmo (bastante direto):

1. Limpe a corda
2. Substitua UC -> "1", lc -> "0"
3. Transforme a string em uma lista binária
4. Particione a lista em três e interprete cada parte como um número base-2
5. Substitua os números pelos símbolos apropriados e junte-os novamente em uma sequência.

Ruby 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','')define m como 'a-zA-Z'e remove não letras
• .tr(m,?0*26+?1) converte minúsculas em 0, maiúsculas em 1
• .scan(/.../) string de grupo em grupos de 3 e descartar o último grupo se tiver menos de 3
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} converter cada número binário em um caractere

Perl 6, 81 bytes

Provavelmente isso pode ser feito melhor, mas esta é a minha chance

{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 bytes

Programa completo, jogado no golfe (leituras da entrada padrão):

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

Um pouco não-destruído:

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

Note-se que @A... Z[em ASCII, e da mesma forma para `a... z}.

Japt v2.0a0 -P, 27 bytes

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

Guardado 3 bytes graças a @Shaggy

Tente

Pyke, 31 bytes, não competitivo

Pyke é mais antigo que o desafio, mas eu adicionei alguns recursos para torná-lo mais competitivo - função de bloco. Eu usei o mesmo truque que o @Martin Büttner usou.

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

Experimente aqui!

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

O que, sem respostas TI-BASIC? Hora de eu consertar isso!

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

Entrada é o código oOo em Ans.
Saída é o código BF traduzido .

Exemplos:

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

Sem golfe:
(novas linhas e comentários adicionados)

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 é uma linguagem tokenizada. Contagem de caracteres não é igual à contagem de bytes.