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,'
Antworten:
,[>,>++++++[<-------->-]<[<.>-]<,]
.
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,'
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.
print<>=~s/(.)(.)/$1x$2/ger
print<>=~s/(.)(.)/$1x$2/ger. Ich bin mir auch ziemlich sicher $1x$2, dass Sie das gemeint haben und nicht umgekehrt.
/rist in Perlop dokumentiert und wurde in v5.14.0
-pFlagge benutzen, lassen Sie fallen printund die <>Antwort wird einfach: s/(.)(.)/$1x$2/ge-> 17 Zeichen +1 für -p-> 18 .
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)
raw_inputentspricht Python 3 input. Die erste Zeile muss bis zums=input()
s=input() while s:a,b,*s=s;print(a*int(b),end='')
,/{⍺/⍨⍎⍵}/↑T⊂⍨~⎕D∊⍨T←⍞
Erläuterung:
T←⍞: Eingabe speichern in TT⊂⍨~⎕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 Zeile8086 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.
dq 21cdc38821cd08b4 d888ed30c188482c e8ebfce210cd14b453 Zeichen? Ich sehe nicht, wo es nicht Großbuchstaben oder eof behandelt, obwohl ...
#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
\2.{9}ist eine tolle Idee) großartig!
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);
}
error: first parameter of 'main' (argument count) must be of type 'int'. Gibt es eine Befehlszeilenoption?
BEGIN KEY KEY 48 - 0 DO DUP EMIT LOOP 0 UNTIL
Getestet mit pforth unter OS X.
print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])
iterda ... Ich denke ich werde es selbst benutzen!
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);}}
main(c,n){ ... }Diese werden beim Ausführen des Programms standardmäßig mit 1 übergeben.
intArgument ausnutzen , aber Compiler, die ich benutze, beschweren sich, error: second parameter of 'main' (argument array) must be of type 'char **'damit ich nicht durchkommen kann main(c,n). Ich muss verwenden main(int c,char **n). Könnte eine Plattform oder eine GCC-Sache sein.
n;main(c)aber nicht main(n,c)- gut genug! :)
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.
read[y]speichert zwei Zeichen
replicate x ymit [1..x]>>[y]. Somit kann Ihre zweite Zeile durch ersetzt werden f(x:y:s)=(['1'..y]>>[x])++f s, was sie auf 53 Bytes reduziert.
-P , 8 BytesEingabe als Array von Zeichen, Ausgabe als String.
ò crÈpY°
ò crÈpYn :Implicit input of character array
ò :Groups of 2
r :Reduce each pair
È :By passing them through the following function as [X,Y]
p : Repeat X
Yn : Y, converted to an integer, times
:Implicitly join and output
ò crÏ°îXwenn du es zu gruselig findest!
Die Größe dieser Antwort überschreitet die maximale postbare Programmgröße (eh), sodass sich der Code in meinem GitHub-Repository befindet .
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;
}
2ι`ÅΓ
-1 Byte dank @Grimy .
Ausgabe als Liste von Zeichen.
Alte 6- Byte- Antwort ohne integrierte Lauflängendecodierung:
2ôε`×?
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 newline2ι`ÅΓist 5 Bytes. Wäre traurig, wenn das integrierte RLE keine RLE-Herausforderung gewinnen würde.
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])
2/{)15&*}/
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++;}}}}
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.