Schreiben Sie den kürzesten Code in der Sprache Ihrer Wahl, um die Lauflängendekodierung der angegebenen Zeichenfolge durchzuführen.

Die Zeichenfolge wird als Eingabe für stdin im Formular bereitgestellt

CNCNCNCNCNCNCNCN

wobei jedes Cbeliebige druckbare ASCII-Zeichen sein kann und jedes Neine Ziffer 1bis 9(einschließlich) ist.

Beispieleingabe:

:144,1'1

Entsprechende Ausgabe:

:4444,'

Brainfuck, 34 Zeichen

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

Shakespeare-Programmiersprache , 406 Bytes

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

Ungolfed-Version:

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]

Ich verwende den Python-SPL-Compiler von drsam94 , der einige Fehler aufweist (weshalb ich ihn beispielsweise Open your mindanstelle Open thy mindder Golfversion verwende).

Um dieses Programm auszuführen, verwenden Sie:

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

Wie es funktioniert

SPL ist eine esoterische Programmiersprache, mit der Programme wie Shakespeare-Stücke aussehen. Dabei werden Zeichen als Variablen verwendet, und die Verarbeitung wird ausgeführt, indem die Zeichen Dinge zueinander sagen.

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

Dies ist der Titel des Stücks; es wird vom Compiler ignoriert.

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

Hier deklarieren wir die im Rest des Programms verwendeten Variablen. Alles zwischen ,und .wird vom Compiler ignoriert. In diesem Fall deklarieren wir Romeo, um das zu dekodierende Zeichen zu speichern, und Juliet, um die Lauflänge des Zeichens zu speichern.

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

Hier deklarieren wir die erste und einzige Handlung im Programm. Acts und Szenen sind wie Labels. Sie können jederzeit mit let us return to scene IIoder einer Variante davon angesprungen werden . Wir verwenden nur einen Akt, weil er für unsere Bedürfnisse ausreicht. Auch hier wird alles zwischen :und .vom Compiler ignoriert.

Scene I: A silent entrance.

Hier deklarieren wir die erste Szene. Szenen sind in römischen Ziffern nummeriert: die erste ist Scene I, die zweite Scene IIund so weiter.

[Enter Romeo and Juliet]

Dies ist eine Regie; Darin teilen wir den Variablen Romeound Julietmit, dass sie die "Bühne" betreten sollen. Es können nur zwei Variablen gleichzeitig auf der "Bühne" sein. Die Stufe wird verwendet, damit der Compiler herausfinden kann, welche Variable welche adressiert, wenn sie sprechen. Da wir nur zwei Variablen haben, bleiben Romeo und Julia für die Dauer des Programms auf der Bühne.

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

Eine weitere Szenendeklaration. Szene II wird angesprungen, um eine andere Lauflänge zu dekodieren.

Juliet:

Diese Form der Erklärung bedeutet, dass Julia anfängt zu sprechen. Alles bis zur nächsten Romeo:, Regieanweisung oder Szenen- / Handlungserklärung wird eine Linie sein, die von Julia gesprochen wird, und so wird sich "ich" auf Julia, "du" / "du" auf Romeo usw. beziehen.

Open your mind.

Dieser Befehl speichert den Ordnungswert eines einzelnen Zeichens aus STDIN in Romeo.

Is my mother jollier than thou?

In der SPL werden Substantive entweder zu 1 oder -1 übersetzt, je nachdem, ob sie positiv oder negativ sind. In diesem Fall my motherbedeutet dies 1. Adjektive (positiv oder negativ) multiplizieren ihr Substantiv mit 2.

Das ist eine Frage; my motherDarin fragt Julia, ob (AKA 1) "lustiger" ist als Romeo. Vergleichswerte übersetzen entweder nachless than (wenn sie negativ sind, wie worse) oder greater than(wenn sie positiv sind, wie jollier) übersetzt. Daher läuft diese Frage auf Is 1 greater than you?.

Der Grund, warum wir diese Frage stellen, besteht darin, das Ende der Eingabe zu erkennen. Da der Wert von EOFvon Plattform zu Plattform unterschiedlich ist, normalerweise aber unter 1 liegt, wird er von uns zur Erkennung verwendet.

If so, we must proceed to scene IV.

Wird die vorhergehende Frage zu ausgewertet true , springen wir zu Szene IV, was einfach das Ende des Programms ist. Kurz gesagt, wenn wir eine EOF feststellen, beenden wir das Programm.

Romeo:

Es ist jetzt Romeos Linie: "Ich" und "Du" beziehen sich auf Romeo bzw. Julia.

Open your mind.

Diese Anweisung setzt den Ordnungswert eines einzelnen Zeichens aus STDIN in Juliet. Dies ist in diesem Fall die Lauflänge des in gespeicherten Zeichens 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!

Dies ist zu lang, um es im Detail zu besprechen, aber vertraue mir einfach, dass es übersetzt wird Juliet -= 48. Wir tun dies, weil Juliet den ASCII-Wert einer Ziffer enthält, undord('0') == 48 ; Beim Subtrahieren von 48 übersetzen wir den ASCII-Wert einer Zahl in die Zahl selbst.

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

Eine weitere Szenendeklaration. Dieser ist für die Schleife, in der wir wiederholt den Zeichenwert von Romeo,Juliet times .

Juliet:
  Speak thy mind.

Diese Aussage veranlasst Romeo, seinen Wert als Zeichen auszudrucken. Das heißt, der zuvor in Romeo gespeicherte Zeichenwert wird jetzt ausgegeben.

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

Ein Schwein ist ein negatives Substantiv a hog. daher wird diese Aussage zu ausgewertet Juliet -= 1.

Art thou as rotten as nothing?

Romeo fragt hier, ob Juliet "so faul wie" oder gleich 0 ist.

If so, let us return to scene II.

Wenn Julias Wert 0 ist, kehren wir zu Szene II zurück, um die Lauflänge eines anderen Charakters zu dekodieren.

Let us return to scene III.

Ansonsten kehren wir zu Szene III zurück, um Romeos Charakter erneut auszugeben.

Scene IV: Finale.

[Exeunt]

Diese endgültige Szenendeklaration ist nur eine Markierung für das Ende des Programms. Die [Exeunt]Regieanweisung ist erforderlich, damit der Compiler die endgültige Szene generiert.

GolfScript, 10 Zeichen

2/{1/~~*}/

Perl, 27 Zeichen

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

Mit Python 3 kann ich die Ansätze meiner beiden Python2-Lösungen zusammenführen.

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

APL (22)

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

Erläuterung:

• T←⍞: Eingabe speichern in T
• T⊂⍨~⎕D∊⍨T: Teilen Sie Tdie Zeichen auf, die keine Ziffern sind
• ↑: 2verwandle es in eine N/2Matrix
• {⍺/⍨⍎⍵}/: in jeder Zeile der Matrix ( /) repliziere ( /) das erste Zeichen ( ⍺) mit dem eval ( ⍎) des zweiten Zeichens (⍵ )
• ,/: verketten die Ausgabe jeder Zeile

Ruby, 30 Bytes

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

27 Bytes Code + 3 Bytes, um es mit dem -pFlag auszuführen :

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

8086 Assembly, 106 98 Zeichen

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

Wenn sich die Zahlen vor den Zeichen im Eingabestream befänden, könnten zwei Zeilen (18 Zeichen) davon entfernt werden.

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

Muss mit dem -rFlag ausgeführt
werden. \vKann durch Ersetzen mit dem nicht druckbaren 0x0Bund \amit auf 110 + 2 reduziert werden0x07

C 65 Zeichen

Ruft die Eingabe als Parameter ab.

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

Perl, 19 18 Zeichen

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

Die Regeln zum Zählen von Schaltern in der Befehlszeile finden Sie hier .

Viertens 45 Zeichen

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

Getestet mit pforth unter OS X.

Python, 63 62 Zeichen

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

Windows PowerShell, 55 Zeichen

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

Ich habe das Gefühl, dass man mehr Golf spielen kann, insbesondere mit den Casts von char bis string und int, aber ich habe nicht die Zeit, weiter daran zu arbeiten.

C, 68 Zeichen

Die Antwort von @ ugoren in C ist etwas kürzer, aber diese Antwort erfüllt die Anforderung, dass "die Zeichenfolge als Eingabe für stdin geliefert wird ".

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

Haskell, 58 56 Zeichen

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

Mein erster wirklicher Versuch, etwas Golf zu spielen, also gibt es hier wahrscheinlich einige Verbesserungen.

Japt -P , 8 Bytes

Eingabe als Array von Zeichen, Ausgabe als String.

ò crÈpY°

Versuch es

ò 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-Trit-Rotationsvariante), 4.494e6 Bytes

Die Größe dieser Antwort überschreitet die maximale postbare Programmgröße (eh), sodass sich der Code in meinem GitHub-Repository befindet .

Wie führe ich das aus?

Dies könnte ein schwieriger Teil sein, da naive Haskell-Interpreter eine Ewigkeit brauchen, um dies auszuführen. TIO hat einen anständigen Malbogle Unshackled-Interpreter, aber leider kann ich ihn nicht verwenden (Einschränkungen).

Das beste, was ich finden konnte, ist die Variante mit fester Rotationsbreite von 20 Trit, die mit einer Dekomprimierung von 360 Bytes pro Stunde eine sehr gute Leistung erbringt .

Um den Dolmetscher ein bisschen schneller zu machen, habe ich alle Checks von Matthias Lutters Malbolge Unshackled-Dolmetscher entfernt.

Meine modifizierte Version kann ungefähr 6,3% schneller laufen.

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

Es funktioniert!

05AB1E , 6 5 Bytes

2ι`ÅΓ

-1 Byte dank @Grimy .

Ausgabe als Liste von Zeichen.

Probieren Sie es online aus.

Alte 6- Byte- Antwort ohne integrierte Lauflängendecodierung:

2ôε`×?

Probieren Sie es online aus.

Erläuterung:

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 char

d = raw_input ()
print "". join ([x * int (d [i + 1]) für i, x in Aufzählung (d) wenn ~ i & 1])

s = raw_input ()
print "". join (i * int (j) für i, j in zip (s [:: 2], s [1 :: 2])

GolfScript (10 Zeichen)

2/{)15&*}/

J - 24

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

In diesem Beitrag geht es darum, das Infix-Adverb zu verwenden.

Befunge, 49 Zeichen

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

K, 35

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

Python 2, 58

Dies ist inspiriert von Darren Stones Python-Lösung - Missbrauch von Iteratoren!

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

Dies ist meine ursprüngliche Lösung (60 Zeichen)

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

Ein anderer Ansatz ist 3 Zeichen länger:

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

Java: 285 Zeichen

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 Zeichen

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

Leerzeichen, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Ersetzen Sie S, T, L durch Leerzeichen, Tabulatorzeichen und Zeilenvorschubzeichen.)

Probieren Sie es online [hier] .

Erläuterung:

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

Dies fühlt sich außergewöhnlich lang an, um Clojure zu sein. Wenn jemand es besser machen kann, poste es bitte.