Escreva o código mais curto no idioma de sua escolha para executar a decodificação do comprimento da execução da string especificada.

A string será fornecida como entrada no stdin no formato

CNCNCNCNCNCNCNCN

onde cada um Cpode ter qualquer caractere ASCII imprimível e cada Num é um dígito 1para 9(inclusive).

Entrada de amostra:

:144,1'1

Saída correspondente:

:4444,'

Brainfuck, 34 caracteres

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

Linguagem de programação de 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]

Versão não destruída:

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]

Estou usando o compilador Python SPL do drsam94 , que possui alguns bugs (é por isso que, por exemplo, eu uso em Open your mindvez da Open thy mindversão golfed).

Para executar este programa, use:

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

Como funciona

SPL é uma linguagem de programação esotérica projetada para fazer com que os programas se pareçam com as peças de Shakespeare. Isso é feito usando caracteres como variáveis, e o processamento é realizado fazendo com que os caracteres digam coisas um ao outro.

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

Este é o título da peça; é ignorado pelo compilador.

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

Aqui estamos declarando as variáveis ​​usadas no restante do programa. Tudo entre ,e .é ignorado pelo compilador. Nesse caso, declaramos que era Romeousado para reter o caractere que está sendo decodificado e Julietusado para reter a duração da execução do caractere.

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

Aqui declaramos o primeiro e único ato no programa. Atos e cenas são como rótulos; eles podem ser acessados ​​a qualquer momento usando let us return to scene IIou alguma variante disso. Nós usamos apenas um ato, porque é suficiente para nossas necessidades. Novamente, qualquer coisa entre :e .é ignorada pelo compilador.

Scene I: A silent entrance.

Aqui declaramos a primeira cena. As cenas são numeradas em algarismos romanos: o primeiro é Scene I, o segundo Scene IIe assim por diante.

[Enter Romeo and Juliet]

Esta é uma direção de palco; nele, dizemos aos Romeoe Julietvariáveis para vir para o "palco". Somente duas variáveis ​​podem estar no "palco" de uma só vez; o estágio é usado para que o compilador possa descobrir qual variável está endereçando e quando eles falam. Como temos apenas duas variáveis, Romeu e Julieta permanecerão no palco pelo período do programa.

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

Outra declaração de cena. A cena II será saltada para decodificar outra duração.

Juliet:

Essa forma de declaração significa que Juliet começará a falar. Tudo até a próxima Romeo:direção do palco ou declaração de cena / ato será uma frase falada por Julieta e, assim, "eu" se referirá a Julieta, "você" / "tu" a Romeu, etc.

Open your mind.

Este comando armazena o valor ordinal do caractere único de STDIN em Romeo.

Is my mother jollier than thou?

No SPL, os substantivos são traduzidos para 1 ou -1, dependendo de serem positivos ou negativos. Nesse caso, my mothertraduz para 1. Adjetivos (positivos ou negativos) multiplicam seu substantivo por 2.

Esta é uma questão; nele, Julieta pergunta se my mother(AKA 1) é "mais alegre" que Romeu. Os comparativos são traduzidos para less than(se forem negativos, como worse) ou greater than(se forem positivos, como jollier). Portanto, esta questão se resume a Is 1 greater than you?.

A razão pela qual fazemos esta pergunta é detectar o final da entrada. Como o valor de EOFvaria de acordo com a plataforma, mas geralmente é menor que 1, usamos isso para detectá-lo.

If so, we must proceed to scene IV.

Se a pergunta anterior foi avaliada true, pulamos para a cena IV - que é simplesmente o fim do programa. Em resumo, se detectarmos um EOF, encerraremos o programa.

Romeo:

Agora é a linha de Romeu: "eu" e "você" se referem a Romeu e Julieta, respectivamente.

Open your mind.

Novamente, essa instrução coloca o valor ordinal de um único caractere de STDIN em Juliet, que nesse caso é o comprimento de execução do caractere armazenado 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 é muito longo para analisar em detalhes, mas confie em mim no que se refere Juliet -= 48. Fazemos isso porque Juliet mantém o valor ASCII de um numeral e ord('0') == 48; ao subtrair 48, convertemos do valor ASCII de um número para o próprio número.

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

Outra declaração de cena. Este é para o loop no qual repetidamente imprimimos o valor de caractere Romeo, Juliettimes.

Juliet:
  Speak thy mind.

Essa afirmação faz com que Romeu imprima seu valor como personagem; isto é, qualquer valor de caractere que foi armazenado anteriormente no Romeo agora é exibido.

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

Um porco é um substantivo negativo, então se a hogtraduz em -1; portanto, esta declaração é avaliada como Juliet -= 1.

Art thou as rotten as nothing?

Romeu pergunta aqui se Julieta é "tão podre quanto" ou igual a 0.

If so, let us return to scene II.

Se o valor de Juliet for 0, retornamos à cena II para decodificar a duração de outra personagem.

Let us return to scene III.

Senão, voltamos à cena III para exibir novamente o personagem de Romeu.

Scene IV: Finale.

[Exeunt]

Esta declaração final da cena é apenas um marcador para o final do programa. A [Exeunt]direção do palco é necessária para que o compilador gere a cena 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="")

Python 3, 52

O Python 3 permite mesclar as abordagens das minhas duas soluções python2.

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

APL (22)

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

Explicação:

• T←⍞: armazena entrada em T
• T⊂⍨~⎕D∊⍨T: divida Tnos caracteres que não são dígitos
• ↑: Transformá-lo em um 2-by- N/2matriz
• {⍺/⍨⍎⍵}/: em cada linha da matriz ( /), replique ( /) o primeiro caractere ( ⍺) pelo eval ( ⍎) do segundo caractere ( ⍵)
• ,/: concatenar a saída de cada linha

Ruby, 30 bytes

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

Código de 27 bytes + 3 bytes para executá-lo com o -psinalizador:

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

Montagem 8086, 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

Se os números estivessem antes dos caracteres no fluxo de entrada, duas linhas (18 caracteres) poderiam ser raspadas.

SED GNU, 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

Precisa ser executado com o -rsinalizador
Pode ser reduzido para 110 + 2, substituindo \vpelo não imprimível 0x0Be \apelo0x07

C, 65 caracteres

Obtém a entrada como um 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'

As regras para contar opções na linha de comando estão aqui .

Quarto, 45 caracteres

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

Testado com pforth no 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])})

Tenho a sensação de que isso pode ser melhorado, especificamente com os elencos de char para string e int, mas não tenho tempo para continuar trabalhando nisso agora.

C, 68 caracteres

A resposta de @ ugoren em C é um pouco mais curta, mas esta resposta está em conformidade com o requisito de que "a string será fornecida como entrada no 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

Minha primeira tentativa real de jogar golfe, provavelmente há alguma melhoria a ser feita aqui.

Japonês -P , 8 bytes

Entrada como uma matriz de caracteres, saída como uma string.

ò crÈpY°

Tente

ò 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 rotação de 20 trit), 4,494e6 bytes

O tamanho desta resposta excede o tamanho máximo do programa postável (eh); portanto, o código está localizado no meu repositório GitHub .

Como executar isso?

Isso pode ser uma parte complicada, porque o intérprete ingênuo de Haskell levará anos e anos para executá-lo. O TIO possui um intérprete decente do Malbogle Unshackled, mas, infelizmente, não poderei usá-lo (limitações).

O melhor que eu pude encontrar é a variante fixa de largura de rotação de 20 trit, que funciona muito bem, descompactando 360 bytes por hora .

Para tornar o intérprete um pouco mais rápido, removi todas as verificações do intérprete Malbolge Unshackled de Matthias Lutter.

Minha versão modificada pode executar cerca de 6,3% mais 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;
}

Está funcionando!

05AB1E , 6 5 bytes

2ι`ÅΓ

-1 byte graças a @Grimy .

Saída como uma lista de caracteres.

Experimente online.

Resposta antiga de 6 bytes sem decodificação em execução:

2ôε`×?

Experimente online.

Explicação:

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 caracteres

d = raw_input ()
print "". join ([x * int (d [i + 1]) para i, x em enumerar (d) se ~ i & 1])

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

GolfScript (10 caracteres)

2/{)15&*}/

J - 24

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

O objetivo desta submissão é usar o infix advérbio.

Befunge, 49 caracteres

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

K, 35

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

Python 2, 58

Isso é inspirado na solução python de Darren Stone - abuso de iterador!

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

Esta é a minha solução original (60 caracteres)

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

Uma abordagem diferente é de três caracteres a mais:

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<_

Espaço em branco, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Substitua S, T, L por caracteres de espaço, tabulação e avanço de linha.)

Experimente online [aqui] .

Explicação:

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

Isso parece excepcionalmente longo por ser Clojure; se alguém puder fazer melhor, publique-o.