주어진 문자열의 실행 길이 디코딩을 수행하기 위해 선택한 언어로 가장 짧은 코드를 작성하십시오.

문자열은 stdin 에 입력으로 양식 으로 제공됩니다.

CNCNCNCNCNCNCNCN

여기서 각각 C은 인쇄 가능한 ASCII 문자 일 수 있으며 각 N숫자 1는 9(포함) 의 숫자 입니다.

샘플 입력 :

:144,1'1

해당 출력 :

:4444,'

Brainfuck, 34 자

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

셰익스피어 프로그래밍 언어 , 406 바이트

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Scene II:.
Ford:
Open your mind.Is sky nicer than you?If so, let us return to scene IV.
Ajax:
Open your mind.You is sum you and sum big big big big big big pig and big big big big cat!
Scene III:.
Ford:
Speak thy mind.
Ajax:
You is sum you and pig!Is you as big as zero?If so, let us return to scene II.Let us return to scene III.
Scene IV:.
[Exeunt]

언 골프 버전 :

The Decoding of the Lengths of Veronan Runs - A Drama of PPCG.

Romeo, quite a character.
Juliet, Romeo's lover and multiplicand.

Act I: In which the lengths of runs are decoded.

Scene I: A silent entrance.

[Enter Romeo and Juliet]

Scene II: In which neither Romeo nor Juliet believes the other open-minded.

Juliet:
  Open your mind. Is my mother jollier than thou? If so,
  we must proceed to scene IV.

Romeo:
  Open your mind. Thou art the sum of thyself and the sum of my good aunt and
  the difference between nothing and the quotient of the square of twice the sum
  of thy foul fat-kidneyed goat and thy death and thy evil variable!

Scene III: In which Romeo snaps and brutally insults Juliet.

Juliet:
  Speak thy mind.

Romeo:
  Thou art the sum of thyself and a hog! Art thou as rotten as nothing? If so,
  let us return to scene II. Let us return to scene III.

Scene IV: Finale.

[Exeunt]

내가 사용하고 drsam94의 파이썬 SPL 컴파일러 (예를 들어, 내가 사용하는 이유이며, 몇 가지 버그를 가지고, Open your mind대신 Open thy mindgolfed 버전을).

이 프로그램을 실행하려면 다음을 사용하십시오.

$ python splc.py rld.spl > rld.c
$ gcc rld.c -o rld.exe
$ echo -n ":144,1'1" | ./rld
:4444,'

작동 원리

SPL은 프로그램이 셰익스피어 연극처럼 보이도록 설계된 난해한 프로그래밍 언어입니다. 문자를 변수로 사용하여이를 수행하고 문자가 서로 이야기하도록하여 처리를 수행합니다.

The Decoding of the Lengths of Veronan Runs - A Drama of PPCG.

이것은 연극의 제목입니다. 컴파일러에 의해 무시됩니다.

Romeo, quite a character.
Juliet, Romeo's lover and multiplicand.

여기서 우리는 나머지 프로그램에서 사용 된 변수를 선언합니다. 모든 타협 ,과 .컴파일러에 의해 무시됩니다. 이 경우, 우리 Romeo는 디코딩되고있는 문자를 유지하는 데 사용되는 문자를 선언 하고 문자 Juliet의 실행 길이를 유지하는 데 사용됩니다.

Act I: In which the lengths of runs are decoded.

여기서 우리는 첫 번째로 선언하고 프로그램에서만 행동합니다. 행위와 장면은 레이블과 같습니다. 그것들을 사용 let us return to scene II하거나 그 변종을 사용하여 언제든지 뛰어 넘을 수 있습니다 . 우리는 하나의 행동 만 사용합니다. 왜냐하면 그것은 우리의 필요에 충분하기 때문입니다. 다시 말하지만, 사이 아무 :및 .컴파일러에 의해 무시됩니다.

Scene I: A silent entrance.

여기서 첫 장면을 선언합니다. 장면은 로마 숫자로 번호가 매겨집니다. 첫 번째는 Scene I, 두 번째 Scene II등입니다.

[Enter Romeo and Juliet]

이것은 무대 방향입니다. 여기에서 변수 Romeo와 Juliet변수가 "스테이지"에 오도록 지시합니다. "stage"에는 한 번에 두 개의 변수 만있을 수 있습니다. 이 단계는 컴파일러가 말할 때 어떤 변수가 어떤 변수를 처리하는지 파악할 수 있도록 사용됩니다. 로미오와 줄리엣은 변수가 두 개 밖에 없기 때문에 프로그램 기간 동안 계속 무대에있을 것입니다.

Scene II: In which neither Romeo nor Juliet believes the other open-minded.

또 다른 장면 선언. 또 다른 실행 길이를 디코딩하기 위해 Scene II로 이동합니다.

Juliet:

이 형식의 선언은 Juliet가 말하기 시작한다는 것을 의미합니다. 다음 Romeo:, 무대 방향 또는 장면 / 행위 선언 까지의 모든 내용 은 Juliet가 말한 줄이므로 "me"는 Juliet, "you"/ "thou", Romeo 등을 나타냅니다.

Open your mind.

이 명령은 STDIN의 단일 문자 서수 값을에 저장합니다 Romeo.

Is my mother jollier than thou?

SPL에서 명사는 양수인지 음수인지에 따라 1 또는 -1로 변환됩니다. 이 경우, 1로 my mother번역됩니다. 형용사 (양수 또는 음수)에 명사에 2를 곱합니다.

이것은 질문입니다. my mother거기 에서 Juliet는 (AKA 1)이 Romeo보다 "jollier" 인지 묻습니다 . 비교는 less than(와 같이 음수이면 worse) 또는 greater than(양수이면과 같이 jollier)으로 해석됩니다 . 따라서이 질문은로 요약됩니다 Is 1 greater than you?.

이 질문을하는 이유는 입력의 끝을 감지하기 위해서입니다. 의 값은 EOF플랫폼마다 다르지만 일반적으로 1보다 작으므로이를 사용하여 감지합니다.

If so, we must proceed to scene IV.

앞의 질문이로 평가되면 true장면 IV로 넘어갑니다. 이는 단순히 프로그램의 끝입니다. 즉, EOF를 감지하면 프로그램을 종료합니다.

Romeo:

이제 "로미오"와 "당신"은 로미오의 줄입니다. 각각 로미오와 줄리엣을 말합니다.

Open your mind.

다시,이 문장은 STDIN에서 단일 문자의 서수 값을 Juliet에 넣습니다.이 경우에는에 저장된 문자의 실행 길이입니다 Romeo.

Thou art the sum of thyself and the sum of my good aunt and the difference 
between nothing and the quotient of the square of twice the sum of thy foul
fat-kidneyed goat and thy death and thy evil variable!

너무 길어서 자세히 설명하기는 어렵지만을 번역한다는 점을 신뢰하십시오 Juliet -= 48. Juliet는 숫자의 ASCII 값을 보유하기 때문에이 작업을 수행합니다 ord('0') == 48. 48을 빼면 숫자의 ASCII 값에서 숫자 자체로 변환됩니다.

Scene III: In which Romeo snaps and brutally insults Juliet.

또 다른 장면 선언. 이것은 우리가 반복적으로의 문자 값 인쇄하는 루프입니다 Romeo, Juliet시간을.

Juliet:
  Speak thy mind.

이 진술은 로미오가 자신의 가치를 인물로 인쇄하게한다. 즉, 이전에 Romeo에 저장된 문자 값이 출력됩니다.

Romeo:
  Thou art the sum of thyself and a hog!

돼지는 음수이므로 a hog-1로 변환됩니다. 따라서이 문장은로 평가됩니다 Juliet -= 1.

Art thou as rotten as nothing?

로미오는 여기서 줄리엣이 "썩은 것처럼"또는 0과 같은지 묻습니다.

If so, let us return to scene II.

Juliet의 값이 0이면 다른 캐릭터의 길이를 디코딩하기 위해 scene II로 되돌아갑니다.

Let us return to scene III.

그렇지 않으면, 우리는 로미오의 캐릭터를 다시 출력하기 위해 장면 III으로 되돌아갑니다.

Scene IV: Finale.

[Exeunt]

이 마지막 장면 선언은 프로그램의 끝을 나타내는 표시 일뿐입니다. [Exeunt]단계 방향은 실제로 마지막 장면을 생성하는 컴파일러를 얻을 필요가있다.

GolfScript, 10 자

2/{1/~~*}/

펄, 27 자

print<>=~s/(.)(.)/$1x$2/ger

R 67

x=strsplit(readline(),"")[[1]];cat(rep(x[c(T,F)],x[c(F,T)]),sep="")

파이썬 3, 52

Python 3을 사용하면 두 python2 솔루션의 접근 방식을 병합 할 수 있습니다.

s=input()
t=''
while s:a,b,*s=s;t+=a*int(b)
print(t)

APL (22)

,/{⍺/⍨⍎⍵}/↑T⊂⍨~⎕D∊⍨T←⍞

설명:

• T←⍞: 입력 저장 T
• T⊂⍨~⎕D∊⍨T: 분할 T 숫자가 아닌 문자로
• ↑하십시오로 돌려 2-by- N/2행렬
• {⍺/⍨⍎⍵}/: 행렬의 각 행 /( /)에서 첫 번째 문자 ( ⍺)를 eval (⍎ 두 번째 문자 ( ⍵) ) ( )
• ,/: 각 행의 출력을 연결

루비, 30 바이트

gsub!(/(.)(.)/){$1*$2.to_i}

27 바이트 코드 + 3 바이트를 -p플래그 와 함께 실행합니다 .

$ ruby -p rld.rb <<< ":144,1'1"
:4444,'

8086 어셈블리, 106 98 자

l:
mov ah,8
int 21h
mov bl,al
int 21h
sub al,48
mov cl,al
xor ch,ch
mov al,bl
mov ah,14
p:
int 10h
loop p
jmp l

입력 스트림에서 문자 앞에 숫자가 있으면 두 줄 (18 자)이 제거 될 수 있습니다.

GNU SED, 122 + 2 (-r)

#n
s/.*/\n&\a987654321\v\v\v\v\v\v\v\v\v/
:a
s/\n(.)(.)(.*\a.*\2.{9}(.*))/\1\n\4\3/
tb
bc
:b
s/(.)\n\v/\1\1\n/
tb
ba
:c
P

으로 실행해야 -r플래그를
대체하여 110 + 2로 줄일 수있다 \v인쇄 할 수없는과 0x0B와 \a와0x07

C, 65 자

입력을 매개 변수로 가져옵니다.

main(p,v)char*p,**v;{
    for(p=v[1];*p;--p[1]<49?p+=2:0)putchar(*p);
}

펄, 19 18 자

perl -pe 's/(.)(.)/$1x$2/ge'

명령 줄에서 스위치를 계산하는 규칙은 다음 과 같습니다 .

넷째, 45 자

BEGIN KEY KEY 48 - 0 DO DUP EMIT LOOP 0 UNTIL

OS X에서 pforth로 테스트되었습니다.

파이썬, 63 62 자

print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])

Windows PowerShell, 55 자

-join((read-host)-split'(..)'|%{(""+$_[0])*(""+$_[1])})

나는 이것이 char에서 string 및 int 로의 캐스트로 더 골프화 될 수 있다는 느낌을 얻지 만 지금 당장 계속 노력할 시간이 없습니다.

C, 68 자

C에서 @ugoren의 대답은 약간 짧지만이 대답은 "문자열이 stdin에 입력으로 제공됩니다"라는 요구 사항을 준수합니다 .

n;main(c){for(;;){c=getchar(),n=getchar()-48;while(n--)putchar(c);}}

하스켈, 58 56 자

f[]=[]
f(x:y:s)=replicate(read[y])x++f s
main=interact$f

골프를 치기위한 첫 번째 시도이므로 여기에서 약간의 개선이있을 것입니다.

apt -P , 8 바이트

문자 배열로 입력하고 문자열로 출력합니다.

ò crÈpY°

시도 해봐

ò crÈpYn     :Implicit input of character array
ò            :Groups of 2
   r         :Reduce each pair
    È        :By passing them through the following function as [X,Y]
     p       :  Repeat X
      Yn     :    Y, converted to an integer, times
             :Implicitly join and output

Malbolge Unshackled (20 트릿 회전 변형), 4,494e6 바이트

이 답변의 크기는 게시 가능한 최대 프로그램 크기 (eh)를 초과하므로 코드는 내 GitHub 리포지토리에 있습니다.

이것을 실행하는 방법?

순진한 Haskell 통역사가 이것을 실행하기 위해 나이가 들기 때문에 이것은 까다로운 부분 일 수 있습니다. TIO는 괜찮은 Malbogle Unshackled 통역사가 있지만 슬프게도 사용할 수 없습니다 (제한 사항).

내가 찾을 수있는 가장 좋은 방법 은 시간당 360 바이트의 압축을 풀고 매우 잘 수행되는 고정 된 20 트 라이트 회전 폭 변형 입니다.

인터프리터를 좀 더 빠르게 만들기 위해 Matthias Lutter의 Malbolge Unshackled 인터프리터에서 모든 검사를 제거했습니다.

수정 된 버전은 약 6,3 % 더 빠르게 실행될 수 있습니다.

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

작동합니다!

05AB1E , 6 5 바이트

2ι`ÅΓ

덕분에 -1 바이트 @Grimy .

문자 목록으로 출력합니다.

온라인으로 사용해보십시오.

이전 6 바이트는 내장 된 런타임 디코딩없이 응답합니다.

2ôε`×?

온라인으로 사용해보십시오.

설명:

2ι      # Uninterleave the (implicit) input-string in two parts
        #  i.e. ":144,1'3" → [":4,'","1413"]
  `     # Push both separated to the stack
   ÅΓ   # Run-length decode
        #  i.e. ":4,'" and "1413" → [":","4","4","4","4",",","'","'","'"]
        # (after which the result is output implicitly)

2ô      # Split the (implicit) input-string into parts of size 2
        #  i.e. ":144,1'3" → [":1","44",",1","'3"]
  ε     # Loop over each of these pairs:
   `    #  Push both characters separated to the stack
    ×   #  Repeat the first character the digit amount of times as string
        #   i.e. "'" and "3" → "'''"
     ?  #  And print it without trailing newline

파이썬, 78 72 66 문자

d = raw_input ()
print "". join ([x * int (d [i + 1]), i, x의 경우 열거 형 (d) if ~ i & 1])

s = raw_input ()
print "". join (i에서 j의 zip (s [:: 2], s [1 :: 2])의 i * int (j))

GolfScript (10 자)

2/{)15&*}/

J-24

;@(_2(<@#~".)/\])@1!:1 3

이 제출의 요점은 접사 부사를 사용하는 것입니다.

Befunge, 49 자

>~:25*-      v
$>\1-:v:-*68~_@
$^ ,:\_v
^      <

K, 35

{,/(#).'|:'"*I"$/:(2*!-_-(#x)%2)_x}

파이썬 2, 58

이것은 대런 스톤 (Darren Stone)의 파이썬 솔루션, 반복자 남용에서 영감을 얻은 것입니다!

x=iter(raw_input())
print''.join(a*int(next(x))for a in x)

이것은 내 원래 솔루션입니다 (60 자)

s=raw_input()
t=''
while s:t+=s[0]*int(s[1]);s=s[2:]
print t

다른 접근 방식은 3 자 더 깁니다.

f=lambda a,b,*x:a*int(b)+(x and f(*x)or'')
print f(raw_input())

자바 : 285 자

import java.util.Scanner;public class A{public static void main(String args[]){Scanner s = new Scanner(System.in);while(s.hasNext()){String t=s.next();for(int i=0;i<t.length();i++) {for(int j=0; j<(Byte.valueOf(t.substring(i+1,i+2)));j++){System.out.print(t.substring(i,i+1));}i++;}}}}

Befunge-98, 22 자

>#@~~"0"-v
^#:\,:\-1<_

공백, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(S, T, L을 Space, Tab, Linefeed 문자로 바꿉니다.)

온라인으로 사용해보십시오 [여기] .

설명:

"assembly"      whitespace                                      stack
----------      ----------                                      -----
s:              LSS SL      ;input loop                         []
    push 0      SS SSL                                          [0]
    dup         SLS                                             [0,0]
    getc        TLTS        ;input & store char c               [0]
    rcl         TTT         ;recall c                           [c]
    dup         SLS                                             [c,c]
    push 16     SS STSSSSL                                      [c,c,16]
    sub         TSST                                            [c,c-16]
    jlt  tt     LTT TTL     ;exit if ord(c) < 16                [c]       
    push 0      SS SSL                                          [c,0]
    dup         SLS                                             [c,0,0]
    getc        TLTS        ;input & store char n               [c,0]
    rcl         TTT         ;recall n                           [c,n]
    push 48     SS STTSSSSL ;convert n to m = ord(n)-ord('0')   [c,n,48]
    sub         TSST                                            [c,m]

ss:             LSS SSL     ;inner loop outputs c, m times      [c,m]
    dup         SLS                                             [c,m,m]
    jeq  t      LTS TL      ;if m==0, stop outputting this c    [c,m]
    push 1      SS STL      ;otherwise decr m                   [c,m,1]
    sub         TSST                                            [c,m-1]
    copy 1      STS STL     ;copy c to tos                      [c,m-1,c]
    putc        TLSS        ;output this c                      [c,m-1]
    jmp  ss     LSL SSL     ;loop back to output this c again   [c,m-1]

t:              LSS TL                                          [c,m]
    pop         SLL                                             [c]
    pop         SLL                                             []
    jmp  s      LSL SL      ;loop back to get the next c,n      []

tt:             LSS TTL                                         [c]
    end         LLL         ;exit

클로저 (107)

(pr(apply str(map #(apply str(repeat(Integer/parseInt(str(second %)))(first %)))(partition 2(read-line)))))

Clojure가되기에 너무 오래 걸린다고 생각합니다. 누군가 더 잘할 수 있다면 게시하십시오.