给定以oOo CODE编写的程序的输入，输出它表示的BF代码。

这是oOo CODE的工作方式的简短描述：

• 首先，所有非字母字符都将被删除（所有不在此范围内的字符 A-Za-z）。

  例如，使用该程序PROgRam reVERsES giVeN iNPut sEqUENcE（esolangs Wiki页面上给出的示例完全可以实现您的期望）。第一步之后，我们现在有了 PROgRamreVERsESgiVeNiNPutsEqUENcE。

• 接下来，将所有剩余字符分成3组。现在有了 PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE。如果尾部有1个或2个字符，则将其丢弃。

• 根据下表将每组3个字母转换为BF命令：

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

  也就是说，如果组中的第一个字母是小写字母，第二个字母是大写字母，第三个字母是小写字母，它将转换为command [。

  在我们的示例中，该程序最终成为BF程序,[>,]<[.<]+，该程序的确撤消了其输入。

因为这是code-golf，所以以字节为单位的最短代码将获胜。

测试用例：

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

oOo，1569年 1515字节

必须要做的。在这里尝试。

打高尔夫球：

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

译为Brainfuck（为清晰起见，使用换行符）：

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

不带解释：

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

感谢您的有趣挑战！

CJam，36 35字节

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

在这里测试。

说明

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字节

@ dev-null节省了1个字节

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

我已经尝试过许多变体，但这似乎是最短的。也适用于空输入！

这个怎么运作

首先，使用x.replace(/[a-z]/gi,c=>，我们找到c输入中的每个字母。我们建立a并b给""在函数调用的另一端，由于函数忽略过去的第二任何参数。a将存储一个二进制字符串来确定我们当前正在使用哪个字符，b并将存储结果。

现在的混淆部分：第一，与(a+=+(c<'a'))我们追加0到a，如果c是大写的; 1除此以外。该表达式返回的新值a，因此我们可以通过检查索引2处的字符是否存在来检查它是否达到了三个字符的长度[2]?。如果没有，我们只需以结束函数:0。

如果a现在的长度为3个字符，则它是000和之间的一个二进制数111。我们可以通过将其添加"0b"到开头将其转换为十进制数字，然后强制引擎将其解析为数字'0b'+a-0。

但是，我们仍然需要重置a为空字符串。我们不能只是这样做，'0b'+(a="")-0因为那意味着被解析的字符串是just 0b。幸运的是，当为数字解析，空字符串为0，所以我们可以代替0用(a="")。

现在我们有了编号，我们可以将字符附加到的索引"><[]-+.,"处b。替换完成后，我们用于&&b从函数返回它。（好吧，除非结果.replace为空，否则仅在空输入上发生，并且无论如何都会返回空字符串。）

05AB1E，35 32字节

码：

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

根据这个答案，使用马丁·布特纳（MartinBüttner）的一个非常巧妙的技巧。说明：

á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

在线尝试！

使用CP-1252编码。

视网膜，79 75 71 70字节

感谢randomra节省了1个字节。

i`[^a-z]

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

在线尝试！

说明

i`[^a-z]

我们首先删除所有不是字母的东西。

M!`...

通过返回所有（不重叠）3个字符的匹配，将字符串分成三个字符的块。这将自动丢弃任何不完整的尾随块。

m`^
;

;在每行前面加上a 。我们将其用作基础2转换的标记。说到这，我们将简单地将大写字母视为1和将小写字母视为0。

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

这将以2为基数进行一元转换。在每一步中，我们只需将字符的左侧加倍，;然后将;其向右移动。为什么这样做？请记住，我们将小写解释为0，大写解释为1。每当我们处理一个字母时，我们只需将到目前为止的运行总数加倍（在左侧）-将小写字母juste加倍2*0=0，这样就可以完全忽略它们，并且大写字母代表到目前为止的二进制数，因此将它们加倍是我们想要的。然后，我们将当前字母添加到代表0或1相应的运行总计中。

T`l

删除所有小写字母/零。

.+
$.&

匹配每一行，并用该行中的（十进制）个字符替换。由于;这将一元数转换为其十进制等效值+ 1。

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

音译，将1-8替换为相应的命令。

¶

删除换行符。

MATL，38 32字节

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

在线尝试！

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

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

在线测试！

这个怎么运作

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字节

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

只需删除非字母，将大写字母转换为1，小写字母转换为0，分成三个一组，忽略尾随的1或2，然后对这些组进行解码。

编辑：由于@ dev-null，节省了16个字节，尽管传递空字符串时代码不再起作用。

Python 3，91个字节

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

嗯...看起来有点长，尤其是第二行。b=[b,2*b+(c<'a')][c.isalpha()]虽然稍微差一点。

Pyth，40个字节

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

在这里尝试！

如果我可以将结果输出为字符列表而不是字符串，则可以节省2个字节。

说明

过滤掉所有非字母，将大写字母转换为1，将小写字母转换为0，分割为3的块，将每个块解释为二进制数，并将其用作包含所有BF命令的字符串的索引。

jkm @“> <[]-+。，” id2f！％lT3cm？rId0Z1f！rIT2z3＃z =输入

                                fz＃使用T过滤输入
                                 ！＃逻辑不
                                  rIT2＃T == swapcase（T），如果T不是字母，则为true
                        m＃带有d的地图过滤器结果
                         rId0＃如果d == toLower（d）
                              Z1＃0小写字母，1大写字母
                       c 3＃分成3个区块，必要时最后一个元素较短
                 带T的f＃过滤器
                  ！＃逻辑不
                   ％lT3＃len（t）mod 3->仅保留长度为3的元素
  m＃与d对应的地图
              id2＃从二进制转换为十进制
   @“> <[]-+。，”＃获取生成的BF命令
jk＃连接到字符串

Jolf，31 34个字节

在这里尝试！更换►用\x10和♣用\x05。因为我错误地实现了chop函数，所以我获得了3个字节。:(

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

胡恩，212字节

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

取消高尔夫：

|=  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. 使用++ murn摆脱输入中所有无法用“ alf”（字母）解析的字符
2. 用组合器解析列表，该组合器一次将每个3个字符输出到列表，用小写字母“ 0”替换大写字母“ 1”
3. 将结果转换为（单元（清单磁带）），并强行解开包装，以获取最远的解析结果，以便仅使用三分之二而不会崩溃
4. 映射列表，将每个组解析为二进制
5. 使用列表中的每个数字作为文本'> <[]-+。'的索引，然后将列表投射回磁带。

Hoon没有适当的正则表达式，只有解析器组合器库，因此很冗长。如果未解析整个输入流，++ scan也将​​崩溃，因此我必须使用++ rose，将其强制转换为一个单元，并将其解包为“最远的解析”值。它也大量用于列表的映射和映射（++ turn），因此我将函数名称别名为一个字母变量。

Hoon是Urbit（一种全新的重新实现项目）的编程语言。它是纯函数式的，静态类型的，隐约似Lisp的，并且可以编译为Nock。Nock是在二叉树bignum内存模型之上运行的基于组合器的VM。

引导Urbit时，您将进入：dojo，shell和Hoon副本。要运行该片段，只需键入：

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

然后将独立功能粘贴到下一行。

果冻，27 个字节

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

在线尝试！请注意，对于倒数第二个测试用例，反斜杠需要在输入字符串中转义。

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个字节

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. 清洁
2. 修剪
3. 重塑为3xn矩阵m，UC = 1，lc = 0
4. （4 2 1）* m + 1生成索引列表
5. 正确的字符索引

Perl，76 73 72 +1 = 73字节

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

需要-n标志：

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

将 技巧用于base-2转换。

这个怎么运作：

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

朱莉娅107字节

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

这是一个匿名函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量。

取消高尔夫：

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字节

在string.gsub()这里大量使用时，可能再有一次我可以在此函数上创建一个字符指针来获取一些字节。另外，这是我的第一个lua程序，没有空格！：D

该程序通过命令行参数获取输入，并输出BrainFuck程序，每行一个命令。

编辑：由于@Oleg V. Volkov而节省了1个字节

arg[1]:gsub("[%A]",""):gsub("%l",0):gsub("%u",1):gsub("...",function(c)x=1+tonumber(c,2)print(("><[]-+.,"):sub(x,x))end)

高尔夫球和解释

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字节

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

将尝试更多地打高尔夫球。

Mathematica，192个字节

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

使用所需字符串作为参数的匿名函数。（非常简单）算法的步骤：

1. 清洁琴弦
2. 替换UC->“ 1”，lc->“ 0”
3. 将字符串转换为二进制列表
4. 将列表分为三部分，并将每个块解释为以2为底的数字
5. 用适当的符号替换数字，然后重新组合成字符串。

红宝石117 114 113 111 86 79个字节

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

• tr(?^+m='a-zA-Z','')将m设置为'a-zA-Z'并删除非字母
• .tr(m,?0*26+?1) 将小写转换为0，大写转换为1
• .scan(/.../) 将块字符串分成3组，如果最后一组少于3，则将其丢弃
• {$><<"><[]-+.,"[$&.t‌​o_i 2]} 将每个二进制数字转换为一个字符

Perl 6，81位元组

这可能可以做得更好，但这是我的努力

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

用法

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

不打高尔夫球

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 ++，173167字节

完整程序，打高尔夫球（从标准输入中读取）：

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

有点不符合要求：

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

请注意，@A... Z[以ASCII表示，同样以`a...表示z}。

Japt v2.0a0，27 -P个字节

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

@Shaggy节省了3个字节

试试吧

Pyke，31个字节，非竞争性

Pyke比挑战要古老，但我添加了一些功能以使其更具竞争力-块函数。我使用了与@MartinBüttner相同的技巧。

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

在这里尝试！

JavaScript，148个字节

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字节

什么，没有TI-BASIC的答案？是时候让我解决了！

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

输入是中的oOo代码Ans。
输出是翻译后的BF代码。

例子：

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

取消高尔夫：（
添加了换行符和注释）

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"

笔记：

• TI-BASIC是一种标记化语言。字符数不不等于字节数。