Napisz najkrótszy kod w wybranym języku, aby wykonać dekodowanie długości ciągu danego ciągu.

Ciąg zostanie dostarczony jako wejście na stdin w formie

CNCNCNCNCNCNCNCN

gdzie każdy Cmoże być dowolnym drukowalnym znakiem ASCII, a każdy Njest cyfrą 1na 9(włącznie).

Przykładowe dane wejściowe:

:144,1'1

Odpowiednia wydajność:

:4444,'

Brainfuck, 34 znaki

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

Język programowania Szekspira , 406 bajtów

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

Wersja bez golfa:

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]

Używam kompilatora Pythona SPL drsam94 , który ma kilka błędów (dlatego na przykład używamOpen your mind zamiast Open thy mindw wersji golfowej).

Aby uruchomić ten program, użyj:

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

Jak to działa

SPL to ezoteryczny język programowania zaprojektowany tak, aby programy wyglądały jak sztuki Szekspira. Robi to za pomocą znaków jako zmiennych, a przetwarzanie odbywa się poprzez to, że znaki mówią sobie nawzajem.

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

To jest tytuł sztuki; jest ignorowany przez kompilator.

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

Tutaj deklarujemy zmienne używane w pozostałej części programu. Wszystko pomiędzy ,i .jest ignorowane przez kompilator. W tym przypadku deklarujemy Romeo, używane do przechowywania dekodowanej postaci, i Julietużywane do przechowywania długości przebiegu znaku.

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

Tutaj deklarujemy pierwszy i jedyny akt w programie. Akty i sceny są jak etykiety; można do nich wskoczyć w dowolnym momencie za pomocą let us return to scene IIlub jakiejś jego wariantu. Używamy tylko jednego aktu, ponieważ jest on wystarczający dla naszych potrzeb. Ponownie, wszystko pomiędzy :i .jest ignorowane przez kompilator.

Scene I: A silent entrance.

Tutaj ogłaszamy pierwszą scenę. Sceny są ponumerowane cyframi rzymskimi: pierwsza to Scene Idruga Scene IIi tak dalej.

[Enter Romeo and Juliet]

To jest kierunek sceny; w nim mówimy zmiennym Romeoi Juliet, aby przyszły na „etap”. Tylko dwie zmienne mogą znajdować się jednocześnie na „scenie”; etap jest używany, aby kompilator mógł dowiedzieć się, która zmienna jest adresowana, a kiedy mówi. Ponieważ mamy tylko dwie zmienne, Romeo i Julia pozostaną na scenie przez cały czas trwania programu.

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

Kolejna deklaracja sceny. Scena II zostanie przeskoczona w celu odkodowania kolejnego przebiegu.

Juliet:

Ta forma deklaracji oznacza, że ​​Juliet zacznie mówić. Wszystko do następnego Romeo:, reżyserii scenicznej lub deklaracji sceny / aktu będzie wierszem wypowiedzianym przez Juliet, a zatem „ja” będzie odnosić się do Julii, „ty” / „ty” do Romeo itp.

Open your mind.

To polecenie przechowuje wartość porządkową pojedynczego znaku z STDIN w Romeo.

Is my mother jollier than thou?

W języku SPL rzeczowniki tłumaczą się na 1 lub -1 w zależności od tego, czy są dodatnie czy ujemne. W tym przypadku my mothertłumaczy się na 1. Przymiotniki (dodatnie lub ujemne) mnożą ich rzeczownik przez 2.

To jest pytanie; w tym Juliet pyta, czy my mother(AKA 1) jest „bardziej wesoły” niż Romeo. Porównania tłumaczą się na less than(jeśli są negatywne, jak worse) lub greater than(jeśli są pozytywne, jak jollier). Dlatego pytanie sprowadza się do Is 1 greater than you?.

Powodem, dla którego zadajemy to pytanie, jest wykrycie końca danych wejściowych. Ponieważ wartość EOFróżni się w zależności od platformy, ale zwykle jest mniejsza niż 1, używamy tego do jej wykrycia.

If so, we must proceed to scene IV.

Jeśli poprzednie pytanie zostanie ocenione true, przejdziemy do sceny IV - która jest po prostu końcem programu. Krótko mówiąc, jeśli wykryjemy EOF, kończymy program.

Romeo:

Teraz linia Romeo: „ja” i „ty” odnoszą się odpowiednio do Romea i Julii.

Open your mind.

Ponownie, to polecenie umieszcza wartość porządkową pojedynczego znaku z STDIN w Juliet, która w tym przypadku jest długością przebiegu znaku zapisanego w 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!

Ten jest zbyt długi, aby przejść do niego bardzo szczegółowo, ale zaufaj mi, że to się tłumaczy Juliet -= 48. Robimy to, ponieważ Juliet posiada wartość ASCII liczby, oraz ord('0') == 48; odejmując 48, tłumaczymy z wartości ASCII liczby na samą liczbę.

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

Kolejna deklaracja sceny. Ten jest dla pętli, w której wielokrotnie drukujemy wartość znaku Romeo, Julietrazy.

Juliet:
  Speak thy mind.

To stwierdzenie powoduje, że Romeo wypisuje swoją wartość jako postać; to znaczy, dowolna wartość znaku wcześniej zapisana w Romeo jest teraz wyprowadzana.

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

Wieprz jest rzeczownikiem przeczącym, więc a hogtłumaczy się na -1; dlatego oświadczenie to ocenia Juliet -= 1.

Art thou as rotten as nothing?

Romeo pyta, czy Julia jest „tak zepsuta jak”, czy równa 0.

If so, let us return to scene II.

Jeśli wartość Juliet wynosi 0, wracamy do sceny II, aby dekodować długość przebiegu innej postaci.

Let us return to scene III.

W przeciwnym razie powrócimy do sceny III, aby ponownie przedstawić postać Romea.

Scene IV: Finale.

[Exeunt]

Ta ostateczna deklaracja sceny jest tylko znacznikiem końca programu. [Exeunt]Kierunek etap jest konieczny, aby uzyskać kompilator faktycznie generuje ostateczną scenę.

GolfScript, 10 znaków

2/{1/~~*}/

perl, 27 znaków

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

R 67

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

Python 3, 52

Python 3 pozwala mi łączyć podejścia moich dwóch rozwiązań python2.

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

APL (22)

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

Wyjaśnienie:

• T←⍞: zapisz dane wejściowe w T
• T⊂⍨~⎕D∊⍨T: podział Tna znaki, które nie są cyframi
• ↑: 2zamień w N/2macierz
• {⍺/⍨⍎⍵}/: w każdym wierszu macierzy ( /) powtórz ( /) pierwszy znak ( ⍺) przez eval ( ⍎) drugiego znaku ( ⍵)
• ,/: konkatenuje dane wyjściowe każdego wiersza

Rubinowy, 30 bajtów

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

Kod 27 bajtów + 3 bajty, aby uruchomić go z -pflagą:

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

Zestaw 8086, 106 98 znaków

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

Gdyby liczby znajdowały się przed znakami w strumieniu wejściowym, można by z tego wygolić dwie linie (18 znaków).

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

Musi być uruchomiony z -rflagą
może być zmniejszona do 110 + 2, zastępując \vz niecenzuralny 0x0Bi \aze0x07

C, 65 znaków

Pobiera dane wejściowe jako parametr.

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

Perl, 19 18 znaków

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

Zasady liczenia przełączników w wierszu poleceń znajdują się tutaj .

Dalej, 45 znaków

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

Testowane z pforth na OS X.

Python, 63 62 znaków

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

Windows PowerShell, 55 znaków

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

Mam wrażenie, że można to bardziej pograć w golfa, szczególnie w obsadach od char do string i int, ale nie mam teraz czasu, aby nad tym popracować.

C, 68 znaków

Odpowiedź @ ugorena w C jest nieco krótsza, ale ta odpowiedź jest zgodna z wymogiem, że „ciąg będzie dostarczany jako wejście na standardowe wejście ”.

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

Haskell, 58 56 znaków

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

Moja pierwsza prawdziwa próba gry w golfa, więc prawdopodobnie jest tu coś do zrobienia.

Japt -P , 8 bajtów

Dane wejściowe jako tablica znaków, dane wyjściowe jako ciąg znaków.

ò crÈpY°

Spróbuj

ò 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 (wariant rotacji 20-trytów), 4 494e6 bajtów

Rozmiar tej odpowiedzi przekracza maksymalny rozmiar programu do wysłania (eh), więc kod to się w moim repozytorium GitHub .

Jak to uruchomić?

Może to być trudna część, ponieważ naiwny tłumacz Haskell będzie potrzebował wieków, aby to uruchomić. TIO ma przyzwoitego tłumacza Malbogle Unshackled, ale niestety nie będę mógł go używać (ograniczenia).

Najlepszy, jaki udało mi się znaleźć, to stały wariant szerokości rotacji 20 trytów, który działa bardzo dobrze, dekompresując 360 bajtów na godzinę .

Aby nieco przyspieszyć tłumacza, usunąłem wszystkie kontrole z nieskrępowanego tłumacza Matthiasa Luttera.

Moja zmodyfikowana wersja może działać o około 6,3% szybciej.

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

To działa!

05AB1E , 6 5 bajtów

2ι`ÅΓ

-1 bajt dzięki @Grimy .

Wyjście jako lista znaków.

Wypróbuj online.

Stare 6 bajtów odpowiedzi bez wbudowanego dekodowania długości przebiegu:

2ôε`×?

Wypróbuj online.

Wyjaśnienie:

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

Python, 78 72 66 znaków

d = raw_input ()
print "". join ([x * int (d [i + 1]) for i, x in enumerate (d) if ~ i & 1])

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

GolfScript (10 znaków)

2/{)15&*}/

J - 24

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

Celem tego przesłania jest użycie przysłówka infix.

Befunge, 49 znaków

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

K, 35

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

Python 2, 58

Jest to inspirowane pythonowym rozwiązaniem Darrena Stone'a - nadużyciami iteratora!

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

To jest moje oryginalne rozwiązanie (60 znaków)

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

Inne podejście jest dłuższe o 3 znaki:

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

Java: 285 znaków

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 znaki

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

Biała spacja, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Zamień S, T, L na spację, tabulację, znak linii.)

Wypróbuj online [tutaj] .

Wyjaśnienie:

"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

Clojure (107)

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

To wyjątkowo długo jest byciem Clojure, jeśli ktoś może zrobić lepiej, opublikuj to.