Étant donné l'entrée d'un programme écrit en oOo CODE , indiquez le code BF qu'il représente.

Voici une brève description du fonctionnement de oOo CODE:

• Tout d'abord, tous les caractères non alphabétiques sont supprimés (tout ce qui n'est pas dans la plage A-Za-z).

  Par exemple, prenons le programme PROgRam reVERsES giVeN iNPut sEqUENcE(un exemple donné sur la page wiki esolangs qui fait exactement ce que vous attendez). Après cette première étape, nous avons maintenant PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Ensuite, divisez tous les caractères restants en groupes de 3. Nous avons maintenant PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. S'il existe un groupe de fin de 1 ou 2 caractères, éliminez-le.

• Convertissez chaque groupe de 3 lettres en une commande BF en fonction du tableau suivant:

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

  En d’autres termes, si la première lettre d’un groupe est en minuscule, la seconde en majuscule et la troisième en minuscule, la traduction sera renvoyée à la commande [.

  Avec notre exemple, cela devient finalement le programme BF ,[>,]<[.<]+, qui inverse son entrée.

Puisqu'il s'agit de code-golf , le code le plus court en octets va gagner.

Cas de 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 octets

Cela devait être fait. Essayez ici .

Golfé:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Traduit en Brainfuck (avec des sauts de ligne pour plus de clarté):

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

Ungolfed avec explication:

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

Merci pour le défi intéressant!

CJam, 36 35 octets

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

Testez-le ici.

Explication

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 octets

Sauvegardé 1 octet grâce à @ dev-null

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

J'ai essayé de nombreuses variantes, mais cela semble être la plus courte. Fonctionne également sur une entrée vide!

Comment ça fonctionne

Tout d’abord, avec x.replace(/[a-z]/gi,c=>, on trouve prendre chaque lettre cdans l’entrée. Nous fixons aet bà ""l'autre extrémité de l'appel de fonction, la fonction ne tient pas compte des paramètres passés du second. astockera une chaîne binaire pour déterminer le caractère que nous sommes en train de créer et bstockera le résultat.

Maintenant , pour la partie source de confusion: d' abord, avec (a+=+(c<'a')), nous ajoutons un 0à asi cest en majuscules; 1autrement. Cette expression renvoie la nouvelle valeur a, donc nous pouvons vérifier si elle a atteint trois caractères de longueur avec en vérifiant si le caractère à l' index 2 existe: [2]?. Sinon, nous terminons simplement la fonction avec :0.

Si aest maintenant trois caractères de long, c'est un nombre binaire entre 000et 111. Nous pouvons convertir cela en nombre décimal en ajoutant "0b"au début, puis en forçant le moteur à l'analyser sous forme de nombre '0b'+a-0.

Cependant, nous devons toujours réinitialiser ala chaîne vide. Nous ne pouvons pas simplement faire '0b'+(a="")-0parce que cela voudrait dire que la chaîne analysée est juste 0b. Heureusement, quand elle est analysée sous forme de nombre, la chaîne vide devient 0, nous pouvons donc remplacer le 0avec (a="").

Maintenant , nous avons notre numéro et nous pouvons simplement ajouter le caractère à cet indice "><[]-+.,"pour b. Une fois le remplacement effectué, nous l’utilisons &&bpour le renvoyer depuis la fonction. (Eh bien, à moins que le résultat de .replacesoit vide, cela ne se produit que sur une entrée vide et retourne de toute façon la chaîne vide.)

05AB1E , 35 32 octets

Code:

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

En utilisant une astuce très intelligente de Martin Büttner, tirée de cette réponse . Explication:

á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

Essayez-le en ligne!

Utilise le codage CP-1252 .

Retina , 79 75 71 70 octets

Merci à randomra pour avoir sauvegardé 1 octet.

i`[^a-z]

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

Essayez-le en ligne!

Explication

i`[^a-z]

Nous commençons par enlever tout ce qui n'est pas une lettre.

M!`...

Cela divise la chaîne en morceaux de trois caractères en renvoyant toutes les correspondances à 3 caractères (ne se chevauchant pas). Ceci jette automatiquement tout morceau de fin incomplet.

m`^
;

Ajoutez un ;à chaque ligne. Nous utiliserons cela comme marqueur pour la conversion en base 2. En parlant de cela, nous allons simplement traiter les lettres majuscules comme des lettres 1minuscules 0.

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

Cela fait une conversion amusante base-2 à unaire. A chaque étape, nous doublons simplement les caractères restants ;et déplaçons ;celui vers la droite. Pourquoi ça marche? N'oubliez pas que nous interprétons les minuscules comme 0majuscules 1. Chaque fois que nous traitons une lettre, nous doublons simplement le total cumulé (à gauche) jusqu'à présent - les doubles lettres minuscules sont justes 2*0=0, elles peuvent donc être complètement ignorées et les majuscules représentent le nombre binaire jusqu'à présent; il est donc double de les doubler. ce que nous voulons. Ensuite, nous ajoutons la lettre actuelle à ce total courant qui représente 0ou 1correspond.

T`l

Supprimez toutes les lettres minuscules / zéros.

.+
$.&

Faites correspondre chaque ligne et remplacez-la par le nombre (décimal) de caractères de cette ligne. En raison de ;cela, le nombre unaire devient son équivalent décimal + 1.

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

Translittération qui substitue 1-8 avec la commande correspondante.

¶

Supprimer les retours à la ligne.

MATL , 38 32 octets

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

Essayez-le en ligne!

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

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

Testez-le en ligne!

Comment ça fonctionne

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 octets

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

Supprime simplement les non-lettres, convertit les majuscules en 1 et les minuscules en 0, se divise en groupes de trois, ignore un dernier groupe de 1 ou 2 et décode les groupes.

Edit: 16 octets enregistrés grâce à @ dev-null, bien que le code ne fonctionne plus lorsqu'il est transmis à la chaîne vide.

Python 3, 91 octets

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

Hmm ... a l'air un peu long, surtout la deuxième ligne. b=[b,2*b+(c<'a')][c.isalpha()]est légèrement pire cependant.

Pyth, 40 octets

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

Essayez-le ici!

Pourrait économiser 2 octets si je peux sortir le résultat sous forme de liste de caractères au lieu d’une chaîne.

Explication

Filtre toutes les lettres, convertit les majuscules en 1 et les minuscules en 0, se divise en morceaux de 3, interprète chaque morceau comme un nombre binaire et l'utilise comme index en une chaîne contenant toutes les commandes BF.

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

                                entrée filtre fz # avec T
                                 ! # pas logique
                                  rIT2 # T == swapcase (T), true si T n'est pas une lettre
                        m # résultat de filtrage avec d
                         ? rId0 # si d == toLower (d)
                              Z1 # 0 pour les minuscules, 1 pour les majuscules
                       c 3 # Divisé en morceaux de 3, le dernier élément est plus court si nécessaire
                 filtre f # avec T
                  ! # pas logique
                   % lT3 # len (t) mod 3 -> ne garder que les éléments de longueur 3
  m # carte avec d
              id2 # Convertir du binaire en décimal
   @ "> <[] - +.," # Récupère la commande BF résultante
jk # Rejoindre une chaîne

Jolf, 31 34 octets

Essayez-le ici! Remplacer ►par \x10et ♣avec \x05. Comme j'ai mal implémenté la fonction de hachage, je gagne 3 octets. :(

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

=+([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. utilisez ++ murn pour supprimer tous les caractères de l'entrée ne pouvant pas être analysés avec "alf" (alphabet)
2. analyser la liste avec un combinateur qui génère 3 caractères à la fois dans une liste, en remplaçant minuscule par '0' et en majuscule par '1'
3. Transformez le résultat en (unit (list tape))) et dépliez-le de force pour obtenir le résultat analysé le plus éloigné afin de ne fonctionner qu'avec plusieurs multiples de trois sans se planter.
4. Carte sur la liste, en analysant chaque groupe comme si c'était binaire
5. Utilisez chaque numéro de la liste comme index dans le texte '> <[] - +.,' Et convertissez la liste sur une bande.

Hoon ne possède pas d'expressions régulières appropriées, il ne dispose que d'une bibliothèque de combinateurs d'analyseurs syntaxiques, ce qui en fait un très joli mot. ++ scan se bloque également si l'ensemble du flux d'entrée n'est pas analysé. Je dois donc utiliser ++ rose, le contraindre en une unité et le décompresser pour obtenir la valeur "d'analyse la plus éloignée". Il utilise également beaucoup le currying et le mappage sur les listes (++ turn), aussi alias les noms de fonctions avec des variables d'une lettre.

Hoon est le langage de programmation d'Urbit, un projet de réimplémentation de table rase. Il est purement fonctionnel, typé statiquement, vaguement semblable à un lisp et compile pour Nock. Nock est une machine virtuelle basée sur un combinateur qui s'exécute sur un modèle de mémoire bignum d'arbre binaire.

Lorsque vous démarrez Urbit, vous êtes dans: Dojo, le shell et Hoon repl. Pour exécuter l'extrait, tapez simplement:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

puis collez la fonction autonome sur la ligne suivante.

Gelée , 27 octets

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

Essayez-le en ligne! Notez que les barres obliques inverses doivent être échappées dans la chaîne d'entrée pour l'avant dernier cas de test.

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 octets

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. Nettoyer
2. Réduire
3. reformer dans une matrice 3xn m avec UC = 1, lc = 0
4. (4 2 1) * m + 1 résultats dans un index
5. Indexer les bons caractères

Perl, 76 73 72 + 1 = 73 octets

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

Nécessite le -ndrapeau:

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

Utiliser le truc avec la conversion en base 2 .

Comment ça fonctionne:

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

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

Il s'agit d'une fonction anonyme qui accepte une chaîne et retourne une chaîne. Pour l'appeler, assignez-le à une variable.

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 octets

Une utilisation importante d’ string.gsub()ici, une fois de plus aurait pu me permettre de créer un pointeur à un caractère sur cette fonction pour obtenir des octets. C'est aussi mon premier programme lua sans espace! :RÉ

Ce programme prend son entrée via un argument de ligne de commande et génère un programme BrainFuck, une commande par ligne.

Edit: 1 octet enregistré grâce à @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 et explications

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 octets

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

Je vais essayer de jouer au golf plus.

Mathematica, 192 octets

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

Fonction anonyme qui prend la chaîne souhaitée en argument. Étapes de l'algorithme (assez simple):

1. Nettoyer la ficelle
2. Remplacer UC -> "1", lc -> "0"
3. Transforme la chaîne en liste binaire
4. Séparer la liste en trois et interpréter chaque bloc comme un nombre base-2
5. Remplacez les nombres par leurs symboles appropriés et rejoignez une chaîne.

Ruby 117 114 113 111 86 79 octets

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

• tr(?^+m='a-zA-Z','')met m à 'a-zA-Z'et supprime les non-lettres
• .tr(m,?0*26+?1) convertit les minuscules en 0, les majuscules en 1
• .scan(/.../) divise la chaîne en groupes de 3 et élimine le dernier groupe s'il en a moins de 3
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} convertir chaque nombre binaire en un caractère

Perl 6, 81 octets

Cela peut probablement être mieux fait, mais c'est mon tour

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

Usage

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

Programme complet, joué au golf (lecture de l'entrée standard):

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

Un peu non-golfé:

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

Notez que @A... Z[en ASCII, et même pour `a... z}.

Japt v2.0a0 -P, 27 octets

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

3 octets sauvés grâce à @Shaggy

L'essayer

Pyke, 31 octets, non compétitif

Pyke est plus vieux que le défi, mais j’ai ajouté quelques fonctionnalités pour le rendre plus compétitif - fonction de bloc. J'ai utilisé le même truc que @Martin Büttner .

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

Essayez-le ici!

JavaScript, 148 octets

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 octets

Quoi, pas de réponses TI-BASIC? Il est temps que je répare ça!

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

L'entrée est le code oOo dans Ans.
La sortie est le code BF traduit .

Exemples:

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

Un-golfed:
(Newlines et commentaires ajoutés)

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"

Remarques:

• TI-BASIC est un langage à jeton. Le nombre de caractères ne correspond pas au nombre d'octets.