É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,'
Réponses:
,[>,>++++++[<-------->-]<[<.>-]<,]
.
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,'
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.
print<>=~s/(.)(.)/$1x$2/ger
print<>=~s/(.)(.)/$1x$2/ger. Je suis aussi assez sûr que vous vouliez dire $1x$2, et non l'inverse.
-pdrapeau vous laisse tomber printet <>, donc la réponse deviendra simplement: s/(.)(.)/$1x$2/ge-> 17chars +1 pour -p-> 18 .
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)
raw_inputcorrespond à Python 3 input. Donc la première ligne doit êtres=input()
s=input() while s:a,b,*s=s;print(a*int(b),end='')
,/{⍺/⍨⍎⍵}/↑T⊂⍨~⎕D∊⍨T←⍞
Explication:
T←⍞: stocker l'entrée dans TT⊂⍨~⎕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 ligneAssemblage 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.
dq 21cdc38821cd08b4 d888ed30c188482c e8ebfce210cd14b4pour 53 personnages? Je ne vois pas où il gère les caractères non majuscules ou eof ...
#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
\2.{9}c'est une excellente idée) splendide!
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);
}
error: first parameter of 'main' (argument count) must be of type 'int'. Y a-t-il un commutateur de ligne de commande?
perl -pe 's/(.)(.)/$1x$2/ge'
Les règles de comptage des commutateurs sur la ligne de commande sont ici .
BEGIN KEY KEY 48 - 0 DO DUP EMIT LOOP 0 UNTIL
Testé avec pforth sur OS X.
print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])
iterça ... Je pense que je vais l'utiliser moi-même!
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);}}
main(c,n){ ... }qui seront passés 1 par défaut lorsque le programme est exécuté.
intargument, mais les compilateurs que j'utilise se plaignent error: second parameter of 'main' (argument array) must be of type 'char **'donc je ne peux pas m'en tirer main(c,n); Je dois utiliser main(int c,char **n). Cela pourrait être une plate-forme ou une chose gcc.
n;main(c)mais pas main(n,c)- assez bien! :)
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.
read[y]enregistre deux caractères
replicate x ypar [1..x]>>[y]. Ainsi, votre deuxième ligne peut être remplacée par f(x:y:s)=(['1'..y]>>[x])++f s, ce qui la ramène à 53 octets.
-P , 8 octetsEntrez sous forme de tableau de caractères, sortez sous forme de chaîne.
ò 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Ï°îXsi vous le trouvez trop effrayant!
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 .
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;
}
2ι`ÅΓ
-1 octet grâce à @Grimy .
Sorties sous forme de liste de caractères.
Réponse de 6 octets sans décodage intégré:
2ôε`×?
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 newline2ι`ÅΓest de 5 octets. Ce serait triste si le RLE intégré n'a pas remporté un défi RLE.
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]))
2/{)15&*}/
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++;}}}}
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.