RLE Brainfuck

(пов'язано з BF-RLE )

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

8>дорівнює >>>>>>>>.

Довжина завжди знаходиться в лівій частині команди.

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

Наприклад:

Вхід:

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

Вихід:

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

Виграє найкоротший код у кількості байтів на кожній мові.

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.) Перший +- це одинарний оператор, який прив'язується до першого числа, а другий +s - конкатенація рядків. Це б'є більш очевидне

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

на 14 байт. Зазвичай, "\2"це не завжди працюватиме, але, на щастя, \і "це не ебані команди.

xnor врятував байт, подаючи 1*\1*1трюк. Раніше я мав \1Lв регулярному виразі і визначав L=1як лямбда-аргумент, що також досить круто: 3Lце довгий int-літерал і Lє змінною.

Pyth , 2 байти

r9

Спробуйте тут!

Як це працює

r9 - Повна програма отримання рядка від STDIN.

r - набір розширених рядкових операцій Pyth.
 9 - дев'ята команда цього набору (декодування довжини виконання). Це підтримує багатоцифрові числа.

Луа, 65 64 63 байт

Чудово! Один раз Луа б’є Python!

Редагувати: Збережено один байт завдяки @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>;і друкує потрібний вихід до документа.

Сітківка , 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, завдяки спадару XXcoder

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, в якому ви створюєте масив з двома елементами, а потім індексуєте його за допомогою булевого виразу, яке ви хочете перевірити, при цьому помилковий результат дає вам елемент 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 bytes

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

Try it online!

Thanks to Adám for providing the correct version of the code.

How it works:

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

Proton, 50 bytes

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

Try it online!

Java 8, 148 bytes

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");}

^Gdamn Java regexes are so useless sometimes.. Last time it was lack of using the capture group "$1" for anything, now this.. I want to replace 3c with ccc or 000c with ccc as a one-liner, but unfortunately Java has no way of doing this without a loop. Ah well.

Explanation:

Try it here.

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 bytes

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

Try it online!

Explanation:

span(`elem`['0'..'9'])s splits the given string s into a prefix of digits and the remainder. Matching on the result on the pattern (n:m,x:r) ensures that the digit prefix is non-empty and binds the character after the digits to x and the remainder to r. x<$[1..read$n:m] reads the string of digits n:m as number and repeats x that many times. The result is concatenated to the recursive treatment of the remaining string r.

R, 151 bytes

Outgolfed by user2390246! This is now basically a garbage approach compared to that one, but I'll continue to improve it.

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

Try it online!

Also outputs a bunch of warnings.

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

Next up, seeing if using a grep is more efficient than substr

JavaScript (ES6), 46 bytes

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

Pretty straightforward explanation:

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

Ruby, 35 bytes

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

Try it online!

Untyped Lambda Calculus, 452 bytes

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

Input and output comprise of right-fold lists of church encoded character codes, for example the character code of a newline is 10 so the church encoding would be λf.λx.f(f(f(f(f(f(f(f(f(f x))))))))). Converting "ABCD" to a list looks like λf.λx.f 65 (f 66 (f 67 (f 68 x))) but with the numbers church-encoded.

Applying an encoded string to the program and reducing it all the way should give you an encoded output string with the RLE applied.

Funky, 42 bytes

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

Try it online!

C++, 239 235 bytes

-4 bytes thanks to Zacharý

#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 bytes (with regex), 102 bytes (without regex)

With Regex:

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

Without Regex:

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

Both must be invoked like (<code here>)("input string").

Regex one is quite standard, but the regex-less one is quite special.

Regex-less abuses optional parameters to allocate local variables in "single return" function, otherwise you'd need to make a block and have the return keyword. For each code unit, if the code unit is between 0 and 9 it is accumulated to n and an empty string is returned. Otherwise, the the character is multiplied by the value of n (special cased if n == 0, in that case it will always emit 1 character) and n is set to 0. (n=0*(c=n))+c sets the char code argument to the value of n, multiplies n/c with 0, stores 0 to n, then adds c. This resets our n without being in a statement context.

Python3, 96 bytes

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)

I tried another implementation in Python, but i don't beat /codegolf//a/146923/56846 :(