Geben Sie bei einer Eingabe eines in oOo CODE geschriebenen Programms den BF-Code aus, den es darstellt.

Hier ist eine kurze Beschreibung der Funktionsweise von oOo CODE:

• Zunächst werden alle nicht alphabetischen Zeichen entfernt (alles, was nicht im Bereich liegt A-Za-z).

  Nehmen Sie zum Beispiel das Programm PROgRam reVERsES giVeN iNPut sEqUENcE(ein Beispiel auf der Wiki-Seite von esolangs, das genau das tut, was Sie erwarten). Nach diesem ersten Schritt haben wir jetzt PROgRamreVERsESgiVeNiNPutsEqUENcE.

• Teilen Sie als nächstes alle verbleibenden Zeichen in Gruppen von 3 auf. Wir haben jetzt PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE. Wenn es eine nachgestellte Gruppe von 1 oder 2 Zeichen gibt, verwerfen Sie sie.

• Konvertieren Sie jede Gruppe von 3 Buchstaben in einen BF-Befehl basierend auf der folgenden Tabelle:

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

  Das heißt, wenn der erste Buchstabe einer Gruppe in Kleinbuchstaben geschrieben ist, der zweite in Großbuchstaben und der dritte in Kleinbuchstaben, wird dies in den Befehl übersetzt [.

  In unserem Beispiel wird dies schließlich zum BF-Programm ,[>,]<[.<]+, das seine Eingabe in der Tat umkehrt.

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

Testfälle:

<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

Musste getan werden. Probieren Sie es hier aus .

Golf gespielt:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

Übersetzt nach Brainfuck (mit Zeilenumbrüchen zur Verdeutlichung):

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

Ungolfed mit Erklärung:

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

Danke für die interessante Herausforderung!

CJam, 36 35 Bytes

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

Teste es hier.

Erläuterung

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

1 Byte dank @ dev-null gespeichert

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

Ich habe viele Varianten davon ausprobiert, aber dies scheint die kürzeste zu sein. Funktioniert auch bei leerer Eingabe!

Wie es funktioniert

Zunächst x.replace(/[a-z]/gi,c=>finden wir mit jeden Buchstaben cin der Eingabe. Wir setzen aund bzu ""am anderen Ende der Funktionsaufruf, da die Funktion alle Parameter über die zweite ignoriert. aspeichert eine Binärzeichenfolge, um zu bestimmen, welches Zeichen gerade erstellt wird, und bspeichert das Ergebnis.

Nun zum verwirrenden Teil: Zuerst (a+=+(c<'a'))hängen wir mit 0an aif cGroßbuchstaben an; 1Andernfalls. Dieser Ausdruck gibt den neuen Wert a, so ist, dann können wir überprüfen , ob es mit drei Zeichen Länge erreicht hat , durch Prüfen , ob das Zeichen an dem Index 2 vorhanden ist : [2]?. Wenn nicht, beenden wir die Funktion einfach mit :0.

Wenn aes jetzt drei Zeichen lang ist, ist es eine Binärzahl zwischen 000und 111. Wir können dies in eine Dezimalzahl umwandeln, indem wir sie "0b"an den Anfang anhängen und dann die Engine zwingen, sie als Zahl mit zu analysieren '0b'+a-0.

Wir müssen jedoch noch aauf die leere Zeichenfolge zurücksetzen . Dies können wir nicht einfach tun, '0b'+(a="")-0da dies bedeuten würde, dass die analysierte Zeichenfolge gerecht ist 0b. Zum Glück, wenn sie als Nummer analysiert, wird die leere Zeichenkette 0, so dass wir das ersetzen können 0mit (a="").

Jetzt haben wir unsere Nummer, und wir können nur das Zeichen an diesem Index in anhängen "><[]-+.,"zu b. Nachdem das Ersetzen abgeschlossen ist, verwenden wir &&b, um es von der Funktion zurückzugeben. (Nun, es sei denn, das Ergebnis von .replaceist leer, was nur bei leerer Eingabe geschieht und die leere Zeichenfolge trotzdem zurückgibt.)

05AB1E , 35 32 Bytes

Code:

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

Mit einem sehr cleveren Trick von Martin Büttner, aus dieser Antwort . Erläuterung:

á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

Probieren Sie es online!

Verwendet CP-1252- Codierung.

Retina , 79 75 71 70 Bytes

Danke an randomra für das Speichern von 1 Byte.

i`[^a-z]

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

Probieren Sie es online!

Erläuterung

i`[^a-z]

Zunächst entfernen wir alles, was kein Buchstabe ist.

M!`...

Dadurch wird die Zeichenfolge in Blöcke mit drei Zeichen aufgeteilt, indem alle (nicht überlappenden) Übereinstimmungen mit drei Zeichen zurückgegeben werden. Dadurch werden unvollständige nachgestellte Blöcke automatisch verworfen.

m`^
;

Stellen Sie ;jeder Zeile ein voran . Wir werden dies als Marker für die Base-2-Konvertierung verwenden. Apropos, wir behandeln Großbuchstaben einfach als 1und Kleinbuchstaben als 0.

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

Dies führt eine lustige Basis-2-Konvertierung zur unären durch. Bei jedem Schritt verdoppeln wir einfach die Zeichen links von ;und verschieben das Zeichen ;nach rechts. Warum funktioniert das? Denken Sie daran, wir interpretieren Kleinbuchstaben als 0und Großbuchstaben als 1. Wann immer wir einen Buchstaben verarbeiten, verdoppeln wir einfach die laufende Summe (links) bis jetzt - doppelte Kleinbuchstaben sind gerecht 2*0=0, so dass sie vollständig ignoriert werden können und Großbuchstaben die Binärzahl bis jetzt darstellen, so dass sie verdoppelt werden Was wir wollen. Dann addieren wir den aktuellen Buchstaben zu der laufenden Summe, die für 0oder 1entsprechend steht.

T`l

Entfernen Sie alle Kleinbuchstaben / Nullen.

.+
$.&

Passen Sie jede Zeile an und ersetzen Sie sie durch die (dezimale) Anzahl der Zeichen in dieser Zeile. Aufgrund ;dessen wird die unäre Zahl zu ihrem Dezimaläquivalent + 1.

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

Transliteration, die 1-8 durch den entsprechenden Befehl ersetzt.

¶

Zeilenumbrüche entfernen.

MATL , 38 32 Bytes

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

Probieren Sie es 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 Bytes

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

Online testen!

Wie es funktioniert

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 bis 95 Byte

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

Entfernt einfach Nichtbuchstaben, wandelt Großbuchstaben in Einsen und Kleinbuchstaben in Nullen um, teilt sie in Dreiergruppen auf, ignoriert eine nachfolgende Gruppe von 1 oder 2 und decodiert die Gruppen.

Bearbeiten: 16 Bytes dank @ dev-null gespeichert, obwohl der Code nicht mehr funktioniert, wenn die leere Zeichenfolge übergeben wird.

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 ... sieht ein bisschen lang aus, besonders die zweite Zeile. b=[b,2*b+(c<'a')][c.isalpha()]ist allerdings etwas schlimmer.

Pyth, 40 Bytes

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

Probieren Sie es hier aus!

Könnte 2 Bytes sparen, wenn ich das Ergebnis als Liste von Zeichen anstelle einer Zeichenfolge ausgeben kann.

Erläuterung

Filtert alle Nichtbuchstaben heraus, konvertiert Großbuchstaben in 1 und Kleinbuchstaben in 0, teilt sie in 3er-Blöcke auf, interpretiert jeden Block als Binärzahl und verwendet diesen als Index in einen String, der alle BF-Befehle enthält.

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

                                fz # Filtereingang mit T
                                 ! # logisch nicht
                                  rIT2 # T == Swapcase (T), true, wenn T kein Buchstabe ist
                        m # Kartenfilter Ergebnis mit d
                         ? rId0 # wenn d == toLower (d)
                              Z1 # 0 für Kleinbuchstaben, 1 für Großbuchstaben
                       c 3 # In Stücke zu 3 teilen, letztes Element ist bei Bedarf kürzer
                 f # Filter mit T
                  ! # logisch nicht
                   % lT3 # len (t) mod 3 -> behalte nur Elemente der Länge 3
  m # karte mit d
              id2 # Konvertiert von binär zu dezimal
   @ "> <[] - +." # Liefert den resultierenden BF-Befehl
jk # Verbinde zu einer Zeichenkette

Jolf, 31 34 Bytes

Probieren Sie es hier aus! Ersetzen Sie ►mit \x10und ♣mit \x05. Da ich die Chop-Funktion falsch implementiert habe, gewinne ich 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. benutze ++ murn, um alle Zeichen in der Eingabe zu entfernen, die nicht mit "alf" (alphabet) geparst werden können
2. Analysieren Sie die Liste mit einem Kombinator, der jeweils 3 Zeichen gleichzeitig in einer Liste ausgibt. Ersetzen Sie dabei den Kleinbuchstaben durch "0" und den Großbuchstaben durch "1".
3. Konvertieren Sie das Ergebnis in (Einheit (Listenband)) und packen Sie es gewaltsam aus, um das am weitesten analysierte Ergebnis zu erhalten und mit nur einem Vielfachen von Dreien ohne Absturz zu arbeiten
4. Ordnen Sie die Liste zu, und analysieren Sie jede Gruppe so, als ob sie binär wäre
5. Verwenden Sie jede Nummer in der Liste als Index für den Text '> <[] - +.' Und übertragen Sie die Liste wieder auf ein Band.

Hoon hat keine richtigen regulären Ausdrücke, nur eine Parser-Kombinator-Bibliothek, daher ist es leider ziemlich ausführlich. ++ Scan stürzt auch ab, wenn der gesamte Eingabestream nicht analysiert wird. Daher muss ++ rose verwendet, in eine Einheit umgewandelt und für den Wert "Am weitesten entfernt" entpackt werden. Es macht auch viel Gebrauch für das Currying und Mapping über Listen (++ wiederum), so dass ich die Funktionsnamen zu Ein-Buchstaben-Variablen alias.

Hoon ist die Programmiersprache für Urbit, ein Projekt zur Neuimplementierung von Clean Slate. Es ist rein funktional, statisch typisiert, vage lispelhaft und kompiliert nach Nock. Nock ist eine kombinatorbasierte VM, die auf einem Bignum-Speichermodell mit binären Bäumen ausgeführt wird.

Wenn Sie Urbit starten, werden Sie in das folgende Verzeichnis versetzt: dojo, the shell and Hoon repl. Um das Snippet auszuführen, geben Sie einfach Folgendes ein:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

Fügen Sie dann die eigenständige Funktion in der nächsten Zeile ein.

Gelee , 27 Bytes

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

Probieren Sie es online! Beachten Sie, dass Backslashes in der Eingabezeichenfolge für den vorletzten Testfall maskiert werden müssen.

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. Reinigen
2. Trimmen
3. Umformen in eine 3xn-Matrix m mit UC = 1, lc = 0
4. (4 2 1) * m + 1 ergibt eine Indexliste
5. Index zu den richtigen Zeichen

Perl, 76 73 72 + 1 = 73 Bytes

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

Benötigt die -nFlagge:

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

Verwenden Sie den Trick mit Base-2-Konvertierung .

Wie es funktioniert:

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

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

Wenn string.gsub()ich das hier ausführlich nutze , hätte ich ein weiteres Mal einen Ein-Zeichen-Zeiger für diese Funktion erstellen können, um ein paar Bytes zu erhalten. Außerdem ist es mein erstes Lua-Programm ohne Leerzeichen! : D

Dieses Programm nimmt seine Eingabe über ein Befehlszeilenargument entgegen und gibt ein BrainFuck-Programm aus, einen Befehl pro Zeile.

Edit: 1 Byte gespeichert dank @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 und Erklärungen

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

Werde versuchen mehr Golf zu spielen.

Mathematica, 192 Bytes

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

Anonyme Funktion, die die gewünschte Zeichenfolge als Argument verwendet. Schritte im (ziemlich einfachen) Algorithmus:

1. Reinigen Sie die Saite
2. Ersetzen Sie UC -> "1", lc -> "0"
3. Verwandle den String in eine binäre Liste
4. Teilen Sie die Liste in drei Teile und interpretieren Sie jeden Teil als Zahl zur Basis 2
5. Ersetzen Sie die Zahlen durch die entsprechenden Symbole und fügen Sie sie zu einer Zeichenfolge zusammen.

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','')Setzt m auf 'a-zA-Z'und entfernt Nichtbuchstaben
• .tr(m,?0*26+?1) wandelt Kleinbuchstaben in 0, Großbuchstaben in 1 um
• .scan(/.../) Teilstring in Dreiergruppen aufteilen und letzte Gruppe verwerfen, wenn sie weniger als 3 hat
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} Wandle jede Binärzahl in ein Zeichen um

Perl 6, 81 Bytes

Dies kann wahrscheinlich besser gemacht werden, aber das ist mein Versuch

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

Verwendungszweck

> 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

Volles Programm, Golf (liest von der Standardeingabe):

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

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

Beachten Sie, dass @A... Z[in ASCII, und ebenfalls für `a... z}.

Japt v2.0a0 -P, 27 Bytes

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

3 Bytes gespart dank @Shaggy

Versuch es

Pyke, 31 Bytes, nicht wettbewerbsfähig

Pyke ist älter als die Herausforderung, aber ich habe einige Funktionen hinzugefügt, um die Wettbewerbsfähigkeit zu verbessern - die Chunk-Funktion. Ich habe den gleichen Trick benutzt wie @Martin Büttner .

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

Probieren Sie es hier aus!

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

Was, keine TI-BASIC Antworten? Zeit für mich, das zu beheben!

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

Eingabe ist der oOo- Code in Ans.
Ausgabe ist der übersetzte BF- Code.

Beispiele:

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

Ungolfen:
(Zeilenumbrüche und Kommentare hinzugefügt)

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"

Anmerkungen:

• TI-BASIC ist eine Token-Sprache. Die Anzahl der Zeichen entspricht nicht der Anzahl der Bytes.