RLE Brainfuck

(liên quan đến BF-RLE )

Phương ngữ RLE ( Mã hóa chiều dài chạy ) giả thuyết của Brainfuck chấp nhận các ký hiệu cho 8 lệnh và cũng chấp nhận các chữ số. Các chữ số được sử dụng để biểu thị số lần lặp lại liên tiếp của một lệnh, do đó cho phép mã hóa độ dài chạy của mã nguồn.

8>bằng >>>>>>>>.

Độ dài luôn ở bên trái của lệnh.

Nhiệm vụ của bạn là viết chương trình / hàm ngắn nhất để dịch chuỗi đầu vào (đoạn RLE Brainfuck) thành chương trình Brainfuck thông thường.

Ví dụ:

Đầu vào:

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

Ouptut:

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

Mã ngắn nhất về số byte trong mỗi ngôn ngữ sẽ giành chiến thắng.

Python 2 , 62 61 byte

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

Hãy thử trực tuyến!

Sự thay thế regex mở rộng 3<2+-thành chuỗi:

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

đó là evaled. (Lưu ý khi nào\1 nào trống, chúng ta sẽ nhận được 1**1 = 1.) Đầu tiên +là một toán tử đơn nguyên liên kết với số đầu tiên và các +s khác là nối chuỗi. Điều này càng rõ ràng

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

bằng 14 byte. Thông thường"\2" sẽ không luôn luôn hoạt động, nhưng rất may \và "không phải là lệnh Brainfuck.

xnor đã lưu một byte, cung cấp 1*\1*1thủ thuật. Trước đây tôi đã có \1Ltrong regex, và được định nghĩa L=1là một đối số lambda, cũng khá tuyệt: 3Llà một int dài theo nghĩa đen vàL là một biến.

Bình , 2 byte

r9

Hãy thử nó ở đây!

Làm thế nào nó hoạt động

r9 - Chương trình đầy đủ nhận Chuỗi từ STDIN.

r - Tập hợp các hoạt động chuỗi mở rộng của Pyth.
 9 - Lệnh thứ chín của tập hợp đó (giải mã độ dài chạy). Điều này hỗ trợ số nhiều chữ số.

Lua, 65 64 63 byte

Tuyệt quá ! Lần đầu tiên, Lua đánh bại Python!

Chỉnh sửa: Đã lưu một byte nhờ @Jarhmander, nhờ anh ta cho thủ thuật hữu ích để buộc một kết quả duy nhất

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

Hãy thử trực tuyến!

Giải thích

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

Hãy thử trực tuyến!

Perl 5 , 18 byte

Mã 17 byte + 1 cho -p.

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

Hãy thử trực tuyến!

vim, 29 25 23 22 16 byte

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

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

Nó hoạt động bằng cách thay thế mỗi chữ số không bằng một lệnh nối thêm ký tự đó vào bộ đệm. Số lượng được để lại một mình và sửa đổi các lệnh đó. Tại thời điểm này, bộ đệm là một chương trình vimscript tạo ra chương trình Brainfuck mong muốn, vì vậy chúng tôi kéo nó vào một thanh ghi và chạy nó.

Hãy thử trực tuyến!

Chỉnh sửa: Giảm kích thước nhờ các đề xuất: H.PWiz: 5, TheF FamilyFroot: 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>-]<,]

Theo tôi hiểu, thông số kỹ thuật cho môi trường brainfuck không được xác định rõ ràng. Chương trình này giả định rằng các ô trong băng cho phép các số nguyên dương và âm lớn tùy ý, không có tràn. Mã này cũng sẽ phiên âm các bình luận không phải là lệnh, nhưng nó sẽ mở rộng mã hóa các bình luận có độ dài chạy (ví dụ: "xem 3b" → "xem bbb"). Chương trình kết quả sẽ chạy giống nhau, vì vậy tôi không quá quan tâm.

Tôi khá chắc chắn rằng tôi vẫn có thể chơi golf một vài byte nhưng tôi đã kiệt sức khi làm việc với nó.

Đây là trình thông dịch tùy chỉnh + kiểm tra mà tôi đã sử dụng để kiểm tra nó. Nếu bạn vượt qua đầu vào trong hộp Đầu vào tiêu chuẩn, nó sẽ chạy với đầu vào đó thay vì chạy thử nghiệm.

Bàn làm việc lộn xộn lộn xộn của tôi:

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

Xếp chồng , 24 byte

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

Hãy thử trực tuyến!

Giải trình

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

(được viết thành hai dòng để hiển thị, nhưng mã có thể được viết thành một dòng)

Điều này xác định một macro \blấy đầu vào trong biểu mẫu \b<input>;và in đầu ra muốn vào tài liệu.

Võng mạc , 28 23 byte

cảm ơn @Leo cho -5 byte

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

Hãy thử trực tuyến!

Pyon , 66 byte

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

Hãy thử trực tuyến!

Pyon gần như chỉ là Python, nhưng nó ngắn hơn vì ređược nhập tự động khi bạn sử dụng vàa được tự động đặt thành đối số hoặc đầu vào

-4 byte nhờ ông Xcoder

Python 2 , 100 93 89 byte

-7 cảm ơn Mr.Xcoder

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

R , 121 106 90 byte

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

Hãy thử trực tuyến!

Đã lưu 15 byte bằng cách nhận ra rằng nó rep()sẽ ép thành số. Đã lưu thêm 16 nhờ Giuseppe, chủ yếu từ việc sử dụng pmaxđể thay thế các chuỗi trống bằng1

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

Hãy thử trực tuyến!

Phá vỡ

Thật là một mớ hỗn độn!

Bắt đầu từ $args , đó là một mảng phần tử duy nhất chứa chuỗi RLE, tôi buộc vào một chuỗi thực tế bằng cách gói dấu ngoặc kép.

Sau đó phân chia nó theo ranh giới từ ( \btrong regex). Điều đó sẽ cho tôi một chuỗi các chuỗi, trong đó mỗi phần tử là một số hoặc mã thông báo BF nằm sau số đó. Vì vậy, trong ví dụ này, 4 yếu tố đầu tiên của mảng phân chia này là 10, +]>+>, 3,+> (tất cả đều string).

Tiếp theo, tôi chuyển nó thành ForEach-Object( %) để xử lý từng phần tử .

Giữa là một sân golf PowerShell nổi tiếng, với một twist; về cơ bản, nó là một toán tử ternary DIY, trong đó bạn tạo một mảng 2 phần tử rồi lập chỉ mục cho nó bằng biểu thức boolean mà bạn muốn kiểm tra, theo đó một kết quả sai cung cấp cho bạn phần tử 0 và kết quả đúng cung cấp cho bạn phần tử 1.

Trong trường hợp này, tôi thực sự tạo một mảng phần tử duy nhất với toán tử dấu phẩy đơn ,, vì tôi không muốn đầu ra trong trường hợp thực.

Trước tiên, hãy nhìn vào bộ chỉ mục, mặc dù nó được thực hiện sau.

Ý tưởng của điều này là $_(phần tử hiện tại) có thể là một số hợp lệ hoặc một số chuỗi khác. Nếu đó là một số, tôi muốn $nlà giá trị của số đó trừ đi 1 (dưới dạng một số, không phải là một chuỗi). Nếu không, tôi muốn$n là false-y.

PowerShell thường cố gắng ép giá trị bên phải vào loại bên trái, nhưng nó có thể phụ thuộc vào hoạt động. Ngoài ra, "10"+5sẽ cung cấp cho bạn một chuỗi mới "105", trong khi đó 10+"5"sẽ cung cấp cho bạn một số nguyên ( 15).

Nhưng các chuỗi không thể được trừ để thay vào đó PowerShell có thể tự động suy ra giá trị số bằng một chuỗi ở phía bên trái của phép trừ, do đó "10"-5sẽ cho 5.

VÌ VẬY, tôi bắt đầu với $_-1, nó sẽ cho tôi con số tôi muốn khi $_thực sự là một con số, nhưng khi nó không nhận được gì. Nhìn bề ngoài, "không có gì" là falsey, nhưng vấn đề là dừng thực thi nhiệm vụ đó, vì vậy $nsẽ giữ lại giá trị trước đó của nó; không phải những gì tôi muốn!

Nếu tôi gói nó trong một biểu hiện phụ, thì khi nó thất bại, tôi nhận được giá trị falsey của mình: $($_-1) .

Tất cả được gán cho $nvà vì chính nhiệm vụ đó được gói trong ngoặc đơn, giá trị được gán $ncũng được chuyển qua đường ống dẫn.

Vì tôi đang sử dụng nó trong trình lập chỉ mục và tôi muốn 1nếu việc chuyển đổi thành công, tôi sử dụng hai notbiểu thức boolean !!để chuyển đổi giá trị này thành boolean. Một chuyển đổi số thành công kết thúc là đúng, trong khi hư vô chim ưng cho chúng ta sự ngọt ngào, ngọt ngào0 đó cho phép trả lại yếu tố duy nhất trong mảng ternary giả đó.

Quay trở lại mảng đó, phần tử là thế này: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)

"$($_[0])"- đây là một cách dài khó chịu để có được ký tự đầu tiên của phần tử hiện tại (giả sử, lấy +từ +[>+), nhưng là một chuỗi chứ không phải là một [char]đối tượng. Tôi cần nó là một chuỗi bởi vì tôi có thể nhân một chuỗi với một số để nhân đôi chuỗi đó, nhưng tôi không thể làm điều đó với một ký tự.

Trên thực tế, tôi đã quản lý để lưu 4 ký tự bằng cách sử dụng một [char]mảng thay vì một chuỗi (bằng cách sử dụng một dấu phẩy đơn nguyên khác ,), vì vậy tôi có thể xóa các trích dẫn và biểu thức phụ thêm. Tôi có thể nhân một mảng để nhân đôi các phần tử của nó. Và vì toàn bộ kết quả của lần lặp này cuối cùng vẫn là một mảng và cần phải được chỉnh sửa -join, sử dụng một mảng ở đây không phải trả thêm chi phí.

Sau đó, tôi nhân mảng chuỗi$n đó với số $nlần nhân đôi . Nhớ lại rằng $ncó thể$null hoặc nó có thể là giá trị của các chữ số trước trừ đi một chữ số.

Sau đó +$_thêm phần tử hiện tại vào phần cuối của ký tự đầu tiên được sao chép của phần tử đó. Đó là lý do tại sao $ntrừ đi một.

Bằng cách này, 10+[>+kết thúc $nbằng 9, sau đó chúng tôi tạo 9 +và thêm +[>+chuỗi đó trở lại chuỗi để có được số 10 cần thiết, cộng với các yếu tố đơn lẻ khác cho chuyến đi.

Nguyên tố này được bọc trong một subexpression $()vì khi $nlà $null, toàn bộ biểu hiện thất bại, do đó tạo ra mảng thất bại, vì thế indexer không bao giờ chạy, vì vậy $nkhông bao giờ được giao.

Lý do tôi sử dụng thủ thuật ternary này là vì một trong những đặc thù của nó: không giống như một toán tử ternary thực sự, các biểu thức xác định các phần tử làm được đánh giá hay không mà họ đang "được chọn", và lần đầu tiên cho rằng vấn đề.

Vì tôi cần gán và sau đó sử dụng $ntrên các lần lặp riêng biệt, điều này rất hữu ích. Giá trị phần tử mảng ternary được đánh giá bằng $ngiá trị của lần lặp trước , sau đó bộ chỉ mục gán lại $ncho lần lặp hiện tại.

Nên ForEach-Object vòng lặp kết thúc với tất cả mọi thứ mà nó được cho là (một loạt các lỗi chúng ta bỏ qua), nhưng là một chuỗi các chuỗi mới.

Vì vậy, toàn bộ điều được gói trong ngoặc đơn và trước đó là unary -joinđể đưa ra chuỗi đầu ra.

QuadR , 17 byte

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

Hãy thử trực tuyến!

Cảm ơn Adám đã cung cấp phiên bản chính xác của mã.

Làm thế nào nó hoạt động:

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

Hãy thử trực tuyến!

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

^{Các biểu thức Gdamn} Java đôi khi vô dụng .. Lần trước, nókhông sử dụng nhóm chụp"$1"cho bất cứ thứ gì, bây giờ, tôi muốn thay thế3cbằngccchoặc000cbằngcccmột lớp lót, nhưng tiếc là Java không có cách nào để làm điều này mà không có vòng. À

Giải trình:

Hãy thử nó ở đây.

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

Hãy thử trực tuyến!

Giải trình:

span(`elem`['0'..'9'])schia chuỗi đã cho sthành tiền tố của các chữ số và phần còn lại. Khớp với kết quả trên mẫu (n:m,x:r)đảm bảo rằng tiền tố chữ số không trống và liên kết ký tự sau các chữ số xvà phần còn lại r. x<$[1..read$n:m]đọc chuỗi các chữ số n:mdưới dạng số và lặp lại xnhiều lần. Kết quả được nối với điều trị đệ quy của chuỗi còn lại r.

R , 151 byte

Bị ruồng bỏ bởi người dùng2390246 ! Đây về cơ bản là một cách tiếp cận rác so với phương pháp đó, nhưng tôi sẽ tiếp tục cải thiện nó.

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

Hãy thử trực tuyến!

Cũng đưa ra một loạt các cảnh báo.

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

Tiếp theo, xem nếu sử dụng một grep hiệu quả hơnsubstr

JavaScript (ES6), 46 byte

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

Giải thích khá đơn giả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

Ruby , 35 byte

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

Hãy thử trực tuyến!

Giải nén Lambda , 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))))))

Đầu vào và đầu ra bao gồm các danh sách gấp bên phải các mã ký tự được mã hóa của nhà thờ , ví dụ mã ký tự của một dòng mới là 10 nên mã hóa của nhà thờ sẽ làλf.λx.f(f(f(f(f(f(f(f(f(f x))))))))) . Chuyển đổi "ABCD" thành một danh sách trông giống nhưλf.λx.f 65 (f 66 (f 67 (f 68 x))) nhưng với các số được mã hóa theo nhà thờ.

Áp dụng một chuỗi được mã hóa vào chương trình và giảm tất cả các cách sẽ cung cấp cho bạn một chuỗi đầu ra được mã hóa với RLE được áp dụng.

Funky , 42 byte

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

Hãy thử trực tuyến!

C ++, 239 235 byte

-4 byte nhờ 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;}

Phi tiêu, 78 byte (có regex), 102 byte (không có regex)

Với Regex:

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

Không có 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()

Cả hai phải được gọi như thế (<code here>)("input string").

Regex one khá chuẩn, nhưng regex-less khá đặc biệt.

Regex-less lạm dụng các tham số tùy chọn để phân bổ các biến cục bộ trong hàm "return return", nếu không, bạn cần tạo một khối và có từ khóa return. Đối với mỗi đơn vị mã, nếu đơn vị mã nằm trong khoảng từ 0 đến 9 thì nó được tích lũy nvà một chuỗi trống được trả về. Mặt khác, ký tự được nhân với giá trị của n(cased đặc biệt nếu n == 0, trong trường hợp đó, nó sẽ luôn phát ra 1 ký tự) và nđược đặt thành 0. (n=0*(c=n))+cđặt đối số mã char thành giá trị của n, nhân n/ cvới 0 , lưu trữ 0 đến n, sau đó thêm c. Điều này đặt lại nmà không có trong một bối cảnh tuyên bố.

Python3, 96 byte

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)

Tôi đã thử một triển khai khác trong Python, nhưng tôi không đánh bại /codegolf//a/146923/56846 :(