Напишите кратчайший код на выбранном вами языке, чтобы выполнить декодирование длины строки для данной строки.

Строка будет предоставлена ​​как ввод на стандартный ввод в виде

CNCNCNCNCNCNCNCN

где каждый Cможет быть любым печатным символом ASCII, и каждый Nявляется цифрой 1до 9(включительно).

Пример ввода:

:144,1'1

Соответствующий вывод:

:4444,'

Brainfuck, 34 персонажа

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

Язык программирования Шекспира , 406 байт

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

Безголовая версия:

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]

Я использую drsam94 Python SPL компилятор , в котором есть несколько ошибок (именно поэтому, например, я использую Open your mindвместо Open thy mindверсии для гольфа).

Чтобы запустить эту программу, используйте:

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

Как это устроено

SPL - это эзотерический язык программирования, разработанный для того, чтобы программы выглядели как пьесы Шекспира. Он делает это, используя символы в качестве переменных, а обработка выполняется, когда персонажи говорят что-то друг другу.

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

Это название пьесы; это игнорируется компилятором.

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

Здесь мы объявляем переменные, используемые в остальной части программы. Все между ,и .игнорируется компилятором. В этом случае мы объявляем Romeo, используется для хранения декодируемого символа, и Julietиспользуется для хранения длины цикла символа.

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

Здесь мы объявляем первый и единственный акт в программе. Акты и сцены похожи на ярлыки; к ним можно перейти в любое время, используя let us return to scene IIили какой-либо вариант этого. Мы используем только один акт, потому что этого достаточно для наших нужд. Опять же, все, что находится между :и .игнорируется компилятором.

Scene I: A silent entrance.

Здесь мы объявляем первую сцену. Сцены нумеруются римскими цифрами: первая есть Scene I, вторая Scene IIи так далее.

[Enter Romeo and Juliet]

Это сценическое направление; в нем, мы говорим о Romeoи Julietпеременные прийти на «стадии». Только две переменные могут быть на «сцене» одновременно; Этап используется для того, чтобы компилятор мог выяснить, к какой переменной относится, когда он говорит. Поскольку у нас есть только две переменные, Ромео и Джульетта останутся на сцене на протяжении всей программы.

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

Объявление другой сцены. На сцену II будет прыгать, чтобы декодировать другую длину цикла.

Juliet:

Эта форма заявления означает, что Джульетта начнет говорить. Все до следующего Romeo:, направления сцены или объявления сцены / акта будет строкой, на которой говорит Джульетта, и, таким образом, «я» будет относиться к Джульетте, «ты» / «ты» к Ромео и т. Д.

Open your mind.

Эта команда сохраняет порядковый номер одного символа из STDIN в Romeo.

Is my mother jollier than thou?

В SPL существительные переводятся в 1 или -1 в зависимости от того, являются ли они положительными или отрицательными. В этом случае my motherпереводится как 1. Прилагательные (положительные или отрицательные) умножают свое существительное на 2.

Это вопрос; в этом Джульетта спрашивает, является ли my mother(AKA 1) «веселее», чем Ромео. Сравнительные данные либо переводятся в less than(если они отрицательные, как worse) или greater than(если они положительные, как jollier). Поэтому этот вопрос сводится к Is 1 greater than you?.

Причина, по которой мы задаем этот вопрос, заключается в обнаружении конца ввода. Поскольку значение EOFзависит от платформы, но обычно меньше 1, мы используем его для его обнаружения.

If so, we must proceed to scene IV.

Если предыдущий вопрос был оценен true, мы переходим к сцене IV, которая является просто концом программы. Короче говоря, если мы обнаруживаем EOF, мы заканчиваем программу.

Romeo:

Теперь это линия Ромео: «я» и «ты» относятся к Ромео и Джульетте соответственно.

Open your mind.

Опять же, этот оператор помещает порядковое значение одного символа из STDIN в Джульетту, которая в этом случае является длиной цикла символа, хранящегося в 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!

Это слишком долго, чтобы переходить к деталям, но поверьте мне, что это переводится как Juliet -= 48. Мы делаем это потому, что Джульетта имеет значение ASCII для числа, и ord('0') == 48; вычитая 48, мы переводим значение ASCII числа в само число.

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

Объявление другой сцены. Это для цикла, в котором мы многократно печатаем значение символа Romeo, Julietраз.

Juliet:
  Speak thy mind.

Это утверждение заставляет Ромео печатать свою ценность как персонажа; то есть, какое бы значение символа не было ранее сохранено в Romeo, теперь выводится.

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

Свинья является отрицательным существительным, поэтому a hogпереводится как -1; следовательно, это утверждение оценивается как Juliet -= 1.

Art thou as rotten as nothing?

Ромео здесь спрашивает, "Джульетта" так же гнилая, как ", или равна 0.

If so, let us return to scene II.

Если значение Джульетты равно 0, мы возвращаемся к сцене II для декодирования длины пробега другого персонажа.

Let us return to scene III.

Иначе, мы возвращаемся к сцене III, чтобы снова вывести персонажа Ромео.

Scene IV: Finale.

[Exeunt]

Это окончательное объявление сцены является просто маркером конца программы. [Exeunt]Режиссура необходимо получить компилятор на самом деле создать финальную сцену.

GolfScript, 10 символов

2/{1/~~*}/

Perl, 27 символов

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 позволяет мне объединить подходы двух моих решений python2.

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

APL (22)

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

Объяснение:

• T←⍞: сохранить вход в T
• T⊂⍨~⎕D∊⍨T: разделить Tна символы, которые не являются цифрами
• ↑: Превратить его в 2матрицу с размерностью N/2матрицы
• {⍺/⍨⍎⍵}/: в каждой строке матрицы ( /), повторить ( /) первый символ ( ⍺) в eval (⍎ ) второго символа ( ⍵)
• ,/: объединить вывод каждой строки

Рубин, 30 байтов

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

27 байтов кода + 3 байта для запуска с -pфлагом:

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

8086 сборка, 106 98 символов

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

Если бы числа были перед символами во входном потоке, две строки (18 символов) могли бы быть отсечены от этого.

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

Необходимо использовать с -rфлагом.
Может быть уменьшено до 110 + 2 путем замены \vна непечатный 0x0Bи \aс0x07

С, 65 символов

Получает входные данные в качестве параметра.

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

Perl, 19 символов 18

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

Правила подсчета ключей в командной строке приведены здесь .

Далее 45 символов

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

Протестировано с pforth на OS X.

Python, 63 62 символа

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

Windows PowerShell, 55 символов

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

У меня такое ощущение, что это может быть улучшено, особенно с помощью приведений от char к string и int, но у меня нет времени продолжать работать над этим прямо сейчас.

C, 68 знаков

Ответ @ ugoren на C немного короче, но этот ответ соответствует требованию, что «строка будет предоставлена ​​в качестве входных данных для stdin ».

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

Haskell, 58 56 символов

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

Моя первая настоящая попытка играть в гольф, так что, возможно, здесь есть кое-какое улучшение.

Japt -P , 8 байт

Ввод в виде массива символов, вывод в виде строки.

ò 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

Malbolge Unshackled (вариант с 20-кратным вращением), 4,494e6 байт

Размер этого ответа превышает максимально допустимый размер программы (eh), поэтому код находится в моем репозитории GitHub .

Как запустить это?

Это может быть непростой задачей, потому что наивному интерпретатору Хаскелла понадобятся годы, чтобы запустить это. У TIO есть достойный интерпретатор Malbogle Unshackled, но, к сожалению, я не смогу его использовать (ограничения).

Лучший вариант, который я смог найти, это фиксированный вариант ширины вращения в 20 трит, который очень хорошо работает, распаковывая 360 байт в час .

Чтобы сделать переводчика немного быстрее, я удалил все проверки из интерпретатора Мэттиласа Люттера «Малболж».

Моя модифицированная версия может работать примерно на 6,3% быстрее.

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

Работает!

05AB1E , 6 5 байт

2ι`ÅΓ

-1 байт благодаря @Grimy .

Выходы в виде списка символов.

Попробуйте онлайн.

Старый 6- байтовый ответ без встроенной функции декодирования длин серий:

2ôε`×?

Попробуйте онлайн.

Объяснение:

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 символов

д = raw_input ()
выведите «». join ([x * int (d [i + 1]) для i, x в перечислении (d), если ~ i & 1])

s = raw_input ()
напечатать "". join (i * int (j) для i, j в zip (s [:: 2], s [1 :: 2]))

GolfScript (10 символов)

2/{)15&*}/

J - 24

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

Смысл этого представления состоит в том, чтобы использовать наречие инфикса.

Befunge, 49 символов

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

К, 35

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

Python 2, 58

Это вдохновлено решением Python Даррена Стоуна - злоупотребление итераторами!

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

Это мое оригинальное решение (60 символов)

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

Другой подход на 3 символа длиннее:

f=lambda a,b,*x:a*int(b)+(x and f(*x)or'')
print f(raw_input())

Ява: 285 чар

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 символа

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

Пробел, 135

LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL

(Замените S, T, L символами пробела, табуляции, перевода строки.)

Попробуйте онлайн [здесь] .

Объяснение:

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

Чувствую себя исключительно как Clojure очень долго, если кто-то может сделать лучше, пожалуйста, опубликуйте его.