Escriba el código más corto en el idioma que elija para realizar la decodificación de longitud de ejecución de la cadena dada.

La cadena se proporcionará como entrada en stdin en el formulario

CNCNCNCNCNCNCNCN

donde cada uno Cpodría ser cualquier carácter ASCII imprimible y cada uno Nes un dígito 1para 9(inclusive).

Entrada de muestra:

:144,1'1

Salida correspondiente:

:4444,'

Brainfuck, 34 personajes

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

Lenguaje de programación Shakespeare , 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]

Versión sin golf:

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]

Estoy usando el compilador Python SPL de drsam94 , que tiene algunos errores (por lo que, por ejemplo, lo uso en Open your mindlugar de Open thy minden la versión de golf).

Para ejecutar este programa, use:

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

Cómo funciona

SPL es un lenguaje de programación esotérico diseñado para hacer que los programas se vean como obras de Shakespeare. Lo hace mediante el uso de caracteres como variables, y el procesamiento se realiza haciendo que los personajes se digan cosas entre sí.

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

Este es el título de la obra; es ignorado por el compilador.

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

Aquí estamos declarando las variables utilizadas en el resto del programa. Todo está entre ,y .el compilador lo ignora. En este caso, declaramos que se Romeousa para contener el carácter que se decodifica y que se Julietusa para mantener la longitud de ejecución del personaje.

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

Aquí declaramos el primer y único acto en el programa. Los actos y las escenas son como etiquetas; se puede saltar a ellos en cualquier momento usando let us return to scene IIo alguna variante de eso. Solo usamos un acto, porque es suficiente para nuestras necesidades. Una vez más, el compilador ignora cualquier cosa entre :y ..

Scene I: A silent entrance.

Aquí declaramos la primera escena. Las escenas están numeradas en números romanos: la primera es Scene I, la segunda Scene II, y así sucesivamente.

[Enter Romeo and Juliet]

Esta es una dirección escénica; en él, le decimos a las variables Romeoy Julietque entren en el "escenario". Solo dos variables pueden estar en el "escenario" a la vez; la etapa se usa para que el compilador pueda determinar qué variable está abordando qué cuando habla. Como solo tenemos dos variables, Romeo y Julieta permanecerán en el escenario durante todo el programa.

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

Otra declaración de escena. Se saltará a la escena II para decodificar otra duración de ejecución.

Juliet:

Esta forma de declaración significa que Julieta comenzará a hablar. Todo hasta la próxima Romeo:declaración de dirección de escena o escena / acto será una línea pronunciada por Juliet, y por lo tanto "yo" se referirá a Juliet, "usted" / "you" a Romeo, etc.

Open your mind.

Este comando almacena el valor ordinal de un solo carácter de STDIN en Romeo.

Is my mother jollier than thou?

En SPL, los sustantivos se traducen a 1 o -1 dependiendo de si son positivos o negativos. En este caso, se my mothertraduce en 1. Los adjetivos (positivos o negativos) multiplican su sustantivo por 2.

Esta es una pregunta; en ella, Juliet pregunta si my mother(también conocido como 1) es "más alegre" que Romeo. Los comparativos se traducen a less than(si son negativos, como worse) o greater than(si son positivos, como jollier). Por lo tanto, esta pregunta se reduce a Is 1 greater than you?.

La razón por la que hacemos esta pregunta es para detectar el final de la entrada. Como el valor de EOFvaría según la plataforma, pero generalmente es menor que 1, lo usamos para detectarlo.

If so, we must proceed to scene IV.

Si se evalúa la pregunta anterior true, saltamos a la escena IV, que es simplemente el final del programa. En resumen, si detectamos un EOF, finalizamos el programa.

Romeo:

Ahora es la línea de Romeo: "yo" y "tú" se refieren a Romeo y Julieta, respectivamente.

Open your mind.

Nuevamente, esta declaración coloca el valor ordinal de un solo carácter de STDIN en Julieta, que en este caso es la longitud de ejecución del carácter almacenado en 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!

Este es demasiado largo para pasar con gran detalle, pero solo confía en mí en que se traduce Juliet -= 48. Hacemos esto porque Juliet tiene el valor ASCII de un número, y ord('0') == 48; al restar 48, traducimos del valor ASCII de un número al número mismo.

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

Otra declaración de escena. Este es para el ciclo en el que imprimimos repetidamente el valor de carácter de Romeo, Julietveces.

Juliet:
  Speak thy mind.

Esta declaración hace que Romeo imprima su valor como personaje; es decir, cualquier valor de carácter que se haya almacenado previamente en Romeo ahora se genera.

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

Un cerdo es un sustantivo negativo, por lo que se a hogtraduce en -1; por lo tanto, esta declaración se evalúa como Juliet -= 1.

Art thou as rotten as nothing?

Romeo aquí pregunta si Julieta está "tan podrida como", o igual a 0.

If so, let us return to scene II.

Si el valor de Juliet es 0, volveremos a la escena II para decodificar la longitud de la carrera de otro personaje.

Let us return to scene III.

De lo contrario, volvemos a la escena III para dar salida al personaje de Romeo nuevamente.

Scene IV: Finale.

[Exeunt]

Esta declaración de escena final es solo un marcador para el final del programa. La [Exeunt]dirección del escenario es necesaria para que el compilador realmente genere la escena final.

GolfScript, 10 caracteres

2/{1/~~*}/

perl, 27 caracteres

print<>=~s/(.)(.)/$1x$2/ger

R 67

x=strsplit(readline(),"")[[1]];cat(rep(x[c(T,F)],x[c(F,T)]),sep="")

Pitón 3, 52

Python 3 me permite fusionar los enfoques de mis dos soluciones python2.

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

APL (22)

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

Explicación:

• T←⍞: almacenar entrada en T
• T⊂⍨~⎕D∊⍨T: dividido Ten aquellos caracteres que no son dígitos
• ↑: 2conviértalo en una N/2matriz -por-
• {⍺/⍨⍎⍵}/: en cada fila de la matriz ( /), replica ( /) el primer carácter ( ⍺) por el eval ( ⍎) del segundo carácter ( ⍵)
• ,/: concatenar la salida de cada fila

Rubí, 30 bytes.

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

Código de 27 bytes + 3 bytes para ejecutarlo con la -pbandera:

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

8086 asamblea, 106 98 caracteres

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 los números fueran antes de los caracteres en la secuencia de entrada, dos líneas (18 caracteres) podrían eliminarse de esto.

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

Debe ejecutarse con la -rbandera.
Puede reducirse a 110 + 2 reemplazándola \vpor la no imprimible 0x0By \apor0x07

C, 65 caracteres

Obtiene la entrada como parámetro.

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

Perl, 19 18 caracteres

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

Las reglas para contar los interruptores en la línea de comandos están aquí .

Adelante, 45 caracteres

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

Probado con adelante en OS X.

Python, 63 62 caracteres

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

Windows PowerShell, 55 caracteres

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

Tengo la sensación de que esto se puede reducir aún más, específicamente con los lanzamientos de char a string e int, pero no tengo tiempo para seguir trabajando en ello en este momento.

C, 68 caracteres

La respuesta de @ ugoren en C es ligeramente más corta, pero esta respuesta cumple con el requisito de que "la cadena se proporcionará como entrada en stdin ".

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

Haskell, 58 56 caracteres

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

Mi primer intento real de jugar al golf es algo, por lo que probablemente haya que mejorar aquí.

Japt -P , 8 bytes

Entrada como una matriz de caracteres, salida como una cadena.

ò crÈpY°

Intentalo

ò 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 rotación de 20 trits), 4,494e6 bytes

El tamaño de esta respuesta excede el tamaño máximo de programa postable (eh), por lo que el código se encuentra en mi repositorio de GitHub .

¿Cómo ejecutar esto?

Esto podría ser una parte difícil, porque el ingenuo intérprete de Haskell tardará siglos en ejecutarlo. TIO tiene un intérprete decente Malbogle Unshackled, pero lamentablemente no podré usarlo (limitaciones).

La mejor que pude encontrar es la variante de ancho de rotación fija de 20 trits, que funciona muy bien, descomprimiendo 360 bytes por hora .

Para hacer que el intérprete sea un poco más rápido, eliminé todas las comprobaciones del intérprete Malbolge Unshackled de Matthias Lutter.

Mi versión modificada puede correr alrededor de un 6,3% más rápido.

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

¡Esta funcionando!

05AB1E , 6 5 bytes

2ι`ÅΓ

-1 byte gracias a @Grimy .

Salidas como una lista de caracteres.

Pruébalo en línea.

Antigua respuesta de 6 bytes sin decodificación de longitud de ejecución integrada:

2ôε`×?

Pruébalo en línea.

Explicación:

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]) para i, x en enumerate (d) if ~ i & 1])

s = raw_input ()
print "". join (i * int (j) para i, j en zip (s [:: 2], s [1 :: 2]))

GolfScript (10 caracteres)

2/{)15&*}/

J - 24

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

El objetivo de esta presentación es utilizar el adverbio infijo.

Befunge, 49 caracteres

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

K, 35

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

Pitón 2, 58

Esto está inspirado en la solución de Python de Darren Stone: ¡abuso de iteradores!

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

Esta es mi solución original (60 caracteres)

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

Un enfoque diferente es 3 caracteres más largo:

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 caracteres

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

Espacio en blanco, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Reemplace S, T, L con espacio, tabulación, caracteres de salto de línea).

Pruébelo en línea [aquí] .

Explicación:

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

Esto se siente excepcionalmente largo para ser Clojure, si alguien puede hacerlo mejor, publíquelo.