Écrivez le code le plus court dans la langue de votre choix pour effectuer le décodage de la longueur d'exécution de la chaîne donnée.

La chaîne sera fournie en entrée sur stdin sous la forme

CNCNCNCNCNCNCNCN

où chacun Cpourrait être n'importe quel caractère ASCII imprimable et chaqueN est un chiffre 1à 9(inclus).

Exemple d'entrée:

:144,1'1

Sortie correspondante:

:4444,'

Brainfuck, 34 personnages

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

Langage de programmation Shakespeare , 406 octets

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

Version non golfée:

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]

J'utilise le compilateur SPL Python drsam94 , qui a quelques bugs ( ce qui explique pourquoi, par exemple, je l' utilise au Open your mindlieu de Open thy mindla version golfed).

Pour exécuter ce programme, utilisez:

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

Comment ça fonctionne

SPL est un langage de programmation ésotérique conçu pour que les programmes ressemblent à des pièces de Shakespeare. Il le fait en utilisant des caractères comme variables, et le traitement est effectué en demandant aux personnages de se dire des choses.

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

C'est le titre de la pièce; il est ignoré par le compilateur.

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

Ici, nous déclarons les variables utilisées dans le reste du programme. Tout entre ,et. est ignoré par le compilateur. Dans ce cas, nous déclarons Romeo, utilisé pour contenir le caractère en cours de décodage, et Juliet, utilisé pour contenir la longueur du caractère.

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

Nous déclarons ici le premier et le seul acte du programme. Les actes et les scènes sont comme des étiquettes; ils peuvent être sautés à tout moment en utilisantlet us return to scene II ou une variante de cela. Nous n'utilisons qu'un seul acte, car il suffit à nos besoins. Encore une fois, tout ce qui se trouve entre :et .est ignoré par le compilateur.

Scene I: A silent entrance.

Ici, nous déclarons la première scène. Les scènes sont numérotées en chiffres romains: la première estScene I , la seconde Scene II, etc.

[Enter Romeo and Juliet]

Ceci est une mise en scène; on y raconteRomeoJuliet variables et de venir sur la "scène". Seules deux variables peuvent être sur la "scène" à la fois; l'étape est utilisée pour que le compilateur puisse déterminer quelle variable s'adresse à qui quand ils parlent. Parce que nous n'avons que deux variables, Roméo et Juliette resteront sur scène pendant toute la durée du programme.

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

Une autre déclaration de scène. La scène II sera sautée afin de décoder une autre longueur d'exécution.

Juliet:

Cette forme de déclaration signifie que Juliette va commencer à parler. Tout jusqu'à la prochaineRomeo: , mise en scène ou déclaration de scène / acte sera une phrase prononcée par Juliette, et donc "moi" fera référence à Juliette, "vous" / "tu" à Roméo, etc.

Open your mind.

Cette commande stocke la valeur ordinale d'un caractère unique de STDIN dans Romeo .

Is my mother jollier than thou?

En SPL, les noms se traduisent par 1 ou -1 selon qu'ils sont positifs ou négatifs. Dans ce cas,my mother traduit par 1. Les adjectifs (positifs ou négatifs) multiplient leur nom par 2.

C'est une question; Juliet y demande si my mother(AKA 1) est "plus joyeux" que Roméo. Les comparatifs se traduisent par less than(s'ils sont négatifs, comme worse) ou greater than(s'ils sont positifs, comme jollier). Par conséquent, cette question se résume à Is 1 greater than you?.

La raison pour laquelle nous posons cette question est de détecter la fin de l'entrée. Étant donné que la valeur de EOFvarie selon la plate-forme, mais est généralement inférieure à 1, nous l'utilisons pour la détecter.

If so, we must proceed to scene IV.

Si la question précédente est évaluée true, nous passons à la scène IV - qui est tout simplement la fin du programme. En bref, si nous détectons un EOF, nous terminons le programme.

Romeo:

C'est maintenant la ligne de Roméo: «moi» et «vous» se réfèrent respectivement à Roméo et Juliette.

Open your mind.

Encore une fois, cette instruction place la valeur ordinale d'un seul caractère de STDIN dans Juliet, qui dans ce cas est la longueur du caractère stocké dans 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!

Celui-ci est trop long pour être détaillé, mais croyez-moi, cela se traduit par Juliet -= 48. Nous faisons cela parce que Juliette détient la valeur ASCII d'un chiffre, et ord('0') == 48; en soustrayant 48, nous traduisons de la valeur ASCII d'un nombre au nombre lui-même.

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

Une autre déclaration de scène. Celui-ci est pour la boucle dans laquelle nous imprimons à plusieurs reprises la valeur de caractère de Romeo,Juliet times.

Juliet:
  Speak thy mind.

Cette déclaration fait que Roméo imprime sa valeur en tant que personnage; c'est-à-dire que la valeur de caractère précédemment stockée dans Romeo est maintenant sortie.

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

Un porc est un nom négatif, donc se a hogtraduit par -1; par conséquent, cette déclaration est évaluée Juliet -= 1.

Art thou as rotten as nothing?

Roméo demande ici si Juliette est "aussi pourrie que" ou égale à 0.

If so, let us return to scene II.

Si la valeur de Juliette est 0, nous rebouclons vers la scène II pour décoder la durée de vie d'un autre personnage.

Let us return to scene III.

Sinon, nous retournons à la scène III pour sortir à nouveau le personnage de Roméo.

Scene IV: Finale.

[Exeunt]

Cette déclaration de scène finale n'est qu'un marqueur de la fin du programme. La [Exeunt]direction de la scène est nécessaire pour que le compilateur génère réellement la scène finale.

GolfScript, 10 caractères

2/{1/~~*}/

perl, 27 caractères

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 me permet de fusionner les approches de mes deux solutions python2.

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

APL (22)

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

Explication:

• T←⍞: stocker l'entrée dans T
• T⊂⍨~⎕D∊⍨T: Divisé T sur les caractères qui ne sont pas des chiffres
• ↑: le transformer en matrice 2-par-N/2
• {⍺/⍨⍎⍵}/: sur chaque ligne de la matrice ( /), réplique ( /) le premier caractère ( ⍺) par l'eval ( ⍎) du deuxième caractère ( ⍵)
• ,/: concaténer la sortie de chaque ligne

Rubis, 30 octets

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

27 octets de code + 3 octets pour l'exécuter avec le -pdrapeau:

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

Assemblage 8086, 106 98 caractères

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

Si les chiffres étaient avant les caractères dans le flux d'entrée, deux lignes (18 caractères) pourraient être supprimées.

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

Doit être exécuté avec le -rdrapeau
Peut être réduit à 110 + 2 en remplaçant \vpar l'imprimable 0x0Bet \apar0x07

C, 65 caractères

Obtient l'entrée en tant que paramètre.

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

Perl, 19 18 caractères

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

Les règles de comptage des commutateurs sur la ligne de commande sont ici .

Quatrième, 45 caractères

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

Testé avec pforth sur OS X.

Python, 63 62 caractères

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

Windows PowerShell, 55 caractères

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

J'ai l'impression que cela peut être approfondi, en particulier avec les transtypages de char à string et int, mais je n'ai pas le temps de continuer à travailler dessus pour le moment.

C, 68 caractères

La réponse de @ ugoren en C est légèrement plus courte, mais cette réponse est conforme à l'exigence selon laquelle "la chaîne sera fournie en entrée sur stdin ".

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

Haskell, 58 56 caractères

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

Ma première vraie tentative de jouer au golf, donc il y a probablement des améliorations à faire ici.

Japt -P , 8 octets

Entrez sous forme de tableau de caractères, sortez sous forme de chaîne.

ò crÈpY°

Essayez-le

ò 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 de rotation de 20 trits), 4 494e6 octets

La taille de cette réponse dépasse la taille maximale du programme (eh), le code est donc trouve dans mon référentiel GitHub .

Comment faire ça?

Cela pourrait être une partie délicate, car un interprète naïf de Haskell prendra des âges pour exécuter cela. TIO a un interprète Malbogle Unshackled décent, mais malheureusement je ne pourrai pas l'utiliser (limitations).

Le meilleur que j'ai pu trouver est la variante de largeur de rotation fixe de 20 trits, qui fonctionne très bien, décompresse 360 ​​octets par heure .

Pour rendre l'interprète un peu plus rapide, j'ai supprimé toutes les vérifications de l'interpréteur Malbolge Unshackled de Matthias Lutter.

Ma version modifiée peut fonctionner environ 6,3% plus rapidement.

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

Ça marche!

05AB1E , 6 5 octets

2ι`ÅΓ

-1 octet grâce à @Grimy .

Sorties sous forme de liste de caractères.

Essayez-le en ligne.

Réponse de 6 octets sans décodage intégré:

2ôε`×?

Essayez-le en ligne.

Explication:

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 caractères

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) for i, j in zip (s [:: 2], s [1 :: 2]))

GolfScript (10 caractères)

2/{)15&*}/

J - 24

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

Le point de cette soumission est d'utiliser l'adverbe infixe.

Befunge, 49 caractères

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

K, 35

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

Python 2, 58

Ceci est inspiré par la solution python de Darren Stone - abus d'itérateur!

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

Ceci est ma solution d'origine (60 caractères)

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

Une approche différente prend 3 caractères de plus:

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 caractères

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

Espace, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Remplacez S, T, L par des espaces, des tabulations et des sauts de ligne.)

Essayez-le en ligne [ici] .

Explication:

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

Cela semble exceptionnellement long pour être Clojure, si quelqu'un peut faire mieux, veuillez le poster.