Это очень просто: ваша программа или функция должна сгенерировать следующий текст:

Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.

Хорошая печать

Вы можете написать программу или функцию , которая возвращает вывод в виде строки или печатать его в STDOUT (или ближайшую альтернативу). При желании вы можете включить один завершающий символ новой строки в вывод.

счет

Количество байтов в вашем коде, умноженное на количество уникальных байтов в вашем коде

Самый низкий балл побеждает.

Например, ответ «мозговая шутка» или «пробел» имеет здесь огромное преимущество, так как множитель будет очень низким (8 и 3 соответственно). Однако, как правило, написание программ на этих языках дает гораздо более длинный код, который может свести на нет это преимущество.

Стандартные лазейки, которые больше не смешны , запрещены .

code-challenge string kolmogorov-complexity

— durron597
источник

Я предполагаю, что корпус должен быть точным?

— EnragedTanker

@crayzeedude да, в этом

— вся

Хорошо. Просто уточняю. : p

— EnragedTanker

1

@CarpetPython В песочнице было несколько споров по этому поводу, и в итоге я решил, что нет способа НАСТОЯЩИМ выровнять игровое поле. Обратите внимание, что пробелы и бессонница имеют самые высокие оценки в любом случае!

— durron597

2

Как я где-то писал, если мы предположим, что использование большего количества байтов для компенсации менее уникальных символов ведет себя аналогично преобразованию чисел в разные базы, то приблизительно bytecount~Log(X,unique), с некоторой константой X для этой задачи. Таким образом, уникальная константа. Вычисление этой оценки (log2) дает

python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546

. Так что, кроме ответа «

— бред»

7

Бессонница , 575 байт * 4 = 2300

dyedd=dyyyye=d=yd=dddde=ded=deey=eyy=de=edd=eydyee=yeyy=yey==ddyee=eydee=y=eyeedd=dde=yddd=eede=yedde=eeyd==yeyy=yyddy=eyy=dy=dddye=dyey=ede=yddd=dde=de=yyye=yyye=ddyyy=dyy=yeyddy=eyyyde=eed=ddd=yd=edyyd=eeydd=yedd=eye=eee=eeyy=yyyedde=d=eyyyedy=d=yddyye==dyyede=ddd=eydd=yd=ddde==eeeeyy=yeyd=deyy=yyy=ydy=dy=dd=e=ey=dddddy=yeey=ey=eed=ddd=eedy=ddddde=ydeyy=edd=ydy=ddy=yeedd=ydde=dde=edyye=ded=yeed=dddddde=eedy=eyde=ydy=ydydd=eyydd=dd=dddd=ddyye=ydeey=ed=eeeye=y=ydydde=eyyd=eyee=dy=edeyed=dyed==eyyddey=dd=yddd=yddd=de=ddedy=eyydd=eeedy==eyyydeee=d=d=eydd=yey=dyy==yyyedy=

Использует 4 символа dye=.

Решение 1b (не опубликовано): 783 байта * 3 = 2349

eeeeyeeyy=eeyy=yeyye=yyyeeyye=eeeye=yeyey=eyeyyy=eyy=eeyeye=yeyeyyy=yyeeye=yeyy=yey==yyeyeyeye=eyyey=y=yyyyyy=y=eyyeyyyyyyye=eeye=yyeeyye=eyeyeyyy==yeyy=yeyyyeyye=yyyeeyy==eeyyeee==eeyye=yyyyeyyeyyye=yyyyyyy=yeye=eyyyyy=eeye=eeyeeeeey=eyeye=eeee=yeyyye=eyyyyye=y=eeeyyy=eyyeyee=yyy=eyye=yeyeeee=yyeyeyyyy=eeyy=yyyyy=eyyyy=yyeeyye=e=eyyyyy=eyey==eyeyy=yyyyyeyeyeye=ye=yyyyyy==eeeeyy=yeye=yeyyey=yyy=eyyyeeeye==yeeyyeyy=e==yeeeyyyeyy=yeey=ey=eee=eyeyy=yyeeee=yeeyyyyy=yee=yeyyy=yeeeeyy=eyeeeeeye=eeeyy=yyeeeeyyye=yey=yyyyeeyye=yyyyyyy=yeee=eeeeyyeye=eyeeye=eeyyeyyy=eeyee=yyyyyeeyy=eee=eeyyeyyyyy=eeey=eyyeeyy=eyyeyyy=eeeeyeee=eeeye=y=yyyeyy=yyeeee=yyeyey=ey=eyyyyyeyyy=yeye==yeeyyyeyy=yeye=yyyyeeyy=eeeyyeeyyy=yeeyeyyy=eeyye=eee=eyyye==eyeyeyyyyy=e=eeyeeye=yeey=eyeyy=eyeye=ey=eyyeye=

Использует только 3 символа ey=.

Решение 1: 826 байт * 3 = 2478

yoyoy~oyoyo~oyooyy~ooyyoyy~ooyyyyoy~~yoyyo~ooyoooyooo~yoyyo~oyoyoyyy~yyo~oyyoo~~ooooy~oyyyyy~oyoyoo~~oyyyoooyy~~oyoyooyyy~yyooo~yoyo~yoyyyyo~yooyo~y~yyoyyyooyy~oyyooy~ooyoy~oyyooy~ooyyo~yoyyoo~o~ooyo~yooyyoo~yoyoy~ooyyyyooo~oyoyyo~yyoyyyoo~yyo~yyooyyo~yoyyoooy~~yoyyyooyoyy~oyoyyy~yoooyyoy~yooyy~yooyyo~yyooyyoo~oyoyo~oyyy~oyyo~oyyoyo~oyyyoo~oyoyyoo~yooyo~ooooo~~yoyyoyyoyoo~yoyyooo~y~ooooy~yyyoy~ooooyyoyyoy~oyyoo~oyyoyo~yoyyyooy~oyooo~yoyyoyy~yyyyyo~oyooy~oyoyy~yoyyyoy~ooyoy~yoyyoooy~~oyyyo~ooooooy~yooyoyyoyo~yooyyo~oooyyo~yoyooyyo~oyyy~o~yooooy~oyoyyooooy~~yoyyooyyo~oy~yyyoyyyyy~yoyyyoy~yooo~oooy~oooooyyoyyyo~yoyyo~y~oooyyyoyoo~yyooooyoyy~y~oooyyyoy~~yoy~oyyoyoyyy~yoyyyyy~oyooo~yyyyooo~yooyyoy~yooyo~yoyyyo~yyoyyyo~o~ooooooyoy~oyoyyoy~yyoooo~ooooyy~oyoyoy~ooyyo~yyoooyo~yyyyyo~oyyo~yooyyooyyoy~~ooyyyyoyyy~ooyyo~yyooo~

Только использует 3 -х символов: yo~. Программа используется для генерации этого.

В настоящее время все программы используют только инструкции 0, 1, 2, 6. Другими словами, они манипулируют битами в одном байте и распечатывают результат.

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
источник

19

CJam, 266 281 456 байт * 14 12 7 уникально = 3724 3372 3192

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

14301201124204202034420112034224204431020210101232301021240204310431312122132100240400222324402030223103420431324402222132223233141443401210314023001122320404112224314302132421403301243334313000011124244441400003310332301330220022110121411122100040310110020040121444302100143202204330334033211334242120304123121024200421121232100303121022431044444423243331440434010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

объяснение

Стратегия, которую я использовал, состоит в том, чтобы обрабатывать каждый символ в строке как цифру от 123 и кодировать ее как десятичное число в программе. Затем программа преобразует это число обратно в базу 123 и отображает каждую цифру базы 123 обратно в символ. Поскольку трудно объяснить, почему программа находится в ее текущем состоянии, я объясню каждую ее версию.

Вот как выглядел конец программы в первой версии:

...2068438725 123b:c

Это реализует стратегию самым простым способом. Число, обычно кодируемое в базе 10, преобразуется обратно в базу 123, и каждая цифра базы 123 отображается обратно в символ. Но при этом используются 4 уникальных нецифровых символа, и возможность избавиться от любого из них, вероятно, будет стоить такого же размера из-за необходимости использовать менее простой код.

Во- первых, я понял , что я мог бы избавиться от bи от :операторов, создавая их во время выполнения , как их значения символов ASCII преобразуются обратно в символ (с уже настоящим cоператором) и оценивать их с ~оператором. Оказалось, что это немного сложно сделать с :оператором, так как он должен быть проанализирован вместе со следующим cоператором. Я решил это путем создания символов, :а cзатем создания и вычисления символа +, который объединяет первые два символа в строку, :cкоторую затем можно правильно оценить.

Во-вторых, я понял, что у ~оператора, который я только что представил, был новый удобный перегруженный вариант: когда ему присваивается число, он производит побитовое дополнение. Используя это два раза подряд после числа, я мог ввести разрыв токена в источнике без результирующего вычислительного эффекта, что позволило бы мне заменить пробелы, используемые для разделения чисел ~~.

Конечный результат - это еще 15 байт кода в конце, но эта стоимость значительно перевешивается за счет исключения двух уникальных символов из 14. Вот сравнение конца первой версии с концом второй версии:

...2068438725  123[ b  ][   :c    ]
...2068438725~~123~~98c~58c99c43c~~

Использовать меньше двух операторов, которые я использовал, было бы невозможно, но я все же хотел меньше уникальных символов. Поэтому следующим шагом было исключить цифры. Изменив кодировку числа таким образом, чтобы каждая десятичная цифра была действительно цифрой от 5 до 5, я мог бы потенциально исключить цифры 6-9. Прежде чем что-либо удалять из конца пргорама, это выглядело так:

...4010014400 10b5b123b:c

Как упомянуто ранее, устранение места легко. Но b, :и cне было бы так легко, так как их коды символов 98, 58и 99, соответственно. Все они содержали цифры, помеченные для исключения, поэтому мне пришлось искать способы вывести их все. И единственными полезными числовыми операторами со значениями символов, не содержащими 5-9, были декремент, приращение, умножение и сложение.

Для 98, я сначала использовал 100~~40c~40c~, который уменьшает 100вдвое. Но потом я понял, что мог бы использовать ~оператор еще раз, поскольку побитовое дополнение позволяет мне получать отрицательные числа, которые при добавлении позволяют имитировать вычитание. Так что я тогда использовал 100~~1~43c~, который добавляет 100и -2и на 2 байта меньше. Ибо 58я использовал 44~~14~~43c~, что добавляет 44и 14. И для 99, я использовал 100~~40c~, который уменьшает 100.

Конечный результат довольно большой и запутанный, но стоимость значительно большего числа и кода обработки была немного перевешена большим преимуществом исключения 5 уникальных символов из 12. Вот сравнение окончательного завершения программы до исключений и после вылеты:

...4010014400  10[      b      ][  5  ][     b     ]123[      b      ][            :c            ]
...4010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

— Runer112
источник

Хорошо, теперь я впечатлен. Как сравнить цифры 6, 7 и т. Д. С базой 5?

— durron597

@ durron597 Они действительно не делают вычисления проще, так как коды символов операторов мне нужно , ( 98, 58и 99) по - прежнему вне диапазона. И увеличение базы только уменьшает общий размер программы на 8-10%, что недостаточно, чтобы компенсировать 10-15% баллов, полученных за счет нового уникального персонажа. Повторное включение bоператора также не стоит.

— Runer112

Возьмите число x и конвертируйте его в базу b. Его длина будет floor(log_b(x)+1), и он будет содержать bразные символы. Так что счет b*floor(log_b(x)+1). x заданное большое число, и если вы построите это для b, вы обнаружите, что минимум в значительной степени равен b = 3. Т.е. длина уменьшается немного, когда вы используете более высокие основания (log), но размер кодировки увеличивается линейно, так что это того не стоит. Сделал простую пробелную программу, но получил всего 4134 баллов.

— blutorange

@blutorange Вы должны запустить программу для пробелов. 4134 достаточно для второго места

— durron597

16

Пробелы, 1157 937 байт * 3 уникальных = 3471 2811

По популярному (?) Запросу я публикую свое решение для пробелов.

Чтобы уменьшить необходимый код, я жестко закодировал всю строку как одно двоичное число (7 бит на каждый байт). Простой цикл извлекает символы и печатает их.

Исходный код на filebin.ca.

ПРИМЕЧАНИЕ . Спецификации допускают произвольные большие целые числа , но интерпретатор языка Haskell на официальной странице ограничен 20 битами. Используйте, например, этот интерпретатор ruby в github / hostilefork / whitespaces.

Скрипт ruby для создания программы пробелов (l = WHITESPACE, t = TAB, u = NEWLINE, все, что после // игнорируется, записывает в файл prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

def b2ws(bin)
    bin.chars.map{|x|x=='0' ? "l" : "t"}.join
end
def d2ws(dec,pad=0)
    b2ws(dec.to_s(2).rjust(pad,'0'))
end

bin = str.reverse.chars.map do |x|
    "  " + d2ws(x.getbyte(0),7) + " // char <#{x=="\n" ? "LF" : x}>"
end
data = "lll // pushes string as one large number\n#{bin.join("\n")}\nu"

File.open('prog.h','w') do |fout|
    fout << data << "\n"
    fout << <<-eos

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

Для иллюстрации, программа для пробелов в удобочитаемой форме. Ниже приведен простой скрипт для преобразования его в настоящую пробелную программу.

lll // pushes string as one large number
  ltltttl // char <.>
  ttltltt // char <k>
  ttltttt // char <o>
  ttltttt // char <o>
  ttlttll // char <l>
  ltlllll // char < >
  ttllllt // char <a>
  ltlllll // char < >
  ttlltlt // char <e>
  ttlttlt // char <m>
  ltlllll // char < >
  ttllttt // char <g>
  ttltttl // char <n>
  ttltllt // char <i>
  tttlttl // char <v>
  ttltllt // char <i>
  ttllttt // char <g>
  ltlllll // char < >
  ltllltl // char <">
  ltlttll // char <,>
  tlllttt // char <G>
  tlltttt // char <O>
  tllltll // char <D>
  ltlllll // char < >
  tlttllt // char <Y>
  tlttltl // char <Z>
  tlllllt // char <A>
  tllttll // char <L>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltlllll // char < >
  tltlltl // char <R>
  tllltlt // char <E>
  tltlttl // char <V>
  tlltttt // char <O>
  ltlllll // char < >
  tltlltt // char <S>
  tltllll // char <P>
  tllttlt // char <M>
  tltltlt // char <U>
  tlltltl // char <J>
  ltlllll // char < >
  tlttlll // char <X>
  tlltttt // char <O>
  tlllttl // char <F>
  ltlllll // char < >
  tlltttl // char <N>
  tltlttt // char <W>
  tlltttt // char <O>
  tltlltl // char <R>
  tlllltl // char <B>
  ltlllll // char < >
  tlltltt // char <K>
  tlllltt // char <C>
  tlltllt // char <I>
  tltltlt // char <U>
  tltlllt // char <Q>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltllltl // char <">
  ltlllll // char < >
  ltttltl // char <:>
  ltltllt // char <)>
  ttlltlt // char <e>
  ttllltt // char <c>
  ttllllt // char <a>
  ttlltlt // char <e>
  tttllll // char <p>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttlt // char <m>
  ltlllll // char < >
  tttlltl // char <r>
  ttltttt // char <o>
  ttllttl // char <f>
  ltlllll // char < >
  ttttllt // char <y>
  ttlltll // char <d>
  tttlttt // char <w>
  ttltttt // char <o>
  tttlltl // char <r>
  ltlllll // char < >
  ttltttt // char <o>
  ttltttt // char <o>
  tttltll // char <t>
  ltlllll // char < >
  tttltll // char <t>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltltl // char <j>
  ltltlll // char <(>
  ltlllll // char < >
  ttlltll // char <d>
  ttlltlt // char <e>
  tttltll // char <t>
  ttltttt // char <o>
  tttltlt // char <u>
  tttlllt // char <q>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttll // char <l>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltttt // char <o>
  ttltllt // char <i>
  ttttlll // char <x>
  ttltttt // char <o>
  ttltttl // char <n>
  ttllltl // char <b>
  ttltttt // char <o>
  ltlllll // char < >
  ttltlll // char <h>
  tttltll // char <t>
  ttlltlt // char <e>
  ttllltl // char <b>
  ttllllt // char <a>
  ttttltl // char <z>
  ttltllt // char <i>
  ttlttll // char <l>
  tllltlt // char <E>
u

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu

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

Возьмите число x и конвертируйте его в базу b. Его длина будет floor(log_b(x)+1), и он будет содержать bразные символы. Так что счет b*floor(log_b(x)+1). xэто заданное большое число, и если вы построите это для b, вы обнаружите, что минимум почти равен b=3(и b=2почти так же хорош). Т.е. длина уменьшается немного, когда вы используете более высокие основания (log), но размер кодировки увеличивается линейно, так что это того не стоит.

Таким образом, я искал язык только с 0/1, но не нашел ни одного, а потом вспомнил, что есть пробелы, и попробовал его. В пробеле вы можете ввести двоичные числа с 0 и 1 напрямую.

Старый код, хуже оценка, но интереснее

Старый код в filebin .

Сценарий ruby, который я использовал для создания программы (l = WHITESPACE, t = TAB, u = NEWLINE, все после //игнорирования записывает в файл prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.' + "\n"

def shift(x)
    (x-97)%128
end

EOS = "lttltl" #26
STACK = []

bin = str.reverse.chars.map do |x|
    byte = shift(x.getbyte(0))
    rf = STACK.index(byte)
    STACK.unshift(byte)

    y = byte.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
    ph = "lll#{y}u" # pushing directly
    if rf
        bn = rf.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
        cp = "ltll#{bn}u" # copying from stack
    end

    if STACK.size>0 && STACK[0]==STACK[1]
        "lul // dup #{x.inspect}"
    elsif cp && cp.size < ph.size
        "#{cp} // copy <#{x.inspect}> (from #{rf})"
    else
        "#{ph} // push <#{x.inspect}> (#{shift(x.getbyte(0))})"
    end
end

File.open('prog.h','w') do |fout|
    fout << "ll#{EOS}u // push EOS" << "\n"
    fout << bin.join("\n") << "\n"
    fout << <<-eos
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  ll#{EOS}u // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu
    eos
end

Для иллюстрации, программа для пробелов в удобочитаемой форме. Ниже приведен простой скрипт для преобразования его в настоящую пробелную программу.

lllttltlu // push EOS
llltltlltu // push <"\n"> (41)
llltllttltu // push <"."> (77)
llltltlu // push <"k"> (10)
llltttlu // push <"o"> (14)
lul // dup "o"
llltlttu // push <"l"> (11)
lllttttttu // push <" "> (63)
llllu // push <"a"> (0)
ltlltu // copy <" "> (from 1)
llltllu // push <"e"> (4)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
lllttlu // push <"g"> (6)
lllttltu // push <"n"> (13)
llltlllu // push <"i"> (8)
llltltltu // push <"v"> (21)
ltlltu // copy <"i"> (from 1)
lllttlu // push <"g"> (6)
ltllttlu // copy <" "> (from 6)
llltllllltu // push <"\""> (65)
llltlltlttu // push <","> (75)
lllttllttlu // push <"G"> (102)
lllttltttlu // push <"O"> (110)
lllttlllttu // push <"D"> (99)
ltlltltu // copy <" "> (from 5)
lllttttlllu // push <"Y"> (120)
lllttttlltu // push <"Z"> (121)
lllttlllllu // push <"A"> (96)
lllttltlttu // push <"L"> (107)
ltlltllu // copy <" "> (from 4)
lllttlltllu // push <"E"> (100)
lllttlltttu // push <"H"> (103)
llltttllttu // push <"T"> (115)
ltllttu // copy <" "> (from 3)
llltttllltu // push <"R"> (113)
ltlltllu // copy <"E"> (from 4)
llltttltltu // push <"V"> (117)
ltlltttlu // copy <"O"> (from 14)
ltlltllu // copy <" "> (from 4)
llltttlltlu // push <"S"> (114)
lllttlttttu // push <"P"> (111)
lllttlttllu // push <"M"> (108)
llltttltllu // push <"U"> (116)
lllttltlltu // push <"J"> (105)
ltlltltu // copy <" "> (from 5)
llltttltttu // push <"X"> (119)
ltlltlllu // copy <"O"> (from 8)
lllttlltltu // push <"F"> (101)
ltllttu // copy <" "> (from 3)
lllttlttltu // push <"N"> (109)
llltttlttlu // push <"W"> (118)
ltlltllu // copy <"O"> (from 4)
ltlltllltu // copy <"R"> (from 17)
lllttlllltu // push <"B"> (97)
ltlltltu // copy <" "> (from 5)
lllttltltlu // push <"K"> (106)
lllttllltlu // push <"C"> (98)
lllttltlllu // push <"I"> (104)
ltllttttu // copy <"U"> (from 15)
llltttllllu // push <"Q"> (112)
ltlltltu // copy <" "> (from 5)
ltllttlltu // copy <"E"> (from 25)
ltllttttlu // copy <"H"> (from 30)
ltllttttlu // copy <"T"> (from 30)
llltllllltu // push <"\""> (65)
ltlltllu // copy <" "> (from 4)
llltlttlltu // push <":"> (89)
llltlltlllu // push <")"> (72)
llltllu // push <"e"> (4)
llltlu // push <"c"> (2)
llllu // push <"a"> (0)
llltllu // push <"e"> (4)
lllttttu // push <"p"> (15)
ltlltttu // copy <" "> (from 7)
lllttlllu // push <"y"> (24)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
llltllltu // push <"r"> (17)
llltttlu // push <"o"> (14)
llltltu // push <"f"> (5)
ltllttu // copy <" "> (from 3)
ltllttlu // copy <"y"> (from 6)
lllttu // push <"d"> (3)
llltlttlu // push <"w"> (22)
llltttlu // push <"o"> (14)
ltlltttu // copy <"r"> (from 7)
ltlltltu // copy <" "> (from 5)
ltlltlu // copy <"o"> (from 2)
lul // dup "o"
llltllttu // push <"t"> (19)
ltllttu // copy <" "> (from 3)
ltlltu // copy <"t"> (from 1)
llltlltlu // push <"s"> (18)
llltltllu // push <"u"> (20)
llltlltu // push <"j"> (9)
llltllltttu // push <"("> (71)
ltlltltu // copy <" "> (from 5)
lllttu // push <"d"> (3)
llltllu // push <"e"> (4)
ltlltttu // copy <"t"> (from 7)
llltttlu // push <"o"> (14)
ltlltttu // copy <"u"> (from 7)
llltllllu // push <"q"> (16)
ltllttlu // copy <" "> (from 6)
lllttlllu // push <"y"> (24)
llltlttu // push <"l"> (11)
llltlltlu // push <"s"> (18)
ltlltltu // copy <"u"> (from 5)
llltttlu // push <"o"> (14)
llltlllu // push <"i"> (8)
llltltttu // push <"x"> (23)
ltlltlu // copy <"o"> (from 2)
lllttltu // push <"n"> (13)
llltu // push <"b"> (1)
ltlltlu // copy <"o"> (from 2)
ltlltlttu // copy <" "> (from 11)
llltttu // push <"h"> (7)
llltllttu // push <"t"> (19)
llltllu // push <"e"> (4)
llltu // push <"b"> (1)
llllu // push <"a"> (0)
lllttlltu // push <"z"> (25)
llltlllu // push <"i"> (8)
llltlttu // push <"l"> (11)
lllttlltllu // push <"E"> (100)
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  lllttltlu // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu

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

использовать lulдля клонирования стека, когда есть повторяющийся символ
используйте ltlдля клонирования n-й записи стека, если она короче, чем прямое нажатие на символ
сдвинуть все байты на 97 (мод 128), уменьшить двоичные числа

Простой скрипт ruby для преобразования моего читаемого человеком кода в реальную программу (чтение файла prog.hи запись в файл prog.ws):

WHITESPACE = "l"
NEWLINE = "u"
TAB = "t"

File.open('prog.ws','w') do |fout|
    code = ""
    fin = File.read('prog.h')
    fin.each_line do |line|
        line.gsub!(/\/\/.*/,'')
        line.scan(/#{NEWLINE}|#{WHITESPACE}|#{TAB}/i) do |x|

            code << case x.downcase
            when NEWLINE.downcase
                "\n"
            when WHITESPACE.downcase
                " "
            when TAB.downcase
                "\t"
            else
                ""
            end
        end
    end
    fout << code
end

— blutorange
источник

Конечный символ новой строки является необязательным, вы можете сохранить несколько символов, не печатая его.

— durron597

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

— Blutorange

7

Ruby 144 байта * 39 уникальных = 5616

puts"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"#{'the quick brown fox jumps over the lazy dog,'.upcase}\" giving me a look."

Иногда самое простое - лучшее.

— MegaTom
источник

Вы не используете никаких упрощений в данных. Примеры cjam и пробелов получили впечатляющие оценки вместе с некоторыми объяснениями. Даже с бонусом за использование аккуратного кода на вменяемом языке, это слишком много, чтобы придумывать! Может быть, вы можете повторно войти в длину + уникальный конкурс выигрыша.

— Jose_X

6

Brainfuck, 1264 байта * 7 уникальных = 8848

Да, это ужасная оценка.

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

— mbomb007
источник

Я обнаружил, что можно использовать меньше уникальных символов, но длина будет 10795, умножить на 5 = 53975.

— mbomb007

Вы могли бы сделать это только с +.уверенностью, что это будет немного меньше, хотя.

— Captncraig

Используя только +и .я получаю 15018 * 2 = 30,036.

— Captncraig

6

> <> (Рыба) - 578 байт * 8 уникальных = 4624

14121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p

Моя оценка не так конкурентоспособна, как я надеялся, но я подумал, что это решение было достаточно интересным для публикации.

объяснение

Первый раздел кода представляет собой длинную строку из цифр 0-4, которые представляют 3-значное базовое 5 представление для каждого символа в строке. В оставшемся коде используется pоператор Fish, который позволяет редактировать исходный код программы во время ее работы. Используя этот оператор, я смог сгенерировать код Фиша, необходимый для преобразования базовых 5 символов обратно в базовые 10 и их вывода, а затем поместить этот код обратно в исходный код в начале файла до того, как интерпретатор достигнет конца линии и обернуты вокруг. Когда интерпретатор достигает конца строки, код был изменен так:

v4121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p
>55**$5*++ol?!;

Когда код оборачивается и попадает в vоператор, он переходит ко второй строке, попадает в >оператор и переходит к циклу, каждый раз преобразуя кодирование base 5 обратно в значение ascii base 10, а затем выводит это значение. Когда в стеке больше нет значений, ?оператор переходит к ;и программа завершается.

— tallestpurpl
источник

5

7 , 273 байта × 7 уникальных байтов = 1911, неконкурентоспособен (языковые испытания после даты)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Подавить уникальных персонажей

Хорошая печать

счет

Бессонница , 575 байт * 4 = 2300

Решение 1b (не опубликовано): 783 байта * 3 = 2349

Решение 1: 826 байт * 3 = 2478

CJam, 266 281 456 байт * 14 12 7 уникально = 3724 3372 3192

объяснение

Пробелы, 1157 937 байт * 3 уникальных = 3471 2811

Старый код, хуже оценка, но интереснее

Ruby 144 байта * 39 уникальных = 5616

Brainfuck, 1264 байта * 7 уникальных = 8848

> <> (Рыба) - 578 байт * 8 уникальных = 4624

объяснение

7 , 273 байта × 7 уникальных байтов = 1911, неконкурентоспособен (языковые испытания после даты)

Python 2 163 147 145 143 байта * 35 36 35 уникально = 5705 5292 5220 5005

Редактирование:

Python 2, 14508 11700 11088 10164 9486 9746 7860 145 байтов * 36 уникальных = 5220

> <> (Рыба) - 138 байт * 65 уникально = 8970

05AB1E , 380 байт * 11 символов = 4180 баллов

Perl 6, 139 байт * 36 уникальных = 5004

Java 8, 141 байт * 64 уникальных символа = 9,024

Perl 5 , 137 байт * 35 уникальных = 4795

Tcl , 345 байтов, 345 x 13 = 4485

Tcl , 337 байт, 337 x 15 = 5055

Tcl , 329 байт, 329 x 16 = 5264

Tcl , 333 байта, 333 x 16 = 5328

Tcl , 148 байтов, 148 x 37 = 5476

Tcl , 277 байтов, 277 x 21 = 5817

Tcl , 371 байт, 371 x 16 = 5936

Tcl , 401 байт, 401 x 16 = 6416

Tcl , 403 байта, 403 x 16 = 6448

Tcl , 433 байта, 433 x 15 = 6495

Tcl , 473 байта, 473 x 14 = 6622

Tcl , 133 байта, 133 x 60 = 7980