Scrivi il codice più breve nella lingua che preferisci per eseguire la decodifica della lunghezza della stringa specificata.

La stringa verrà fornita come input su stdin nel modulo

CNCNCNCNCNCNCNCN

dove ognuno Cpotrebbe essere qualsiasi carattere ASCII stampabile e ognuno Nè una cifra 1da 9(compreso).

Input di esempio:

:144,1'1

Uscita corrispondente:

:4444,'

Brainfuck, 34 personaggi

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

Shakespeare Programming Language , 406 byte

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

Versione non golfata:

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]

Sto usando il compilatore Python SPL di drsam94 , che ha alcuni bug (motivo per cui, ad esempio, utilizzo Open your mindinvece diOpen thy mind nella versione golfata).

Per eseguire questo programma, utilizzare:

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

Come funziona

SPL è un linguaggio di programmazione esoterico progettato per far sembrare i programmi come i giochi di Shakespeare. Lo fa usando i caratteri come variabili e l'elaborazione viene eseguita facendo in modo che i personaggi si dicano l'un l'altro.

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

Questo è il titolo dell'opera teatrale; viene ignorato dal compilatore.

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

Qui stiamo dichiarando le variabili utilizzate nel resto del programma. Tutto tra ,e .viene ignorato dal compilatore. In questo caso, dichiariamo Romeo, usato per contenere il personaggio in fase di decodifica e Juliet, usato per contenere la lunghezza del personaggio.

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

Qui dichiariamo il primo e unico atto nel programma. Gli atti e le scene sono come etichette; possono essere saltati in qualsiasi momento usando let us return to scene IIo qualche variante di quello. Usiamo solo un atto, perché è sufficiente per le nostre esigenze. Ancora una volta, qualsiasi cosa tra :e .viene ignorata dal compilatore.

Scene I: A silent entrance.

Qui dichiariamo la prima scena. Le scene sono numerate in numeri romani: il primo è Scene I, il secondo Scene IIe così via.

[Enter Romeo and Juliet]

Questa è una direzione scenica; in esso diciamo alle variabili Romeoe Julietdi entrare nello "stage". Solo due variabili possono essere sullo "stage" contemporaneamente; lo stage viene utilizzato in modo che il compilatore possa capire quale variabile si sta indirizzando e quando parlano. Poiché abbiamo solo due variabili, Romeo e Giulietta rimarranno sul palco per tutta la durata del programma.

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

Un'altra dichiarazione di scena. Verrà saltata la scena II per decodificare un'altra lunghezza di esecuzione.

Juliet:

Questa forma di dichiarazione significa che Juliet inizierà a parlare. Tutto fino alla prossima Romeo:, direzione del palcoscenico o dichiarazione di scena / atto sarà una linea pronunciata da Giulietta, e quindi "io" si riferirà a Giulietta, "tu" / "tu" a Romeo, ecc.

Open your mind.

Questo comando memorizza il valore ordinale del singolo carattere di STDIN in Romeo.

Is my mother jollier than thou?

In SPL, i sostantivi si traducono in 1 o -1 a seconda che siano positivi o negativi. In questo caso, si my mothertraduce in 1. Gli aggettivi (positivi o negativi) moltiplicano il loro nome per 2.

Questa è una domanda; in esso, Juliet chiede se my mother(AKA 1) è "più allegro" di Romeo. I comparativi si traducono in less than(se sono negativi, come worse) o greater than(se sono positivi, come jollier). Pertanto, questa domanda si riduce a Is 1 greater than you?.

Il motivo per cui facciamo questa domanda è rilevare la fine dell'input. Poiché il valore di EOFvaria in base alla piattaforma, ma di solito è inferiore a 1, lo utilizziamo per rilevarlo.

If so, we must proceed to scene IV.

Se la domanda precedente è stata valutata true, passiamo alla scena IV, che è semplicemente la fine del programma. In breve, se rileviamo un EOF, chiudiamo il programma.

Romeo:

Ora è la linea di Romeo: "io" e "tu" si riferiscono rispettivamente a Romeo e Giulietta.

Open your mind.

Ancora una volta, questa affermazione inserisce il valore ordinale di un singolo carattere da STDIN in Juliet, che in questo caso è la lunghezza del personaggio memorizzato 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!

Questo è troppo lungo per essere esaminato nei minimi dettagli, ma fidati di me in ciò che si traduce Juliet -= 48. Lo facciamo perché Juliet detiene il valore ASCII di un numero e ord('0') == 48; sottraendo 48, traduciamo dal valore ASCII di un numero al numero stesso.

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

Un'altra dichiarazione di scena. Questo è per il ciclo in cui stampiamo ripetutamente il valore del carattere di Romeo, Julietvolte.

Juliet:
  Speak thy mind.

Questa affermazione induce Romeo a stampare il suo valore come personaggio; cioè, qualunque sia il valore del personaggio precedentemente memorizzato in Romeo viene ora emesso.

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

Un maiale è un sostantivo negativo, quindi si a hogtraduce in -1; pertanto, questa affermazione valuta Juliet -= 1.

Art thou as rotten as nothing?

Romeo qui chiede se Juliet è "marcio come", o uguale a, 0.

If so, let us return to scene II.

Se il valore di Giulietta è 0, torniamo alla scena II per decodificare la lunghezza di un altro personaggio.

Let us return to scene III.

Altrimenti, torniamo alla scena III per dare di nuovo in uscita il personaggio di Romeo.

Scene IV: Finale.

[Exeunt]

Questa dichiarazione finale della scena è solo un indicatore per la fine del programma. La [Exeunt]direzione del palcoscenico è necessaria affinché il compilatore generi effettivamente la scena finale.

GolfScript, 10 caratteri

2/{1/~~*}/

perl, 27 caratteri

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 mi permette di unire gli approcci delle mie due soluzioni python2.

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

APL (22)

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

Spiegazione:

• T←⍞: memorizza input in T
• T⊂⍨~⎕D∊⍨T: diviso Tper quei caratteri che non sono cifre
• ↑: trasformalo in una matrice 2perbyN/2
• {⍺/⍨⍎⍵}/: su ogni riga della matrice ( /), replicare ( /) il primo carattere ( ⍺) dall'eval ( ⍎) del secondo carattere ( ⍵)
• ,/: concatena l'output di ogni riga

Rubino, 30 byte

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

Codice di 27 byte + 3 byte per eseguirlo con il -pflag:

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

Assemblaggio 8086, 106 98 caratteri

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

Se i numeri fossero prima dei caratteri nel flusso di input, due righe (18 caratteri) potrebbero essere eliminate.

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

Deve essere eseguito con la -rbandiera
Può essere ridotto a 110 + 2 sostituendolo \vcon lo non stampabile 0x0Be \acon0x07

C, 65 caratteri

Ottiene l'input come parametro.

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

Perl, 19 18 caratteri

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

Le regole per il conteggio delle opzioni nella riga di comando sono qui .

Avanti, 45 caratteri

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

Testato con pforth su OS X.

Python, 63 62 caratteri

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

Windows PowerShell, 55 caratteri

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

Ho la sensazione che questo possa essere ulteriormente risolto, in particolare con i cast da char a string e int, ma non ho il tempo di continuare a lavorarci adesso.

C, 68 caratteri

La risposta di @ ugoren in C è leggermente più breve, ma questa risposta soddisfa il requisito che "la stringa verrà fornita come input su stdin ".

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

Haskell, 58 56 caratteri

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

Il mio primo vero tentativo di giocare a golf, quindi probabilmente c'è qualche miglioramento da fare qui.

Japt -P , 8 byte

Input come una matrice di caratteri, output come una stringa.

ò crÈpY°

Provalo

ò 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 (variante a rotazione da 20 trit), 4.494e6 byte

Le dimensioni di questa risposta superano le dimensioni massime del programma (eh), quindi il codice si trova nel mio repository GitHub .

Come eseguirlo?

Questa potrebbe essere una parte difficile, perché l'ingenuo interprete di Haskell impiegherà anni e secoli per eseguire questo. TIO ha un discreto interprete Malbogle Unshackled, ma purtroppo non sarò in grado di usarlo (limitazioni).

La migliore che ho trovato è la variante con larghezza di rotazione fissa di 20 trit, che funziona molto bene, decomprimendo 360 byte all'ora .

Per rendere l'interprete un po 'più veloce, ho rimosso tutti i controlli dall'interprete Malbolge Unshackled di Matthias Lutter.

La mia versione modificata può essere più veloce del 6,3% circa.

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

Sta funzionando!

05AB1E , 6 5 byte

2ι`ÅΓ

-1 byte grazie a @Grimy .

Emette come un elenco di caratteri.

Provalo online.

Vecchia risposta a 6 byte senza decodifica di lunghezza di esecuzione integrata:

2ôε`×?

Provalo online.

Spiegazione:

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 caratteri

d = raw_input ()
stampa "". join ([x * int (d [i + 1]) per i, x in enumerazione (d) se ~ i & 1])

s = raw_input ()
stampa "". join (i * int (j) per i, j in zip (s [:: 2], s [1 :: 2]))

GolfScript (10 caratteri)

2/{)15&*}/

J - 24

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

Il punto di questa presentazione è usare l'avverbio infix.

Befunge, 49 caratteri

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

K, 35

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

Python 2, 58

Questo si ispira alla soluzione di pitone di Darren Stone: l'abuso iteratore!

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

Questa è la mia soluzione originale (60 caratteri)

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

Un approccio diverso è più lungo di 3 caratteri:

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

Java: 285 charas

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 caratteri

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

Spazio bianco, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Sostituisci i caratteri S, T, L con spazio, tabulazione e avanzamento riga).

Provalo online [qui] .

Spiegazione:

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

Questo sembra eccezionalmente lungo per essere Clojure, se qualcuno può fare di meglio, per favore pubblicalo.