RLE Brainfuck

（BF-RLEに関連）

Brainfuck の架空のRLE（Run-Length Encoding）方言は、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編集されます。（when \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*1トリックを提供しました。以前、私は\1L正規表現でL=1、ラムダ引数として定義していましたが、これもかなりクールです：3Llong intリテラルでLあり、変数です。

Pyth、2バイト

r9

ここで試してみてください！

使い方

r9-STDINから文字列を受け取る完全なプログラム。

r-Pythの一連の拡張文字列操作。
 9-そのセットの9番目のコマンド（ランレングスデコード）。これは、複数桁の数字をサポートします。

ルア、 65 64 63バイト

すごい ！かつて、LuaはPythonを打ち負かしました！

編集：@Jarhmanderのおかげで1バイト保存されました。単一の結果を強制する便利なトリックに感謝します

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です。

これは、各非数字を、その文字をバッファーに追加するコマンドで置き換えることにより機能します。カウントはそのままにして、これらのコマンドを変更します。この時点で、バッファは目的のBrainfuckプログラムを生成するvimscriptプログラムであるため、レジスタにプルして実行します。

オンラインでお試しください！

編集：提案によるサイズ削減：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>-]<,]

私が理解しているように、brainfuck環境の仕様はあまり明確に定義されていません。このプログラムは、テープ内のセルが任意の大きな正および負の整数を許容し、オーバーフローしないことを前提としています。このコードは、非コマンドコメントも書き起こしますが、コメントのランレングスエンコーディングを拡張します（たとえば、「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}

（表示されるように2行で書きましたが、コードは1行で記述できます）

これは\b、フォームの入力を受け取り\b<input>;、ドキュメントに必要な出力を出力するマクロを定義します。

網膜、28 23バイト

-5バイトの@Leoに感謝

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

オンラインでお試しください！

Pyon、66バイト

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

オンラインでお試しください！

PyonはほとんどPythonですが、re使用すると自動的にインポートされるため、これは短くなります。aされ、引数または入力に自動的に設定なります

Xcoder氏のおかげで-4バイト

パイソン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="")

オンラインでお試しください！

rep()強制的に数値に変換することで15バイトを節約しました。ジュゼッペのおかげで、主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))]})

オンラインでお試しください！

壊す

なんてこった！

$argsRLE文字列を含む単一の要素配列であるから開始し、引用符で囲むことにより実際の文字列に強制します。

次に、単語の境界で分割します（\b正規表現内）でます。これにより、文字列の配列が得られます。各要素は、数字または数字の後に続くBFトークンのいずれかです。一例では、この分割された配列の最初の4つの要素であるので10、+]>+>、3、+>（すべての文字列です）。

次に、各要素を処理するためにForEach-Object（%）にパイプします。

真ん中は、よく知られたPowerShellのゴルフィズムです。それは基本的にDIY三項演算子であり、2要素の配列を作成し、テストするブール式を使用してインデックスを作成します。偽の結果は要素0、真の結果は要素1になります。

この場合、実際には単項コンマ,演算子を使用して単一の要素配列を作成します。これは、実際のケースでは出力が必要ないためです。

後で実行される場合でも、最初にインデクサーを見てみましょう。

この考え方は、$_（現在の要素）が有効な数値または他の文字列のいずれかである可能性があるということです。それは数だ場合は、私が欲しい$n、その数の値がマイナス（番号ではなく、文字列として）1であることを。そうでない場合、私は欲しい$n false-y。

PowerShellは通常、右側の値を左側の型に強制しようとしますが、操作に依存する場合があります。さらにに関しては、"10"+5あなたに新しい文字列を与える"105"一方で、10+"5"あなたの整数を与えるだろう（15）。

ただし、文字列は減算できないため、代わりにPowerShellは減算の左側にある文字列を使用して自動的に数値を推測できるため、"10"-5が得られ5ます。

SOから始めます$_-1。これは、$_実際に数値である場合に必要な数値を提供しますが、そうでない場合は何も取得しません。表面的には、「何も」は偽であるが、問題はその割り当ての実行を停止することであるため、$nため、以前の値を保持します。私が欲しいものではありません！

それを部分式でラップすると、失敗したときに偽の値が得られます： $($_-1)。

すべてが割り当てられ$n、その割り当て自体が括弧で囲ま$nれているため、割り当てられた値もパイプラインに渡されます。

インデクサーで使用しているため1、変換が成功した場合は、2つのブールnot式!!を使用してこの値をブール値に変換します。成功した数値変換は最終的にtrueになりますが、偽りのない0ことはその偽りの三元配列の唯一の要素を返すことを可能にする甘い、甘いものを与えます。

その配列に戻ると、要素は次のとおりです。 $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"-これは、現在の要素の最初の文字を取得するための厄介な長い方法です（たとえば、+から取得します+[>+）が、[char]オブジェクトとしてではなく、文字列として取得します。文字列に数字を掛けて複製することができるので、文字列にする必要がありますが、文字ではできません。

実際[char]、文字列の代わりに配列を使用して（別の単項コンマを使用して,）4文字を保存することができたので、引用符と余分なサブ式を削除できました。私がすることができ、その要素を複製する配列を掛けます。そして、とにかくこの反復の結果全体-joinが配列であり、編集する必要があるため、ここで配列を使用しても追加コストは発生しません。

次に、その文字列配列にを乗算して$n、それを数$n回複製します。リコール$nすることができ$nullそれは、前の桁の値から1を引いた値で。

次に+$_、現在の要素を、その要素の複製された最初の文字の最後に追加します。それ$nがマイナス1です。

このように10+[>+して、$n最終的に9になります。その後、9を作成し、それを文字列に+追加して+[>+、必要な10に加えて、ライドに必要な他の単一要素を取得します。

要素は、部分式に包まれ$()たときため$nである$nullので、式全体が失敗し、アレイに障害が発生した作成して、そのインデクサが実行されることはありません$n割り当てれることは決してありません。

この3項トリックを使用した理由は、その特異性の1つです。実際の3項演算子とは異なり、要素を定義する式は、そのことについては最初、彼らが「選択」されているかどうかを評価し、取得します。

割り当ててから$n別の反復で使用する必要があるため、これは役立ちます。3項配列要素の値は前の反復の$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");}

^GdamnのJava正規表現は、前回だった...とても役に立たない時々あるキャプチャグループを使用しての欠如"$1"は何のために今、これは..私は交換したい、3cとcccか000cとcccワンライナーとしては、残念ながらJavaは、Aなしでこれを行う方法はありませんループ。まぁ。

説明：

ここで試してみてください。

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バイト

user2390246によるアウトゴルフ！これは、基本的にはこれと比較して基本的にガーベージアプローチですが、引き続き改善していきます。

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

次に、aを使用する方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")。

正規表現は非常に標準的ですが、正規表現のないものは非常に特殊です。

正規表現を使用しない場合、オプションのパラメーターが悪用され、「シングルリターン」関数でローカル変数が割り当てられます。そうでない場合は、ブロックを作成してreturnキーワードを設定する必要があります。コード単位ごとに、コード単位が0〜9の場合、それは累積さnれ、空の文字列が返されます。そうでない場合、文字はの値が乗算されn且つ（その場合、それは常に1つの文字を放出する、0 == N場合ケーシング特別）n0に設定されている(n=0*(c=n))+cの値に設定する文字コードを引数n、乗算n/ c0でに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で別の実装を試しましたが、https： //codegolf.stackexchange.com/a/146923/56846を破りません:(