Учитывая ввод программы, написанной в oOo CODE , выведите код BF, который он представляет.

Вот краткое описание того, как работает oOo CODE:

• Сначала удаляются все не алфавитные символы (все, что не в диапазоне A-Za-z).

  Например, возьмите программу PROgRam reVERsES giVeN iNPut sEqUENcE(пример, приведенный на вики-странице esolangs, который делает именно то, что вы ожидаете). После этого первого шага мы теперь имеем 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  ,
  

  То есть, если первая буква группы в нижнем регистре, вторая в верхнем регистре, а третья в нижнем регистре, она будет преобразована в команду [.

  В нашем примере это, наконец, программа BF ,[>,]<[.<]+, которая действительно меняет свой ввод.

Поскольку это код-гольф , победит самый короткий код в байтах.

Тестовые случаи:

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

ооо, 1569 1515 байт

Должно быть сделано. Попробуй это здесь .

Golfed:

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 байта

Сохранено 1 байт благодаря @ dev-null

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теперь это три символа, это двоичное число между 000и 111. Мы можем преобразовать это в десятичное число, добавив "0b"в начало, а затем заставив движок проанализировать его как число с '0b'+a-0.

Тем не менее, нам все еще нужно сбросить aпустую строку. Мы не можем просто сделать, '0b'+(a="")-0потому что это будет означать, что проанализированная строка является просто 0b. К счастью, когда анализируется как число, пустая строка становится равным 0, так что мы можем заменить 0с (a="").

Теперь у нас есть наш номер, и мы можем только добавить символ в этой позиции индекса в "><[]-+.,"к b. После замены мы используем ее &&bдля возврата из функции. (Ну, если результат .replaceне пустой, что происходит только при пустом вводе и в любом случае возвращает пустую строку.)

05AB1E , 35 32 байта

Код:

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

Используя очень умный трюк от Мартина Бюттнера, из этого ответа . Объяснение:

á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 .

Retina , 79 75 71 70 байт

Спасибо randomra за сохранение 1 байта.

i`[^a-z]

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

Попробуйте онлайн!

объяснение

i`[^a-z]

Мы начинаем с удаления всего, что не является буквой.

M!`...

Это разбивает строку на куски из трех символов, возвращая все (не перекрывающиеся) трехсимвольные совпадения. Это автоматически отбрасывает любой неполный трейлинг-чанк.

m`^
;

Добавить ;к каждой строке. Мы будем использовать это как маркер для преобразования base-2. Говоря об этом, мы будем просто обрабатывать заглавные буквы как 1и строчные как 0.

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

Это делает забавное преобразование базы-2 в одинарное. На каждом шаге мы просто удваиваем символы слева от ;и перемещаем ;один вправо. Почему это работает? Помните, что мы будем интерпретировать нижний регистр как 0и верхний регистр как 1. Всякий раз, когда мы обрабатываем букву, мы просто удваиваем промежуточную сумму (слева) до сих пор - двойные строчные буквы являются справедливыми 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), true, если T не буква
                        m # результат фильтра карты с d
                         ? rId0 # if d == toLower (d)
                              Z1 # 0 для строчных букв, 1 для прописных
                       c 3 # Разбить на части по 3, при необходимости последний элемент короче
                 фильтр F # с T
                  ! # не логично
                   % lT3 # len (t) mod 3 -> сохранить только элементы длины 3
  m # карта с d
              id2 # Преобразовать из двоичного в десятичное
   @ "> <[] - +.," # Получить полученную команду BF
jk # Присоединиться к строке

Джольф, 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 '><[]-+.,')))))

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. используйте ++ murn, чтобы избавиться от всех символов на входе, которые не могут быть проанализированы с помощью "alf" (алфавит)
2. анализировать список с помощью комбинатора, который выводит каждые 3 символа за раз в список, заменяя строчные буквы на «0» и прописные на «1»
3. Приведите результат к (unit (list tape)) и принудительно разверните его, чтобы получить самый анализируемый результат, чтобы работать только с несколькими тройками без сбоев
4. Карта по списку, разбирая каждую группу, как если бы она была двоичной
5. Используйте каждое число в списке в качестве индекса в тексте «> <[] - +.,» И приведите список обратно на ленту.

У Hoon нет правильных регулярных выражений, только библиотека комбинатора синтаксического анализатора, поэтому, к сожалению, он довольно многословен. Сканирование ++ также дает сбой, если весь входной поток не анализируется, поэтому я должен использовать ++ rose, принудительно преобразовать его в единицу и развернуть для получения значения «самый дальний анализ». Кроме того, он интенсивно используется для каррирования и отображения списков (поворот ++), поэтому я присваиваю псевдонимы функций переменным из одной буквы.

Hoon - это язык программирования для Urbit, проекта переопределения с чистого листа. Он чисто функциональный, статически типизированный, похожий на шепот и компилируется в Nock. Nock - это основанная на комбинаторе виртуальная машина, которая работает поверх модели памяти двоичного дерева bignum.

Когда вы загружаете Urbit, вы попадаете в: dojo, shell и Hoon repl. Чтобы запустить фрагмент, просто наберите:

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

Используя трюк с преобразованием базы-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))])]

Это анонимная функция, которая принимает строку и возвращает строку. Чтобы вызвать его, присвойте его переменной.

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

Луа, 120 байт

Большое использование string.gsub()здесь, еще один раз мог бы позволить мне создать односимвольный указатель на эту функцию, чтобы получить несколько байтов. Кроме того, это моя первая программа lua без пробелов! : D

Эта программа получает свой ввод через аргумент командной строки и выводит программу BrainFuck, по одной команде на строку.

Редактировать: 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. Разделите список на три части и интерпретируйте каждый кусок как число base-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")
,[>,]<[.<]+

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 байт

Полная программа, игра в гольф (читает со стандартного ввода):

#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 -P, 27 байт

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

Сохранено 3 байта благодаря @Shaggy

Попробуй

Пайк, 31 байт, неконкурентоспособен

Пайк старше, чем задача, но я добавил некоторые функции, чтобы сделать его более конкурентоспособным - функция чанка. Я использовал тот же трюк, что и @Martin Bü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 - это токенизированный язык. Количество символов не равно количеству байтов.