고전적인 실행 길이 인코딩 및 디코딩이 있습니다.

input   output
a3b2c5  aaabbccccc

그리고 그것은 매우 직설적이고 전에 이루어졌습니다.

여러 문자가 실행 길이 앞에 오는 경우 비표준 동작을 고려해야합니다 ( 0-9 의 단일 숫자). 실행 길이 자리 앞의 각 문자 (숫자가 아닌 또는 문자열의 끝 앞의 마지막 자리)에는 해당 값이 개별적으로 적용 되어 순서대로 인쇄됩니다.

일부 에지 케이스를 포함한 일부 테스트 입력 및 출력 :

input   output
ab3c5   aaabbbccccc
a0b3    bbb  
13b1    111b
a13b1   aaa111b
a123b1  aaa111222b
aa2a1b1 aaaaab

• 문자 시퀀스 ( [a-zA-Z0-9]+) 뒤에는 실행 길이 길이 ( [0-9]) 가 와야합니다.
• 유효한 입력 만 고려하면됩니다 ( ([a-zA-Z0-9]+[0-9])*).
  • 예, 빈 문자열은 유효한 입력입니다.
• 표준 입력을 통한 입력, 표준 출력을 통한 출력

이것은 코드 골프이며 바이트 수는 승자를 결정합니다.

핍, 22 + 1 = 23 바이트

-r플래그를 사용합니다 . 이를 위해서는 1) 입력 후 EOF를 입력 (Linux의 경우 Ctrl-D, Windows의 경우 Ctrl-Z)하거나 2) 다른 곳에서 입력을 파이프해야합니다.

(^_@<v)X_@vMa@`\D*\d+`

설명:

                        a is first line of stdin (from -r flag) and v is -1 (implicit)
              `\D*\d+`  Pattern (regex) object that matches zero or more non-digits
                        followed by at least one digit
            a@          Find all non-overlapping matches in a, returning a list of strings
           M            To that list, map a lambda function:
  _@<v                    Argument sans last character (equivalent to Python a[:-1])
(^    )                   Split into a list of characters
        _@v               Last character of argument
       X                  Repeat each character of the list that many times
                          (String multiplication X, like most operators, works item-wise
                          on lists)
                        Auto-print (implicit)

맵 작업의 결과는 실제로 목록의 목록이지만 기본적으로 목록은 인쇄 될 때 함께 연결되므로 문자열로 수동 변환 할 필요가 없습니다.

예를 들어, 입력 a13b1:

Var a gets        "a13b1"
After regex match  ["a13" "b1"]
After map          [["aaa" "111"] ["b"]]
Final output       aaa111b

Pip은 2 일 전에 기본 정규식 지원을 제공 합니다. 좋은 타이밍!

펄 / 배쉬 54 40 + 1 = 41 바이트

perl -pe's:(\D*\d*)(\d):"\$1=~s/./\$&x$2/egr":ege'

기본적으로 정규 표현식 내의 정규 표현식입니다. 그리고 약간의 마술.

설명

외부 정규식 /(\D*\d*)(\d)/g은 각 실행 길이 인코딩 그룹을 추출합니다. 반복 할 내용 $1과의 반복 횟수 를 캡처합니다 $2. 이제 우리는 그러한 각 그룹을 해당 그룹의 확장으로 대체합니다. 이를 위해 코드를 "\$1=~s/./\$&x$2/egr" 두 번 평가합니다 ( /ee외부 대체 의 플래그로).

첫 번째 평가는 문자열에 반복 횟수 만 보간합니다. 다른 변수는 백 슬래시로 보호됩니다. 입력을 가정하면 a14이제 코드 $1=~s/./$&x4/egr가 생겨 다시 평가됩니다.

이것은 $1(반복 할 내용)의 내용에 대체를 적용합니다 a1. 대체는 각 문자와 일치. . $&변수는 우리가 반복 전체 경기, 보유 x4번. /g각 일치 항목에 대해 전역 적으로이 작업을 수행 /r하고 $1변수 (읽기 전용)를 수정하지 않고 대체 된 문자열을 반환합니다 . 따라서 내부 치환의 결과는 aaaa1111입니다.

-p플래그는 각 입력 라인에 치환을 적용하고 그 결과를 출력한다.

CJam, 33 31 27 바이트

어, 정규 표현식이 없으면이게 꽤 길어요 ...

qN+{:XA,s&L\:L>{])~e*[}&X}%

작동 원리

우리는 입력 문자열의 모든 문자를 반복하고 각 반복에서 마지막으로 발생한 문자를 추적합니다 (처음으로 빈 문자로 시작). 그런 다음 현재 문자가 숫자가 아닌지 확인합니다 하고 마지막 문자가 숫자입니다. 그렇다면, 우리는 이전의 각 문자를 반복합니다 (이미 반복되지 않은).

(약간 오래된 코드 확장)

q{                       }%        e# Read the input (q) and loop through each character
  L                                e# Put variable L (initially empty character) on stack
   A,                              e# Put variable A (equals 10) and create an array 0..9
     s                             e# Convert the array to string "0123456789"
      &                            e# Do a set intersect b/w previous char and 0-9 string
                                   e# If numeric, it gives 1 char string, otherwise 0
       \:LA,s&                     e# Swap to bring current character on top. Store it in L
                                   e# and do the same set intersect with it
              >                    e# Means we are checking that current char is non-numeric
                                   e# and previous numeric
               {      }&           e# Run this block if above is true
                ])~                e# Wrap everything not already repeated in an array and
                                   e# take out the last character and convert it to integer.
                                   e# This is the run length of the preceding string
                   e*              e# Repeat each character in the string, run length times
                     [             e# Start a new array to help when next run length is found
                        L          e# Restore the current character back on stack to be used
                                   e# in next iteration
                           )~e*    e# The last string-run-length pair is not decoded..
                                   e# So we do that now

여기에서 온라인으로 사용해보십시오

rs , 43 71 문자

글쎄, 이것은 빠르게 길어졌다. 바보 같은 숫자 ...

(\d)(\D)/\1 \2
+(\w)(\w+?)(\d)(?= |$)/\1\3 \2\3
(\w)(\d)/(\1)^^(\2)
 /

여기 사용해보십시오!

원본 버전 (와 같은 입력에서는 작동하지 않음 123) :

+(\D)(\D+)(\d)/\1\3\2\3
(\D)(\d)/(\1)^^(\2)

설명

첫 번째 줄은 숫자가 포함 된 런 사이에 공백을 배치합니다 (예 :로 a313전환) a3 13.

두번째 라인은 연속적으로 같은 압축 인코딩을 확장 aa5하는a5a5 .

세 번째 줄 은 반복 연산자a5 를 aaaaa사용하여 모든 인스턴스를 .

마지막 줄은 공백을 제거합니다.

자바 스크립트 ( ES6 ), 86 83 바이트

alert(prompt().replace(/(.+?)(\d)(?!\d)/g,(a,b,c)=>b.replace(/./g,y=>y.repeat(c))))

댓글 :

alert( // output final result
    prompt(). // take input
    replace(/(.+?)(\d)(?!\d)/g, // replace ungreedy capture group of any characters 
                                // followed by a digit (captured)
                                // and not followed by a digit (negative lookahead)
        (a, b, c)=> // replace with a function
            b.replace(/./g, // replace all characters in b
                y=>y.repeat(c) // with that character repeated c times
            )
    )
)

CJam, 27 25 바이트

r_'A+1>.{64&1$>{])~f*o}&}

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

r_                        e# Read a token from STDIN and push a copy.
  'A+                     e# Append the character A to the copy.
     1>                   e# Discard the first character of the copy.
       .{               } e# For each character C of the input string and the
                          e# corresponding character D of the copy:
         64&              e#   Take the bitwise and of D and 64. This pushes @
                          e#   if D is a letter and NUL if it is a digit.
            1$>           e#   Compare the result to a copy of C. This pushes 1
                          e#   if and only if D is a letter and C is a digit.
               {      }&  e#   If the result was 1, do the following:
                ]         e#     Wrap the stack in an array.
                 )~       e#     Pop and evaluate the last character.
                   f*     e#     Repeat each char in the array that many times.
                     o    e#     Print all characters.

Pyth, 33 32 28 바이트

ssmm*vedkPdPcz-hMJf<@zT\=UzJ

온라인으로 사용해보십시오 : 데모 또는 테스트 장치

설명

input 예제를 사용하여 코드를 설명하겠습니다 aa1a23b2. 바라건대 이것이없는 것보다 따라 가기가 더 쉽습니다.

                               implicit: z = input string = 'aa1a23b2'
                         Uz    the indices of z: [0, 1, 2, 4, 5, 6, 7]
                  f            filter for indices T, which satisfy:
                   <@zT\=        z[T] < "="
                               this gives us the list of indices [2, 4, 5, 7], 
                               which correspond to digits in z. 
                 J             assignment, J = [2, 4, 5, 7]
               hMJ             increment all element in J: [3, 5, 6, 8]
              -            J   and remove the elements of J:
                                 [3, 5, 6, 8] - [2, 4, 5, 7] = [3, 6, 8]
            cz                 split z at these indices: ['aa1', 'a23', 'b2', '']
           P                   remove last element: ['aa1', 'a23', 'b2']
  m                            map each string d to:
   m     Pd                      map each string k of d-without-last-char to:
     ved                           int(last element of d)
    *   k                          * k
                               this creates [['a', 'a'], ['aaa', '222'], ['bb']]
 s                             sum the lists: ['a', 'a', 'aaa', '222', 'bb']
s                              sum the strings: 'aaaaa222bb'

루비 73

gets.split(/(\d)(?!\d)/).each_slice(2){|s,i|s.chars.map{|c|$><<c*i.to_i}}

테스트 : http://ideone.com/L1fssb

자바 스크립트 112

alert(prompt().replace(/.*?\d+/g,function(m){for(i=n=m.length-1,o="";i--;){j=m[n];while(j--)o=m[i]+o}return o}))

파이썬 2.7, 98 바이트

import re
print"".join(c*int(m[-1])for m in 
re.findall(r".+?\d(?!\d)",raw_input())for c in m[:-1])

이것은 뒤에 숫자가없는 숫자에 대한 간단한 정규식 검색을 수행 한 다음 각 그룹에서 문자열 산술을 수행하고 다시 결합합니다.

줄리아, 105 99 95 87 바이트

s->join([join([string(b)^(int(p[end])-48)for b=chop(p)])for p=matchall(r"\D*\d*\d",s)])

이것은 문자열을 입력으로 받아 문자열을 반환하는 명명되지 않은 함수를 만듭니다. 호출하려면 이름을 지정하십시오 (예 :) f=s->....

여기에는 두 개의 배열 이해가 사용되는데, 하나는 다른 것 안에 중첩되어 있습니다. 외부 이해는 정규식에 대한 입력 문자열의 각 일치에 작용합니다.\D*\d*\d . 내부 이해는 후행 숫자에 따라 일치하는 각 문자를 반복합니다. 내부 배열의 요소는 문자열로 결합되므로 외부 배열은 문자열 배열입니다. 이들은 결합되어 반환됩니다.

Julia에서는 문자열을 문자 배열처럼 취급 할 수 있습니다. 그러나 Julia 의 Char및 String유형에는 동일한 메소드가 정의되어 있지 않습니다. 특히, ^문자를 사용하여 반복하는 방법은 없습니다 . 이것은 복잡한 해결 방법을 사용합니다.

• 을 사용하여 제거 된 마지막 문자를 생략 한 문자열을 반복합니다 chop().
• 다음을 사용하여 현재 문자를 문자열로 변환 string() .
• 문자 인 후행 숫자를 정수로 변환하십시오. 그러나 예를 들어 int('4')4를 반환하지 않습니다. 오히려이 경우 코드 포인트 (이 경우 52)를 반환합니다. 따라서 48을 빼서 실제 정수를 다시 얻을 수 있습니다.
• string(b)에 따라 반복하십시오 int(p[end]) - 48.

예 :

julia> f("ab3c5")
"aaabbbccccc"

julia> f("a0b3")
"bbb"

julia> f("13b1")
"111b"

파이썬 3 148 144 136 135 바이트

w,o,r,d=''.join,'',[],[]
for c in input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print(o)

제안을 해준 Pietu1998과 mbomb007에게 감사합니다.

파이썬 2 161 151 147 139 138 바이트

어쩌면 오늘은 직장에서 긴 하루를 보냈을지 모르지만, 저는 인생에서 골프를하는 방법을 알 수 없습니다 ..

w,o,r,d=''.join,'',[],[]
for c in raw_input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print o

자바 7, 175 바이트

String c(String s){String r="",a[];for(String x:s.split("(?<=(\\d)(?!\\d))")){a=x.split("");for(int i=0,j,l=a.length-1;i<l;i++)for(j=0;j++<new Short(a[l]);r+=a[i]);}return r;}

도전은보기보다 어렵습니다.

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(String s){
    String r = "",
           a[];
    for(String x : s.split("(?<=(\\d)(?!\\d))")){
      a = x.split("");
      for(int i = 0, j, l = a.length-1; i < l; i++){
        for(j = 0; j++ < new Short(a[l]); r += a[i]);
      }
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("ab3c5"));
    System.out.println(c("a0b3"));
    System.out.println(c("13b1"));
    System.out.println(c("a13b1"));
    System.out.println(c("a123b1"));
    System.out.println(c("aa2a1b1"));
    System.out.println(c("123"));
  }
}

산출:

aaabbbccccc
bbb
111b
aaa111b
aaa111222b
aaaaab
111222