RLE Brainfuck

(terkait dengan BF-RLE )

Dialek RLE ( Run-Length Encoding ) hipotetis dari Brainfuck menerima simbol untuk 8 perintah dan juga menerima angka. Digit digunakan untuk mewakili jumlah pengulangan berturut-turut dari suatu perintah, sehingga memungkinkan pengodean run-length dari kode sumber.

8>sama dengan >>>>>>>>.

Panjang selalu di sisi kiri perintah.

Tugas Anda adalah menulis program / fungsi terpendek yang menerjemahkan string input (fragmen RLE Brainfuck) ke dalam program Brainfuck biasa.

Sebagai contoh:

Memasukkan:

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

Ouptut:

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

Kode terpendek dalam hitungan byte dalam setiap bahasa akan menang.

Python 2 , 62 61 byte

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

Cobalah online!

Substitusi regex diperluas 3<2+-ke string:

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

yang kemudian evaldiedit. (Perhatikan bagaimana ketika \1kosong, kita dapatkan 1**1 = 1.) Yang pertama +adalah operator unary yang mengikat ke nomor pertama, dan yang lainnya +adalah penggabungan string. Ini berdetak lebih jelas

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

dengan 14 byte. Biasanya "\2"tidak selalu berhasil, tetapi untungnya \dan "bukan perintah brainfuck.

xnatau menyimpan byte, memasok 1*\1*1trik. Sebelumnya saya punya \1Ldi regex, dan didefinisikan L=1sebagai argumen lambda, yang juga cukup keren: 3Ladalah int literal panjang dan Lmerupakan variabel.

Pyth , 2 byte

r9

Coba di sini!

Bagaimana itu bekerja

r9 - Program lengkap yang menerima String dari STDIN.

r - rangkaian operasi string Pyth yang diperluas.
 9 - Perintah kesembilan dari set itu (run-length decode). Ini mendukung nomor multi-digit.

Lua, 65 64 63 Bytes

Bagus ! Untuk sekali ini, Lua mengalahkan Python!

Sunting: Disimpan satu byte berkat @Jarhmander, terima kasih padanya untuk trik yang berguna untuk memaksakan hasil tunggal

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

Cobalah online!

Penjelasan

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 byte

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

Cobalah online!

Perl 5 , 18 byte

17 byte kode +1 untuk -p.

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

Cobalah online!

vim, 29 25 23 22 16 byte

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

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

Ini bekerja dengan mengganti setiap non-digit dengan perintah yang menambahkan karakter itu ke buffer. Hitungan dibiarkan sendiri dan memodifikasi perintah-perintah itu. Pada titik ini, buffer adalah program vimscript yang menghasilkan program Brainfuck yang diinginkan, jadi kami menariknya ke dalam register dan menjalankannya.

Cobalah online!

Sunting: Pengurangan ukuran berkat saran: H.PWiz: 5, TheFamilyFroot: 5, DJMcMayhem: 1

RLE Brainfuck, 204 byte

-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>-]<,]

Seperti yang saya pahami, spesifikasi untuk lingkungan brainfuck tidak super jelas. Program ini mengasumsikan bahwa sel-sel dalam rekaman memungkinkan bilangan bulat positif dan negatif sewenang-wenang besar, tanpa meluap. Kode ini juga akan mentranskripsi komentar non-perintah, tetapi akan memperluas pengkodean komentar run-length (mis. "Lihat 3b" → "see bbb"). Program yang dihasilkan harus menjalankan hal yang sama, jadi saya tidak terlalu khawatir.

Saya cukup yakin saya masih bisa bermain golf beberapa byte dari ini, tetapi saya lelah bekerja dengannya.

Inilah tes + juru bahasa khusus yang telah saya gunakan untuk mengujinya. Jika Anda memasukkannya input dalam kotak Input Standar itu harus berjalan terhadap input itu daripada menjalankan tes.

Workpad saya yang ungolfed berantakan:

->>>,
[
  [->+>+<<]>>  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 -
  ]
  <
  ,
]

Ditumpuk , 24 byte

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

Cobalah online!

Penjelasan

['(\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 byte

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

(menulis dalam dua baris agar terlihat, tetapi kode dapat ditulis dalam satu baris)

Ini mendefinisikan makro \byang mengambil input dalam bentuk \b<input>;, dan mencetak output yang diinginkan ke dokumen.

Retina , 28 23 byte

terima kasih kepada @ Leo untuk -5 byte

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

Cobalah online!

Pyon , 66 byte

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

Cobalah online!

Pyon cukup banyak hanya Python, tetapi ini lebih pendek karena re secara otomatis diimpor ketika Anda menggunakannya, dan asecara otomatis diatur ke argumen atau input

-4 byte terima kasih kepada Tn. Xcoder

Python 2 , 100 93 89 byte

-7 dengan terima kasih kepada Mr.Xcoder

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

Cobalah online!

Haskell , 60 byte

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

Cobalah online!

R , 121 106 90 byte

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

Cobalah online!

Disimpan 15 byte dengan menyadari bahwa rep()akan memaksa untuk numerik. Disimpan 16 berkat Giuseppe, terutama dari penggunaan pmaxuntuk mengganti string kosong dengan1

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 byte

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

Cobalah online!

Kerusakan

Berantakan sekali!

Mulai dari $args, yang merupakan array elemen tunggal yang berisi string RLE, saya memaksa menjadi string yang sebenarnya dengan membungkusnya dengan tanda kutip.

Kemudian pisahkan dengan batas kata ( \bdalam regex). Itu akan memberi saya array string, di mana setiap elemen adalah angka atau token BF yang datang setelah angka. Jadi dalam contoh, pertama 4 elemen array perpecahan ini 10, +]>+>, 3, +>(semua string).

Selanjutnya, saya pipa itu ke ForEach-Object( %) untuk menangani setiap elemen .

Bagian tengahnya adalah golfism PowerShell yang terkenal, dengan twist; itu pada dasarnya operator DIY ternary, di mana Anda membuat array 2 elemen kemudian indeks ke dalamnya menggunakan ekspresi boolean yang ingin Anda uji, di mana hasil yang salah memberi Anda elemen 0 dan hasil yang benar memberi Anda elemen 1.

Dalam hal ini, saya benar-benar membuat array elemen tunggal dengan ,operator koma unary , karena saya tidak ingin output dalam kasus yang sebenarnya.

Pertama mari kita lihat pengindeks, meskipun dieksekusi nanti.

Gagasannya adalah $_(elemen saat ini) dapat berupa angka yang valid, atau string lain. Jika itu angka, saya ingin $nmenjadi nilai angka itu minus 1 (sebagai angka, bukan string). Jika tidak, saya mau$n salah-y.

PowerShell biasanya mencoba untuk memaksa nilai kanan ke jenis sisi kiri, tetapi itu bisa bergantung pada operasi. Sebagai tambahan, "10"+5akan memberi Anda string baru "105",, sedangkan 10+"5"akan memberi Anda integer (15 ).

Tetapi string tidak dapat dikurangi sehingga PowerShell dapat menyimpulkan nilai numerik secara otomatis dengan string di sisi kiri pengurangan, oleh karena itu "10"-5memberi 5.

SO, saya mulai dengan $_-1, yang akan memberi saya nomor yang saya inginkan ketika $_sebenarnya angka, tetapi ketika tidak, saya tidak mendapatkan apa-apa. Di permukaan, "tidak ada" adalah falsey, tetapi masalahnya adalah berhenti menjalankan tugas itu, jadi$n akan mempertahankan nilai sebelumnya; bukan yang saya inginkan!

Jika saya membungkusnya dalam subekspresi, maka ketika gagal, saya mendapatkan nilai falsey saya: $($_-1) .

Bahwa semua ditugaskan $ndan karena tugas itu sendiri dibungkus dengan tanda kurung, nilai yang ditugaskan $njuga akan diteruskan ke pipa.

Karena saya menggunakannya di pengindeks, dan saya ingin 1jika konversi berhasil, saya menggunakan dua notekspresi boolean !!untuk mengubah nilai ini menjadi boolean. Konversi angka yang sukses berakhir sebagai benar, sedangkan ketiadaan falsey memberi kita manis, manis 0yang memungkinkan untuk mengembalikan satu-satunya elemen dalam array ternary palsu itu.

Kembali ke array itu, elemennya adalah ini: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- Ini adalah cara yang sangat panjang untuk mendapatkan karakter pertama dari elemen saat ini (katakanlah, dapatkan +dari +[>+), tetapi sebagai string dan bukan sebagai[char] objek. Saya membutuhkannya untuk menjadi string karena saya dapat mengalikan string dengan angka untuk menduplikasi, tetapi saya tidak bisa melakukannya dengan karakter.

Sebenarnya saya berhasil menyimpan 4 karakter dengan menggunakan [char]array alih-alih string (dengan menggunakan koma unary lain ,), jadi saya dapat menghapus tanda kutip dan sub-ekspresi tambahan. Saya bisa mengalikan array untuk menduplikasi elemen-elemennya. Dan karena seluruh hasil iterasi ini akhirnya menjadi sebuah array dan perlu-join diedit, menggunakan array di sini tidak menimbulkan biaya tambahan.

Lalu, saya kalikan array string itu dengan $n, untuk menduplikasinya $nkali. Ingat itu $nbisa terjadi$null atau bisa nilai digit sebelumnya minus satu.

Kemudian +$_ tambahkan elemen saat ini ke akhir karakter pertama yang digandakan dari elemen itu. Itu sebabnya $nminus satu.

Dengan cara ini, 10+[>+berakhir dengan $nsama dengan 9, maka kita menghasilkan 9+ 's dan menambahkannya kembali ke +[>+string untuk mendapatkan 10 yang diperlukan, ditambah elemen tunggal lainnya sepanjang untuk perjalanan.

Unsur ini dibungkus subexpression sebuah $()karena ketika $nadalah$null , seluruh ekspresi gagal, sehingga menciptakan array gagal, sehingga pengindeks tidak pernah berjalan, sehingga$n tidak pernah akan ditugaskan.

Alasan saya menggunakan trik ternary ini adalah karena salah satu kekhasannya: tidak seperti operator ternary nyata, ekspresi yang menentukan elemen lakukan bisa dievaluasi apakah atau tidak mereka "dipilih", dan pertama dalam hal ini.

Karena saya perlu menetapkan dan kemudian menggunakannya $npada iterasi yang terpisah, ini sangat membantu. Nilai elemen array ternary akan dievaluasi dengan nilai iterasi sebelumnya $n, kemudian pengindeks ditugaskan kembali $nuntuk iterasi saat ini.

Sehingga ForEach-Object loop akhirnya menghasilkan semua yang seharusnya (banyak kesalahan yang kita abaikan), tetapi sebagai array dari string baru.

Sehingga semuanya dibungkus dalam tanda kurung dan kemudian didahului oleh unary -joinuntuk memberikan string keluaran.

QuadR , 17 byte

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

Cobalah online!

Terima kasih kepada Adám karena menyediakan versi kode yang benar.

Bagaimana itu bekerja:

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

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

Cobalah online!

Java 8, 148 byte

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 regex} Java kadang-kadang sangat tidak berguna .. Terakhir kali itukurang menggunakan kelompok tangkap"$1"untuk apa pun, sekarang ini .. Saya ingin mengganti3cdengancccatau000cdengancccsebagai satu-liner, tapi sayangnya Jawa tidak memiliki cara untuk melakukan ini tanpa lingkaran. Baiklah

Penjelasan:

Coba di sini.

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 byte

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

Cobalah online!

Penjelasan:

span(`elem`['0'..'9'])smembagi string yang diberikan smenjadi awalan digit dan sisanya. Pencocokan pada hasil pada pola (n:m,x:r)memastikan bahwa awalan digit tidak kosong dan mengikat karakter setelah digit ke xdan sisanya ke r. x<$[1..read$n:m]membaca deretan angka n:msebagai angka dan mengulangi xitu berkali-kali. Hasilnya digabungkan dengan perawatan rekursif dari string yang tersisa r.

R , 151 byte

Dikalahkan oleh pengguna2390246 ! Ini sekarang pada dasarnya pendekatan sampah dibandingkan dengan yang itu, tapi saya akan terus memperbaikinya.

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

Cobalah online!

Juga menghasilkan banyak peringatan.

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

Selanjutnya, melihat apakah menggunakan greplebih efisien daripadasubstr

JavaScript (ES6), 46 byte

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

Penjelasan yang cukup mudah:

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 byte

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

Cobalah online!

Kalkulus Lambda yang tidak diketik , 452 byte

(λ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 dan output terdiri dari daftar lipatan kanan dari kode karakter yang dikodekan gereja , misalnya kode karakter dari baris baru adalah 10 sehingga pengkodean gereja akan menjadiλf.λx.f(f(f(f(f(f(f(f(f(f x))))))))) . Mengonversi "ABCD" ke daftar terlihat sepertiλf.λx.f 65 (f 66 (f 67 (f 68 x))) tetapi dengan angka yang dikodekan oleh gereja.

Menerapkan string yang disandikan ke program dan menguranginya sepanjang jalan akan memberikan Anda string keluaran yang disandikan dengan RLE yang diterapkan.

Funky , 42 byte

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

Cobalah online!

C ++, 239 235 byte

-4 byte berkat 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 byte (dengan regex), 102 byte (tanpa regex)

Dengan Regex:

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

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

Keduanya harus dipanggil seperti (<code here>)("input string").

Regex satu cukup standar, tetapi regex-kurang cukup istimewa.

Regex-less penyalahgunaan parameter opsional untuk mengalokasikan variabel lokal dalam fungsi "pengembalian tunggal", jika tidak, Anda perlu membuat blok dan memiliki kata kunci kembali. Untuk setiap unit kode, jika unit kode antara 0 dan 9 itu diakumulasikan ke ndan string kosong dikembalikan. Jika tidak, karakter dikalikan dengan nilai n(khusus cased jika n == 0, dalam hal itu akan selalu memancarkan 1 karakter) dan ndiatur ke 0. (n=0*(c=n))+cmengatur argumen kode char ke nilai n, mengalikan n/ cdengan 0 , simpan 0 hingga n, lalu tambahkan c. Ini mengatur ulang kita ntanpa dalam konteks pernyataan.

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