Напишите кратчайший код на выбранном вами языке, чтобы выполнить декодирование длины строки для данной строки.
Строка будет предоставлена как ввод на стандартный ввод в виде
CNCNCNCNCNCNCNCN
где каждый Cможет быть любым печатным символом ASCII, и каждый Nявляется цифрой 1до 9(включительно).
Пример ввода:
:144,1'1
Соответствующий вывод:
:4444,'
Ответы:
,[>,>++++++[<-------->-]<[<.>-]<,]
.
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]Режиссура необходимо получить компилятор на самом деле создать финальную сцену.
print<>=~s/(.)(.)/$1x$2/ger
print<>=~s/(.)(.)/$1x$2/ger. Я также вполне уверен, что вы имели в виду $1x$2, а не наоборот.
-pфлага позволит вам сбросить printи <>, таким образом, ответ станет простым: s/(.)(.)/$1x$2/ge-> 17 символов +1 для -p-> 18 .
Python 3 позволяет мне объединить подходы двух моих решений python2.
s=input()
t=''
while s:a,b,*s=s;t+=a*int(b)
print(t)
raw_inputсоответствует Python 3 input. Так что первая строка должна бытьs=input()
s=input() while s:a,b,*s=s;print(a*int(b),end='')
,/{⍺/⍨⍎⍵}/↑T⊂⍨~⎕D∊⍨T←⍞
Объяснение:
T←⍞: сохранить вход в TT⊂⍨~⎕D∊⍨T: разделить Tна символы, которые не являются цифрами↑: Превратить его в 2матрицу с размерностью N/2матрицы{⍺/⍨⍎⍵}/: в каждой строке матрицы ( /), повторить ( /) первый символ ( ⍺) в eval (⍎ ) второго символа ( ⍵),/: объединить вывод каждой строки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 символов) могли бы быть отсечены от этого.
dq 21cdc38821cd08b4 d888ed30c188482c e8ebfce210cd14b453 символов? Я не вижу, где он обрабатывает не заглавные буквы или 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
Необходимо использовать с -rфлагом.
Может быть уменьшено до 110 + 2 путем замены \vна непечатный 0x0Bи \aс0x07
\2.{9}отличная идея) великолепно!
Получает входные данные в качестве параметра.
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'. Есть ли переключатель командной строки?
BEGIN KEY KEY 48 - 0 DO DUP EMIT LOOP 0 UNTIL
Протестировано с pforth на OS X.
print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])
iterэтим ... Думаю, я воспользуюсь им сам!
Ответ @ ugoren на C немного короче, но этот ответ соответствует требованию, что «строка будет предоставлена в качестве входных данных для stdin ».
n;main(c){for(;;){c=getchar(),n=getchar()-48;while(n--)putchar(c);}}
main(c,n){ ... }которые будут переданы 1 по умолчанию при запуске программы.
intаргументом, но компилятор (-ы), которым я пользуюсь, жалуются, error: second parameter of 'main' (argument array) must be of type 'char **'поэтому мне не сойти с рук main(c,n); Я должен использовать main(int c,char **n). Может быть платформой или GCC вещь.
n;main(c)но не main(n,c)- достаточно хорошо! :)
f[]=[]
f(x:y:s)=replicate(read[y])x++f s
main=interact$f
Моя первая настоящая попытка играть в гольф, так что, возможно, здесь есть кое-какое улучшение.
read[y]сохраняет два символа
replicate x yна [1..x]>>[y]. Таким образом, ваша вторая строка может быть заменена на f(x:y:s)=(['1'..y]>>[x])++f s, что сокращает ее до 53 байтов.
-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
ò crÏ°îXесли вы находите это слишком жутким!
Размер этого ответа превышает максимально допустимый размер программы (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;
}
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 newline2ι`ÅΓ5 байт. Было бы грустно, если бы встроенный RLE не выиграл вызов RLE.
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]))
2/{)15&*}/
Это вдохновлено решением 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++;}}}}
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 очень долго, если кто-то может сделать лучше, пожалуйста, опубликуйте его.