RLE Brainfuck

( BF-RLE ile ilgili )

Brainfuck'un varsayımsal RLE ( Çalışma Uzunluğu Kodlaması ) lehçesi 8 komutun sembollerini kabul eder ve ayrıca rakamları kabul eder. Basamaklar, bir komutun art arda tekrar sayısını temsil etmek için kullanılır, böylece kaynak kodunun çalışma uzunluğu kodlamasına izin verir.

8>eşittir >>>>>>>>.

Uzunluk her zaman komutun sol tarafındadır.

Göreviniz, giriş dizesini (RLE Brainfuck parçası) normal bir Brainfuck programına dönüştüren en kısa programı / işlevi yazmaktır.

Örneğin:

Giriş:

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

ouptut:

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

Her dilde bayt sayısındaki en kısa kod kazanacaktır.

Python 2 , 62 61 bayt

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

Çevrimiçi deneyin!

Normal ifade ikamesi 3<2+-dizeye genişler :

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

sonra evaled. ( \1Boş olduğunda , nasıl elde ettiğimize dikkat edin 1**1 = 1.) Birincisi +, ilk sayıya bağlanan tekli bir operatördür ve diğeri +dize birleştirme işlemidir. Bu daha belirgin

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

14 bayt tarafından. Normalde "\2"her zaman işe yaramaz, ama şükürler olsun \ve "beyni olmayan komutlar değildir.

xnor1*\1*1 hileyi vererek bir bayt kaydetti . Daha önce \1Lregex vardı ve L=1aynı zamanda oldukça serin bir lambda argümanı olarak tanımlanan : 3Luzun bir int değişmez ve Lbir değişkendir.

Pyth , 2 bayt

r9

Burada deneyin!

Nasıl çalışır

r9 - Dizeyi STDIN'den alan tam program.

r - Pyth'in genişletilmiş dize işlemleri kümesi.
 9 - Bu setin dokuzuncu komutu (çalışma uzunluğu kod çözme). Bu, çok basamaklı sayıları destekler.

Lua, 65 64 63 Bayt

Harika ! Lua bir kez Python'u yeniyor!

Düzenleme: @Jarhmander sayesinde bir bayt kaydedildi, tek bir sonucu zorlamak için yararlı bir numara için onun sayesinde

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

Çevrimiçi deneyin!

açıklamalar

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 bayt

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

Çevrimiçi deneyin!

Perl 5 , 18 bayt

17 bayt kodu + 1 için -p.

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

Çevrimiçi deneyin!

vim, 29 25 23 22 16 bayt

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

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

Rakam olmayan her bir karakteri, bu karakteri arabelleğe ekleyen bir komutla değiştirerek çalışır. Sayılar tek başına bırakılır ve bu komutlar değiştirilir. Bu noktada, tampon istenen Brainfuck programını üreten bir vimscript programıdır, bu yüzden bir kayıt defterine çeker ve çalıştırırız.

Çevrimiçi deneyin!

Düzenleme: Öneriler sayesinde boyut küçültme: H.PWiz: 5, TheFamilyFroot: 5, DJMc

RLE Brainfuck, 204 bayt

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

Anladığım kadarıyla, beyin fırtınası ortamının özellikleri çok iyi tanımlanmamış. Bu program, banttaki hücrelerin taşma olmadan keyfi olarak büyük pozitif ve negatif tamsayılara izin verdiğini varsayar. Bu kod, komut olmayan yorumları da yazacaktır, ancak yorumların çalışma uzunluğu kodlamasını genişletecektir (örn. "Bkz. 3b" → "bkz. Bbb"). Ortaya çıkan program aynı şekilde çalışmalıdır, bu yüzden fazla endişelenmiyorum.

Hala birkaç bayt kapalı golf olabilir eminim ama onunla çalışmaktan yorgunum.

İşte test etmek için kullandığım özel yorumlayıcı + testler. Girişini Standart Giriş kutusuna iletirseniz, testleri çalıştırmak yerine bu girişe karşı çalışmalıdır.

Dağınık dağınık çalışma yüzeyim:

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

Yığılmış , 24 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

(görünür olması için iki satır halinde yazılmıştır, ancak kod bir satırda yazılabilir)

Bu \b, girdiyi formda alan bir makro tanımlar \b<input>;ve istenen çıktıyı belgeye yazdırır.

Retina , 28 23 bayt

-5 bayt için @Leo sayesinde

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

Çevrimiçi deneyin!

Pyon , 66 bayt

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

Çevrimiçi deneyin!

Pyon hemen hemen sadece Python'dur, ancak bu daha kısadır, çünkü rekullandığınızda otomatik olarak içe aktarılır ve aotomatik olarak bir argümana veya girişe ayarlanır

Bay Xcoder sayesinde -4 bayt

Python 2 , 100 93 89 bayt

-X Mr.Xcoder sayesinde

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

Çevrimiçi deneyin!

Haskell , 60 bayt

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

Çevrimiçi deneyin!

R , 121 106 90 bayt

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

Çevrimiçi deneyin!

rep()Sayıyı zorlayacak şekilde 15 bayt kaydedildi . Giuseppe sayesinde, pmaxboş dizeleri değiştirmek yerine1

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 bayt

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

Çevrimiçi deneyin!

Yıkmak

Ne dağınıklık!

Den başlayarak $argsRLE dizesini içeren tek bir öğe dizisi olan , ben tırnaklarını sararak gerçek bir dize zorlamak.

Sonra kelime sınırına bölün ( \bnormal ifade ile). Bu, her öğenin bir sayı veya sayıdan sonra gelen BF belirteçleri olduğu bir dizi dizeyi verecektir. Örnekte, bu bölünmüş dizinin ilk 4 unsurlarıdır Yani 10, +]>+>, 3, +>(bütün dizgi).

Sonra, bunu her öğeyle başa çıkmak için ForEach-Object( %) içine koyarım .

Orta, iyi bilinen bir PowerShell golfizmidir; aslında bir DIY üçlü operatörüdür, burada 2 elemanlı bir dizi oluşturup test etmek istediğiniz boolean ifadesini kullanarak dizine eklersiniz, böylece yanlış bir sonuç size element 0'ı verir ve gerçek bir sonuç size element 1'i verir.

Bu durumda, ,gerçek durumda çıktı istemiyorum çünkü aslında tekli virgül operatörü ile tek bir öğe dizisi oluşturmak .

Önce, daha sonra çalıştırılsa bile dizinleyiciye bakalım.

Bunun fikri, $_(geçerli öğe) geçerli bir sayı veya başka bir dize olabileceğidir. Bu bir sayı ise, $nbu sayının eksi 1 (bir sayı olarak değil, bir dize) değeri olmak istiyorum . Değilse, $nyanlış olmak istiyorum .

PowerShell genellikle sağ taraftaki değeri sol tarafın türüne zorlamaya çalışır, ancak işleme bağlı olabilir. Buna ek olarak, "10"+5size yeni bir dize "105"verirken 10+"5", size bir tamsayı ( 15) verecektir .

Ancak dizeler çıkarılamaz, bu nedenle PowerShell, sayısal değeri çıkarma işleminin sol tarafındaki bir dize ile otomatik olarak çıkarabilir, bu nedenle "10"-5verir 5.

Yani, başlangıçta , aslında bir sayı $_-1olduğunda istediğim numarayı verecek $_, ama olmadığında hiçbir şey alamıyorum. Yüzeyde, "hiçbir şey" falseydir, ama sorun şu ki, o ödevin yürütülmesini durdurur, bu yüzden $nönceki değerini korur; istediğim gibi değil!

Bir alt ifadeye sarırsam, başarısız olduğunda, falsey değerimi alırım: $($_-1) .

Her şeyin atandığı $nve bu atamanın kendisi parantez içine alındığı için, atanan değer $nde boru hattına aktarılır.

1Dizin oluşturucuda kullandığım ve dönüşüm başarılı olursa istiyorum , ben bu değeri boole dönüştürmek için iki boolean- notifadeleri !!kullanın. Başarılı bir sayı dönüşümü gerçek olarak sonuçlanırken, falsey hiçbir şey bize 0o sahte üçlü dizideki tek öğeyi döndürmeye izin veren tatlı, tatlı verir.

Bu diziye geri dönersek, öğe şudur: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- bu, geçerli öğenin ilk karakterini (diyelim ki, almak +için +[>+) almanın can sıkıcı uzun bir yoludur , ancak bir [char]nesne olarak değil, bir dize olarak . Ben çoğaltmak için bir sayı ile bir dize çarpabilir, ancak bir karakter ile bunu yapamam çünkü bir dize olması gerekiyor.

Aslında [char](başka bir tek virgül kullanarak) bir dize yerine bir dizi kullanarak 4 karakter kaydetmeyi başardı ,, bu yüzden tırnak ve ekstra alt ifade kaldırmak mümkün. Ben yapabilirsiniz öğelerini çoğaltmak için bir dizi çarpın. Ve bu yinelemenin tüm sonucu yine de bir dizi haline geldiğinden ve düzenlenmesi gerektiğinden -join, burada bir dizi kullanmanın ek bir maliyeti yoktur.

Sonra, kez çoğaltmak için bu dize dizisi ile çarpın . Hatırlanacağı olabilir$n$n$n$nullÖnceki basamakların eksi bir değeri olabileceğini veya .

Ardından +$_, geçerli öğeyi, o öğenin çoğaltılan ilk karakterinin sonuna ekler. Bu yüzden $neksi bir.

Bu şekilde, 10+[>+birlikte biter $n, o zaman 9 yapmak 9'a eşit +'ın ve onu geri ekleyin +[>+10 koşul artı gezinti için diğer tek öğeleri almak için dize.

Eleman, bir alt ifade sarılır $()çünkü ne zaman $nolduğunu $nulldizinleyici çalışır, böylece hiçbir tüm ifade, yani, başarısız şekilde dizi oluşturma başarısız $natanır olmadı.

Bu üçlü numara kullanılmaktadır nedeni onun özelliklerini birinin geçerli: Gerçek bir üçlü operatör aksine elemanlarını tanımlayan ifadeler do bu konuda ilk onlar "seçilmiş" olsun ya da olmasın değerlendirdi ve almak.

$nAyrı yinelemeler atamam ve sonra kullanmam gerektiğinden , bu yardımcı olur. Üçlü dizi öğesi değeri önceki yinelemenin $ndeğeri ile değerlendirilir , ardından dizinleyici $ngeçerli yineleme için yeniden atar .

Böylece ForEach-Objectdöngüler, olması gereken her şeyi (görmezden geldiğimiz bir grup hata) çıkarır, ancak yeni dizeler dizisi olarak sonuçlanır.

Böylece, her şey parantez içine alınır ve daha sonra -joinçıktı dizesini vermek için tekli kullanılır .

QuadR , 17 bayt

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

Çevrimiçi deneyin!

Adám'a kodun doğru sürümünü sağladığı için teşekkür ederiz .

Nasıl çalışır:

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

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

Çevrimiçi deneyin!

Java 8, 148 bayt

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 Son kez öyleydi .. bu kadar yararsız bazenyakalama grubunu kullanarak eksikliği"$1"şey içinşimdi bu .. ben değiştirmek istiyorum,3cbirliktecccveya000cbirlikteccctek astar olarak, ama ne yazık ki Java a olmadan bunu yapmanın bir yolu vardır döngü. Ah güzel.

Açıklama:

Burada deneyin.

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 bayt

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

Çevrimiçi deneyin!

Açıklama:

span(`elem`['0'..'9'])sverilen dizgeyi sbir sayı önekine ve geri kalanına böler . Desendeki sonuçla eşleme (n:m,x:r), basamak önekinin boş olmamasını sağlar ve rakamdan sonraki basamağa xve kalan karaktere bağlanır r. x<$[1..read$n:m]basamak dizesini sayı n:molarak okur ve xbunu defalarca tekrarlar . Sonuç, kalan ipin özyinelemeli tedavisine birleştirilir r.

R, , 151 bayt

User2390246 tarafından geride bırakıldı ! Bu şimdi temelde buna kıyasla bir çöp yaklaşımı, ama geliştirmeye devam edeceğim.

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

Çevrimiçi deneyin!

Ayrıca bir sürü uyarı verir.

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

Ardından bir kullanarak eğer görerek grepdaha etkilidirsubstr

JavaScript (ES6), 46 bayt

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

Oldukça basit bir açıklama:

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

Yakut , 35 bayt

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

Çevrimiçi deneyin!

Untyped Lambda Analiz , 452 bayt

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

Girdi ve çıktı, kilise kodlu karakter kodlarının sağ kat listelerinden oluşur, örneğin bir satırsonunun karakter kodu 10'dur, böylece kilise kodlaması olacaktır . "ABCD" nin bir listeye dönüştürülmesiλf.λx.f(f(f(f(f(f(f(f(f(f x)))))))))λf.λx.f 65 (f 66 (f 67 (f 68 x))) , kilisenin kodladığı sayılara .

Programlanmış bir kodlanmış dize uygulamak ve sonuna kadar azaltmak size RLE uygulanmış bir kodlanmış çıkış dizesi vermelidir.

Korkak , 42 bayt

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

Çevrimiçi deneyin!

C ++, 239 235 bayt

Zacharý sayesinde -4 bayt

#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 bayt (normal ifade ile), 102 bayt (normal ifade olmadan)

Regex ile:

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

Regex olmadan:

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

Her ikisi de şöyle çağrılmalıdır (<code here>)("input string") .

Regex one oldukça standart, ancak regex-less bir oldukça özel.

Regex-less, "tek dönüş" işlevinde yerel değişkenleri ayırmak için isteğe bağlı parametreleri kötüye kullanır, aksi takdirde bir blok oluşturmanız ve return anahtar sözcüğüne sahip olmanız gerekir. Her kod birimi için, kod birimi 0 ile 9 arasındaysa, biriktirilir nve boş bir dize döndürülür. Aksi takdirde, karakter değeri ile çarpılır n(n == 0 ise özel kasalı, bu durumda her zaman 1 karakter yayar) ve n0 olarak ayarlanır. Karakter (n=0*(c=n))+ckodu bağımsız değişkenini n, çarpı n/ cile 0 değerine ayarlar , 0 değerini depolar n, sonra ekler c. Bu n, bir ifade bağlamında olmadan sıfırlar .

Python3, 96 bayt

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'da başka bir uygulama denedim, ancak /codegolf//a/146923/56846 :(