RLE Brainfuck

(относится к BF-RLE )

Гипотетический диалект RLE ( Run-Length Encoding ) Brainfuck принимает символы для 8 команд, а также принимает цифры. Цифры используются для представления количества последовательных повторений команды, что позволяет кодировать длину строки исходного кода.

8>равно >>>>>>>>.

Длина всегда в левой части команды.

Ваша задача - написать самую короткую программу / функцию, которая переводит входную строку (фрагмент RLE Brainfuck) в обычную программу Brainfuck.

Например:

Входные данные:

10+[>+>3+>7+>10+4<-]3>2+.>+.7+2.3+.2<2+.>15+.>.3+.6-.8-.2<+.<.

Ouptut:

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

Победит самый короткий код в количестве байтов на каждом языке.

Python 2 , 62 61 байт

lambda s:eval(re.sub('(\d*)(.)',r'+1*\1*1*"\2"',s))
import re

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

Подстановка регулярного выражения раскрывается 3<2+-в строку:

+1*3*1*"<"+1*2*1*"+"+1**1*"-"

который затем evalред. (Обратите внимание, что когда \1пусто, мы получаем 1**1 = 1.) Первый +- это унарный оператор, который привязывается к первому числу, а другие +- конкатенация строк. Это бьет более очевидным

lambda s:re.sub('(\d+)(.)',lambda m:int(m.group(1))*m.group(2),s)
import re

на 14 байтов. Обычно "\2"не будет всегда работать, но , к счастью , \и "не Brainfuck команды.

xnor сохранил байт, предоставив 1*\1*1трюк. Ранее я имел \1Lв регулярном выражении, и определил L=1как лямбда-аргумент, который также довольно круто: 3Lэто длинный int литерал и Lявляется переменной.

Pyth , 2 байта

r9

Попробуй это здесь!

Как это устроено

r9 - Полная программа получения строки из STDIN.

r - набор расширенных строковых операций Пита.
 9 - Девятая команда этого набора (декодирование по длине прогона). Это поддерживает многозначные номера.

Луа, 65 64 63 байта

Большой ! На этот раз Луа побеждает Питона!

Редактировать: Сохранение одного байта благодаря @Jarhmander, спасибо ему за полезный трюк для форсирования одного результата

print(((...):gsub("(%d+)(.)",function(a,b)return b:rep(a)end)))

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

Пояснения

print)((...):gsub(             -- iterate over the argument and replace the strings
            "(%d+)(.)",       -- matching this pattern (at least one digit and a non-digit)
            function(a,b)     -- capture the digit and non-digit parts in separate variables
              return b:rep(a) -- repeat the non-digit a times, a being the digit part
            end)))                    

Scala , 73 69 байт

"(\\d+)(.)".r.replaceSomeIn(_:String,m=>Some("$2"*m.group(1).toInt))

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

Perl 5 , 18 байт

Код 17 байтов + 1 для -p.

s/\d+(.)/$1x$&/ge

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

vim, 29 25 23 22 16 байт

:s/\D/a&<C-v><ESC>/g
D@"

<C-V>0x16, <ESC>0x1b.

Он работает путем замены каждого нецифрового числа командой, которая добавляет этот символ в буфер. Подсчет оставлен в покое и изменяет эти команды. На данный момент буфер представляет собой программу vimscript, которая создает желаемую программу Brainfuck, поэтому мы помещаем ее в регистр и запускаем.

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

Изменить: Уменьшение размера благодаря предложениям: H.PWiz: 5, TheFamilyFroot: 5, DJMcMayhem: 1

RLE Brainfuck, 204 байта

-3>,[[->+>+<<]>>47-3<10+<->[-<+4>->+<[>-]>[3<+<[-]4>->]5<]3>57+[-]+<<[>>-<<[3>+3<-]]3>[3<+3>-]<[>>+7<+[->11-<+[-<+]->>+[-<[->10+<]>>+]<[-4>.4<]4>[-]-3<-<+7>-7<[8>+8<-]]8>[8<+8>-]<[3<.3<[-]-6>-]7<--5>-]<,]

Насколько я понимаю, технические характеристики среды для мозгового удара не очень четко определены. Эта программа предполагает, что ячейки в ленте допускают произвольно большие положительные и отрицательные целые числа без переполнения. Этот код также будет транскрибировать некомандные комментарии, но расширит кодировку комментариев по длине прогона (например, «см. 3b» → «см. Bbb»). Полученная программа должна работать так же, так что я не слишком обеспокоен.

Я почти уверен, что смогу сыграть несколько байтов, но я устал от работы с ним.

Вот пользовательский интерпретатор + тесты, которые я использовал для его тестирования. Если вы передадите ему ввод в поле «Стандартный ввод», он должен работать с этим вводом вместо выполнения тестов.

Мой грязный негольфовый рабочий стол:

->>>,
[
  [->+>+<<]>>  clone 2 into 3 and 4
  if read char is between zero and nine
  (num buffer | max | is_digit | original char | read | temp0 | temp1)
                                                   ^
  47-
  <<<10+  set max
  <->  handle gross 0 case
  [  while max
    -  max minus one
    <+  buffer plus one
    >>>>-  read minus one
    IF STATEMENT : if read is 0
    >+<
    [>-]>[<
      <<+  is_digit = 1
      <[-]>>>  max = 0
    >->]<<  back to read
    <<<     back to max
  ]

  >>>57+[-]  reset `read` (need to add first to avoid infinite negative)

  +<<  check is_digit flag
  ( end marker | 0 | is_digit | original char | temp0 | temp1 | temp2 | temp3)
  x[  IF READ WAS DIGIT
    CODE 1a
    >>temp0 -<<x
    [>>>temp1 +<<<x-]
  ]
  >>>temp1 [<<<x+>>>temp1 -]
  <temp0 [
    START CODE 2a
    >>temp2 +
    7<y+[  IF THERE IS A NUMBER PREFIX
      -
      START CODE 1b
      >11-  end marker is negativeone
      <   on smallest digit
      +[-<+]->  find largest digit
      >+[  sum digits until we hit the end marker negativeone
        -
        <[->10+<]>  h1 = ten * h0; h0 = 0
        >
        +
      ]  leave the negativeone at zero though
      num | 0 | 0 | 0 | original char
            ^
      <num
      [->>>>.<<<<]  print `original char` `num` times
      >>>>[-]-  set `char` to negativeone
      <<<- last ditch guess
      END CODE 1b
      <y+
      7>temp2 -
      7<y[8>temp3 +8<y-]
    ]
    8>temp3 [8<y+8>temp3 -]
    <temp2 [
      CODE 2b
      <<<.  print original char
      <<<[-]-  set num buffer to new left edge
      >>>>>>temp2 -
    ]
    7<y--

    END CODE 2a
    5>temp0 -
  ]
  <
  ,
]

С накоплением , 24 байта

['(\d+)(.)'[\#~*]3/repl]

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

объяснение

['(\d+)(.)'[\#~*]3/repl]
[                      ]   anonymous function, taking string as argument
 '(\d+)(.)'                for all matches of this regex:
           [    ]3/repl      replace (stack = (whole match, digit, repetend))
            \#~              convert digit to number
               *             repeat the character by that digit

TeX, 124 байта

\newcount\n\def\b{\afterassignment\r\n0}\def\r#1{\ifx;#1\else\p#1\expandafter\b\fi
}\def\p#1{#1\ifnum\n>1\advance\n-1\p#1\fi}

(пишется в две строки, чтобы быть видимым, но код может быть написан в одну строку)

Это определяет макрос, \bкоторый принимает входные данные в форме \b<input>;и печатает выходные данные, необходимые для документа.

Retina , 28 23 байта

спасибо @Leo за -5 байт

\d+
$*
+`1(1\D)
$1$1
1

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

Пион , 66 байт

print(re.sub("\d+.",lambda k:(int(k.group()[:-1])*k.group()[-1]),a

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

Pyon в значительной степени просто Python, но он короче, потому что reавтоматически импортируется при его использовании, иa автоматически устанавливается в качестве аргумента или ввода

-4 байта благодаря мистеру Xcoder

Python 2 , 100 93 89 байт

-7 с благодарностью Mr.Xcoder

n=b=""
for y in input():
 if"/"<y<":":n+=y
 elif""==n:b+=y
 else:b+=y*int(n);n=""
print b

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

Haskell , 60 байт

f(a:b)|[(c,d:e)]<-reads$a:b=(<$)d[1..c]++f e|1<2=a:f b
f a=a

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

R , 121 106 90 байт

function(s,a=strsplit)cat(rep(el(a(gsub("\\d","",s),"")),pmax(el(a(s,"\\D")),"1")),sep="")

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

Сэкономили 15 байтов, поняв, что rep()приведут к числовому. Сохранено еще 16 благодаря Джузеппе, в основном благодаря использованию pmaxдля замены пустых строк на1

function(s) {
  x <- el(strsplit(s,"\\D")) # Split the string on anything that is not a digit...
  x <- pmax(x, "1")          # ... and replace any empty strings with 1. This gets us the numbers of repeats
  y <- gsub("\\d","",s)      # Remove all digits from the original string...
  y <- el(strsplit(y))       # ... and split into individual units. This gets us the symbols to repeat
  z <- rep(y, x)             # Implement the repeats. x is coerced to numeric
  cat(z, sep = "")           # Print without separators
}

PowerShell , 66 62 байта

-join("$args"-split'\b'|%{(,$(,$_[0]*$n+$_))[!!($n=$($_-1))]})

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

Сломать

Какой беспорядок!

Начиная с $args , который является массивом из одного элемента, содержащего строку RLE, я добавляю фактическую строку, заключая ее в кавычки.

Затем разделите его по границе слова ( \bв регулярном выражении). Это даст мне массив строк, где каждый элемент является либо номером, либо токеном (ами) BF, которые идут после числа. Таким образом , в примере, первые 4 элемента этого массива являются сплит 10, +]>+>, 3,+> (все строки).

Затем я передаю это в ForEach-Object( %) для работы с каждым элементом .

Середина - хорошо известный гольфизм PowerShell с изюминкой; по сути это троичный оператор DIY, в котором вы создаете массив из 2 элементов, а затем индексируете его, используя логическое выражение, которое вы хотите проверить, в результате чего ложный результат дает вам элемент 0, а истинный результат дает вам элемент 1.

В этом случае я фактически создаю массив из одного элемента с унарным ,оператором запятой , потому что я не хочу выводить в истинном случае.

Сначала давайте посмотрим на индексатор, хотя он будет выполнен позже.

Идея этого в том, что $_(текущий элемент) может быть допустимым числом или какой-либо другой строкой. Если это число, я хочу $nбыть значением этого числа минус 1 (как число, а не строка). Если это не так, я хочу $nбыть ложным.

PowerShell обычно пытается привести правое значение к типу левой стороны, но это может зависеть от операции. Кроме того, "10"+5даст вам новую строку "105", тогда как 10+"5"даст вам целое число (15 ).

Но строки не могут быть вычтены, поэтому вместо этого PowerShell может автоматически вывести числовое значение со строкой в ​​левой части вычитания, поэтому "10"-5дает5 .

Итак, я начинаю с того $_-1, что $_я получу желаемое число, когда на самом деле это число, но когда это не так, я ничего не получаю. На первый взгляд «ничто» не является ложным, но проблема в том, что он останавливает выполнение этого присваивания, поэтому $nсохраняет свое прежнее значение; не то, что я хочу!

Если я обернуть его в подвыражения, а затем , когда это не удается, я получаю свою ценность falsey: $($_-1).

Все это присваивается, $nи поскольку это присваивание само заключено в круглые скобки, значение, которое было присвоено, $nтакже передается в конвейер.

Поскольку я использую его в индексаторе и хочу, 1чтобы преобразование прошло успешно, я использую два логических notвыражения !!для преобразования этого значения в логическое. Успешное преобразование чисел заканчивается как истина, в то время как ничтожность не дает нам того сладкого, сладкого, 0что позволяет вернуть единственный элемент в этом поддельном троичном массиве.

Возвращаясь к этому массиву, элемент выглядит так: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- это надоедливо долгий способ получить первый символ текущего элемента (скажем, получить +из +[>+), но как строку, а не как [char]объект. Мне нужно, чтобы это была строка, потому что я могу умножить строку на число, чтобы дублировать ее, но я не могу сделать это с символом.

На самом деле мне удалось сохранить 4 символа, используя [char]массив вместо строки (используя другую унарную запятую ,), поэтому я смог удалить кавычки и дополнительное подвыражение. Я могу умножить массив, чтобы дублировать его элементы. И поскольку весь результат этой итерации в любом случае оказывается массивом, и его необходимо-join редактировать, использование массива здесь не требует дополнительных затрат.

Затем я умножаю этот массив строк на $n, чтобы дублировать его $nраз. Напомним, что это $nможет быть $nullили это может быть значение предыдущих цифр минус один.

Затем +$_добавляет текущий элемент в конец дублированного первого символа этого элемента. Вот почему $nминус один.

Таким образом, в 10+[>+итоге получается $nравным 9, затем мы делаем 9 +и добавляем это обратно в +[>+строку, чтобы получить необходимые 10, а также другие отдельные элементы для поездки.

Элемент обернут в подвыражение, $()потому что, когда $nесть $null, все выражение терпит неудачу, таким образом создание массива терпит неудачу, таким образом, индексатор никогда не выполняется, поэтому $nникогда не назначается.

Причина, по которой я использовал этот троичный трюк, заключается в одной из его особенностей: в отличие от реального троичного оператора, выражения, определяющие элементы , оцениваются независимо от того, «выбраны» они или нет, и сначала в этом отношении.

Поскольку мне нужно назначить, а затем использовать $nна отдельных итерациях, это полезно. Значение элемента троичного массива оценивается с использованием значения предыдущей итерации $n, затем индексатор переназначает$n для текущей итерации.

Таким образом, ForEach-Objectциклы в итоге выводят все, что должны (куча ошибок, которые мы игнорируем), но в виде массива новых строк.

Так что все это заключено в круглые скобки, а затем предшествует унарный, -joinчтобы получить строку вывода.

QuadR , 17 байт

\d+.
¯1((⍎↓)⍴↑)⍵M

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

Спасибо Adám за предоставление правильной версии кода.

Как это устроено:

\d+.          ⍝ Regex to match any sequence of digits followed by a character.
¯1((⍎↓)⍴↑)⍵M  ⍝ Transformation line
¯1(      )⍵M  ⍝ Arguments: -1 and the matching expression
   ( ↓)       ⍝ 'Drop' the last item (-1) from the match (⍵M), yielding a string which is a sequence of digits.
    ⍎         ⍝ Execute. In this case, it transforms a string into a number.
        ↑     ⍝ 'Take' the last item (-1) from the match (⍵M), yielding a character.
       ⍴      ⍝ Reshape it. That will take the character resulting from the 'Take' operation and repeat it n times,
              ⍝ where n is the result from the 'Drop' and 'Execute' operations.

Протон , 50 байт

x=>/\d+./.sub(k=>int((e=k.group())[to-1])*e[-1],x)

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

Java 8, 148 байт

s->{for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);!s.matches("\\D+");s=s.replaceAll("0(\\D)","$1$1"));return s.replaceAll("((.)+)\\2","$1");}

^{Проклятые} регулярные выражения Java иногда так бесполезны .. В прошлый раз это былоотсутствие использования группы захвата"$1"для чего-либо, теперь это .. Я хочу заменить3cнаcccили000cнаccc как однострочника, но , к сожалению , Java не имеет возможности делать это без петля. Ах хорошо.

Объяснение:

Попробуй это здесь.

s->{                          // Method with String as both parameter and return-type
  for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);
                              //  Replace every numbers of that many zeroes
                              //  (i.e. "3>2+" -> "000>00+")
      !s.matches("\\D+");     //  Loop as long as the String contains zeroes
    s=s.replaceAll("0(\\D)",  //   Replace every 0 followed by a non-0 character,
                   "$1$1")    //   with two times this captured non-0 character
  );                          //  End of loop
  return s.replaceAll("((.)+)\\2","$1");
                              //  Reduce every repeated character amount by 1,
                              //  and return this as result
}                             // End of method

Haskell , 84 байта

f s@(x:r)|(n:m,x:r)<-span(`elem`['0'..'9'])s=(x<$[1..read$n:m])++f r|1<3=x:f r
f e=e

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

Объяснение:

span(`elem`['0'..'9'])sразбивает данную строку sна префикс цифр и остаток. Соответствие результата в шаблоне (n:m,x:r)гарантирует, что префикс цифры не пуст и привязывает символ после цифр к, xа остаток кr . x<$[1..read$n:m]читает строку цифр n:mкак число и повторяет xэто много раз. Результат объединяется с рекурсивной обработкой оставшейся строки r.

R 151 байт

Outgolfed пользователем 2390246 ! В настоящее время это в основном мусорный подход по сравнению с этим, но я буду продолжать его совершенствовать.

function(s,G=substr)for(i in el(strsplit(gsub("(\\d+.)","!\\1!",s),"!")))cat("if"(is.na(g<-as.double(G(i,1,(n=nchar(i))-1))),i,rep(G(i,n,n),g)),sep='')

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

Также выводит кучу предупреждений.

function(s){
s <- gsub("(\\d+.)","!\\1!",s)               # surround groups with !
X <- el(strsplit(s,"!"))                   # split to groups
for( i in X ){                             # iterate over groups
 n <- nchar(i)                             # length of group
 r <- substr(i,1,n-1)                      # potential number (first n-1 chars)
 d <- substr(i,n,n)                        # last character
 if( is.na(as.double(r)) ){                # if it's not a number
   cat(i)                                  # print out the whole string
  } else {
   cat(rep(d,as.double(r)),sep="")         # repeat d r times, and print with no separator
  }
 }
}

Далее, посмотрим, является ли использование grepболее эффективным, чемsubstr

JavaScript (ES6), 46 байт

a=>a.replace(/(\d+)(.)/g,(_,n,b)=>b.repeat(n))

Довольно простое объяснение:

a=>a.replace(/(\d+)(.)/g,                      // Match globally the following: a number N followed by a character
                         (_,n,b)=>b.repeat(n)) // Replace each occurrence by the matched character repeated N times

Рубин , 35 байт

->s{s.gsub(/(\d+)(.)/){$2*$1.to_i}}

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

Нетипизированное лямбда-исчисление , 452 байта

(λp.λq.(λb.λg.(λi.(λp.λq.λb.p q b)(q(λq.λj.λl.j((λq.λj.qλq.λl.(λu.g i j(λp.u)(g j(λq.λg.q(b(p(λp.λq.p q))(p(λp.λq.p(p q)))q g))(λp.u)(λu.u qλq.λu.g j i q(b l(p(λp.λq.p(p(p(p q)))))q u))))λp.p(λp.λb.q p((λp.λq.l(λp.l)(λp.λq.p q)(λq.p j q)q)p b))λp.λp.p)l q))(λp.p)(λp.p(λp.λp.p)λp.λp.p)(λp.λq.p)))(b(p(λp.λp.p))(p(λp.λq.p(p q)))))(λp.λq.λb.p(q b))λp.λq.q(λp.λq.λb.p(λp.λb.b(p q))(λp.b)λp.p)p)λp.λq.λb.q(q(q(q(q(q(p q b))))))

Вход и выход состоят из правильных списков закодированных церковью кодов символов, , например, код символа новой строки равен 10, поэтому кодировка церкви будет такой λf.λx.f(f(f(f(f(f(f(f(f(f x))))))))). Преобразование "ABCD" в список выглядит, λf.λx.f 65 (f 66 (f 67 (f 68 x)))но с цифрами, закодированными церковью.

Применение закодированной строки к программе и ее полное сокращение должно дать вам закодированную строку вывода с примененным RLE.

трусливый , 42 байта

s=>s::gsub("(\\d+)(.)",(_,a,b)=>b::rep(a))

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

C ++, 239 235 байт

-4 байта благодаря Захари

#include<regex>
using s=std::string;std::regex m("[0-9]*[<>+.,\\[\\]-]");s t(s r){s d,h;std::sregex_iterator i(r.begin(),r.end(),m),e;while(i!=e){h=(*i)[0];int g=std::strtol(h.data(),NULL,10);g+=!g;d+=s(g,h[h.size()-1]);++i;}return d;}

Dart, 78 байтов (с регулярным выражением), 102 байта (без регулярного выражения)

С регулярным выражением:

(i)=>i.splitMapJoin(new RegExp(r"(\d+)(.)"),onMatch:(m)=>m[2]*int.parse(m[1]))

Без регулярных выражений:

(i,[n=0,d=0])=>i.codeUnits.map((c)=>i[d++]*((c-=48)>=0&&c<10?0*(n=n*10+c):n<1?1:(n=0*(c=n))+c)).join()

Оба должны быть вызваны как (<code here>)("input string").

Regex one довольно стандартен, но без регулярных выражений совершенно особенный.

Без регулярных выражений злоупотребляет необязательными параметрами для размещения локальных переменных в функции «одиночного возврата», в противном случае вам потребуется создать блок и иметь ключевое слово return. Для каждой единицы кода, если единица кода находится между 0 и 9, она накапливается nи возвращается пустая строка. В противном случае символ умножается на значение n(в специальном регистре, если n == 0, в этом случае он всегда будет испускать 1 символ), и nустанавливается в 0. Устанавливает (n=0*(c=n))+cаргумент кода char в значение n, умножается n/ cна 0 , сохраняет от 0 до n, затем добавляет c. Это сбрасывает наши, nне находясь в контексте заявления.

Python3, 96 байт

s,r=input(),""
while s:
 d=0
 while"/"<s[d]<":":d+=1
 r+=int(s[:d] or 1)*s[d];s=s[d+1:]
print(r)

Я пробовал другую реализацию в Python, но я не разбил /codegolf//a/146923/56846 :(