To bardzo proste: Twój program lub funkcja powinna wygenerować następujący tekst:

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

Drobnym drukiem

Możesz napisać program lub funkcję , która zwraca dane wyjściowe jako ciąg znaków lub wypisuje je do STDOUT (lub najbliższej alternatywy). Opcjonalnie możesz dołączyć jeden końcowy znak nowej linii do wyniku.

Punktacja

Liczba bajtów w kodzie pomnożona przez liczbę unikalnych bajtów w kodzie

Najniższy wynik wygrywa.

Na przykład uderzenie mózgu lub odpowiedź na spację miałaby tutaj ogromną przewagę, ponieważ mnożnik byłby bardzo niski (odpowiednio 8 i 3). Generalnie jednak pisanie programów w tych językach tworzy znacznie dłuższy kod, co może zneutralizować tę zaletę.

Standardowe luki, które nie są już śmieszne, są zakazane .

code-challenge string kolmogorov-complexity durron597
źródło

Zakładam, że obudowa musi być dokładna?

EnragedTanker

@crayzeedude tak, właśnie o to chodzi

durron597

W porządku. Po prostu wyjaśniam. : p

EnragedTanker

1

@CarpetPython Odbyła się debata na ten temat w piaskownicy, i ostatecznie zdecydowałem, że nie ma PRAWDZIWEGO wyrównania pola gry. Zauważ, że białe znaki i bezsenność i tak mają najwyższe wyniki!

durron597

2

Jak już gdzieś napisałem, jeśli założymy, że użycie większej liczby bajtów w celu skompensowania mniej unikalnych znaków zachowuje się podobnie do przekształcania liczb na różne zasady, to w przybliżeniu bytecount~Log(X,unique), przy X pewnej stałej dla tego problemu. W ten sposób unikalna ^ bytecount ~ stała. Obliczenie tego wyniku (log2) daje

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

. Tak więc, z wyjątkiem odpowiedzi na

pieprzenie mózgu

7

Bezsenność , 575 bajtów * 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=

Wykorzystuje 4 znaki dye=.

Rozwiązanie 1b (niepublikowane): 783 bajtów * 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=

Używa tylko 3 znaków ey=.

Rozwiązanie 1: 826 bajtów * 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~

Używa tylko 3 znaki: yo~. Do wygenerowania tego służy program.

Obecnie wszystkie programy używają tylko instrukcji 0, 1, 2, 6. Innymi słowy, manipulują bitami w jednym bajcie i wypisują wynik.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨d̷̰̀ĥ̷̳
źródło

19

CJam, 266 281 456 bajtów * 14 12 7 unikatowych = 3724 3372 3192

Wypróbuj online.

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

Wyjaśnienie

Strategia, którą zastosowałem, polega na traktowaniu każdego znaku w łańcuchu jako cyfry podstawowej 123 i kodowania go jako liczby dziesiętnej w programie. Następnie program konwertuje tę liczbę z powrotem na bazę 123 i odwzorowuje każdą cyfrę 123 z powrotem na znak. Ponieważ trudno jest wyjaśnić, dlaczego program jest w obecnym stanie, wyjaśnię każdą jego wersję.

Oto jak wyglądał koniec programu w pierwszej wersji:

...2068438725 123b:c

To wdraża strategię w najprostszy możliwy sposób. Liczba normalnie zakodowana w bazie 10 jest konwertowana z powrotem na bazę 123, a każda cyfra z bazy 123 jest odwzorowywana z powrotem na znak. Ale wykorzystuje 4 unikalne znaki niecyfrowe, a możliwość pozbycia się któregokolwiek z nich byłaby prawdopodobnie warta trafionego rozmiaru ze względu na konieczność użycia mniej prostego kodu.

Po pierwsze, zdałem sobie sprawę, że mogę pozbyć się ba :operatorami, tworząc je w czasie wykonywania jako ich wartości ASCII przekształcany z powrotem do postaci (z już obecnego coperatora) i ocenę ich z ~operatorem. Wykonanie tego z :operatorem okazało się nieco trudne , ponieważ musi zostać przeanalizowane razem z następującym coperatorem. Rozwiązałem to, tworząc znaki, :a cnastępnie tworząc i oceniając znak +, który łączy poprzednie dwa znaki w łańcuch, :cktóry można następnie poprawnie ocenić.

Po drugie, zdałem sobie sprawę, że ~operator, który właśnie wprowadziłem, miał przydatny nowy, przeciążony wariant: po podaniu liczby tworzy bitowe uzupełnienie. Używając tego dwa razy z rzędu po numerze, mogłem wprowadzić przerwanie tokena w źródle bez żadnego wynikowego efektu obliczeniowego, pozwalając mi zastąpić spacje używane do oddzielania liczb ~~.

Ostateczny wynik to 15 bajtów kodu na końcu, ale koszt ten znacznie przewyższa korzyść polegająca na wyeliminowaniu 2 unikalnych znaków z 14. Oto porównanie końca pierwszej wersji z końcem drugiej wersji:

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

Używanie mniej niż dwóch operatorów, których używałem, byłoby niemożliwe, ale nadal chciałem mniej unikalnych postaci. Kolejnym krokiem było wyeliminowanie cyfr. Zmieniając kodowanie liczby, tak aby każda cyfra dziesiętna była naprawdę cyfrą podstawową 5, mogłabym potencjalnie wyeliminować cyfry 6-9. Przed wyeliminowaniem czegokolwiek z końca prgoramu wyglądało to tak:

...4010014400 10b5b123b:c

Jak wspomniano wcześniej, eliminacja przestrzeni jest łatwa. Ale b, :i cnie będzie tak łatwe, jak ich kody znaków są 98, 58i 99, odpowiednio. Wszystkie zawierały cyfry oznaczone do eliminacji, więc musiałem znaleźć sposób, aby je wszystkie wyprowadzić. Jedynymi przydatnymi operatorami numerycznymi o wartościach znaków niezawierających 5-9 były: zmniejszanie, zwiększanie, mnożenie i dodawanie.

Ponieważ 98początkowo użyłem 100~~40c~40c~, który zmniejsza 100dwukrotnie. Ale potem zdałem sobie sprawę, że mogę jeszcze raz użyć ~operatora, ponieważ bitowe uzupełnienie pozwala mi uzyskać liczby ujemne, które po dodaniu pozwalają emulować odejmowanie. Więc następnie wykorzystane 100~~1~43c~, który dodaje, 100i -2a wynosi 2 bajty mniejsze. Dla 58użyłem 44~~14~~43c~, która dodaje 44i 14. I dla 99, użyłem 100~~40c~, które dekrety 100.

Ostateczny wynik jest dość duży i zaciemniony, ale koszt znacznie większej liczby i kodu przetwarzania nieznacznie przewyższył dużą korzyść polegającą na wyeliminowaniu 5 unikatowych znaków z 12. Oto porównanie końcowego końca programu przed eliminacjami i po eliminacje:

...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
źródło

Ok, teraz jestem pod wrażeniem. W jaki sposób podstawa 6 cyfr, podstawa 7 cyfr itp. Wypada w porównaniu do podstawy 5?

durron597

@ durron597 Oni naprawdę nie sprawiają, że obliczenia łatwiejsze, jak kody znaków operatorów muszę ( 98, 58, i 99) są wciąż poza zasięgiem. Zwiększenie bazy tylko zmniejsza całkowity rozmiar programu o 8-10%, co nie wystarcza, aby zrekompensować wynik 10-15% uzyskany dzięki nowej, wyjątkowej postaci. bPodobnie ponowne włączenie operatora nie jest tego warte.

Runer112

Weź liczbę x i przekonwertuj ją na bazę b. Jego długość będzie wynosić floor(log_b(x)+1)i będzie zawierać bróżne symbole. Więc wynik jest b*floor(log_b(x)+1). x jest daną dużą liczbą, a jeśli spiszesz to dla b, przekonasz się, że minimum wynosi b = 3. To znaczy, długość zmniejsza się nieznacznie, gdy używasz wyższych zasad (log), ale rozmiar zestawu znaków rośnie liniowo, więc nie jest tego warte. Utworzono prosty program do białych znaków, ale otrzymuje on jedynie wynik 4134.

blutorange

@blutorange Powinieneś zainstalować program białych znaków. 4134 wystarczy na drugie miejsce

durron597

16

Biała spacja, 1157 937 bajtów * 3 unikalna = 3471 2811

Według popularnego (?) Żądania publikuję moje rozwiązanie białych znaków.

Aby zredukować potrzebny kod, zakodowałem cały ciąg jako jedną liczbę binarną (7 bitów na każdy bajt). Prosta pętla wydobywa znaki i drukuje je.

Kod źródłowy na filebin.ca.

UWAGA: Specyfikacje dopuszczają dowolne duże liczby całkowite , ale interpreter Haskell na oficjalnej stronie jest ograniczony do 20 bitów. Użyj na przykład tego interpretera ruby na github / hostilefork / white spaces.

Skrypt ruby do tworzenia programu białych znaków (l = WHITESPACE, t = TAB, u = NEWLINE, wszystko po // zignorowane, zapisuje do pliku 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

Na przykład program białych znaków w formie czytelnej dla człowieka. Poniżej znajduje się prosty skrypt do przekonwertowania go na rzeczywisty program do białych znaków.

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

Zasadniczo ciąg do wyprowadzenia jest długą liczbą całkowitą i musisz zmniejszyć jego wynik.

Weź liczbę x i przekonwertuj ją na bazę b. Jego długość będzie wynosić floor(log_b(x)+1)i będzie zawierać bróżne symbole. Więc wynik jest b*floor(log_b(x)+1). xjest daną dużą liczbą, a jeśli spiszesz to dla b, przekonasz się, że minimum wynosi prawie b=3(i b=2jest prawie tak samo dobre). To znaczy, długość zmniejsza się nieznacznie, gdy używasz wyższych zasad (log), ale rozmiar zestawu znaków rośnie liniowo, więc nie jest tego warte.

Tak więc szukałem języka zawierającego tylko 0/1, ale go nie znalazłem, a potem przypomniałem sobie, że jest spacja i wypróbowałem go. W białych znakach możesz bezpośrednio wprowadzać liczby binarne za pomocą zer i jedynek.

Stary kod, gorszy wynik, ale bardziej interesujący

Stary kod na bin pliku .

Skrypt ruby, którego użyłem do utworzenia programu (l = WHITESPACE, t = TAB, u = NEWLINE, wszystko po //zignorowaniu zapisuje do pliku 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

Na przykład program białych znaków w formie czytelnej dla człowieka. Poniżej znajduje się prosty skrypt do przekonwertowania go na rzeczywisty program do białych znaków.

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

Sam program białych znaków jest dość prosty, ale istnieją trzy optymalizacje gry w golfa:

użyj, lulaby sklonować stos, gdy jest zduplikowany znak
użyj, ltlaby sklonować n-ty stos stosu, jeśli jest on krótszy niż bezpośrednie pchnięcie znaku
przesunięcie wszystkich bajtów w dół o 97 (mod 128), zmniejsza liczby binarne

Prosty skrypt ruby do konwersji mojego czytelnego dla człowieka kodu białych znaków na rzeczywisty program białych znaków (odczyt pliku prog.hi zapis do pliku 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
źródło

Końcowy znak nowej linii jest opcjonalny, możesz zapisać kilka znaków, nie drukując go.

durron597

Dzięki, zmieniłem to. Pierwotnie załączyłem go, ponieważ interpreter Haskell dodał trochę danych wyjściowych do debugowania, ale w przypadku ruby wygląda to czysto.

blutorange

7

Rubinowy 144 bajtów * 39 Unikalny = 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."

Czasami najprostsze jest najlepsze.

MegaTom
źródło

Nie używasz żadnych uproszczeń w danych. Przykłady cjam i białych znaków uzyskały imponujące wyniki wraz z kilkoma objaśnieniami. Nawet z premią za używanie uporządkowanego kodu w zdrowym języku, to zbyt wiele do zrobienia! Może możesz ponownie wziąć udział w konkursie na długość + unikalne punkty.

Jose_X

6

Brainfuck, 1264 bajtów * 7 unikalnych = 8848

Tak, to okropny wynik.

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

mbomb007
źródło

Odkryłem, że można użyć mniejszej liczby unikalnych znaków, ale długość wynosiłaby 10795 razy 5 = 53975.

mbomb007

możesz to zrobić, ale +.nie jestem pewien, czy będzie mniejszy.

captncraig

Używam tylko +i .otrzymuję 15018 * 2 = 30,036.

captncraig

6

> <> (Ryby) - 578 bajtów * 8 unikalnych = 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

Mój wynik nie jest tak konkurencyjny, jak się spodziewałem, ale myślałem, że to rozwiązanie jest jeszcze wystarczająco interesujące, aby opublikować.

Wyjaśnienie

Pierwsza sekcja kodu to długi ciąg cyfr 0-4, który reprezentuje 3-cyfrową reprezentację podstawy 5 dla każdego znaku w ciągu. Pozostały kod korzysta z poperatora w Fish, który pozwala edytować kod źródłowy programu podczas jego działania. Korzystając z tego operatora, byłem w stanie wygenerować kod Fish niezbędny do konwersji podstawowych 5 znaków z powrotem na bazę 10 i wyprowadzenie ich, a następnie umieścić ten kod z powrotem w kodzie źródłowym na początku pliku, zanim interpreter dotrze do końca linii i owinięty wokół. Gdy interpreter dojdzie do końca linii, kod został zmodyfikowany tak, aby wyglądał następująco:

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?!;

Gdy kod zawija się i uderza voperatora, przechodzi do drugiej linii, uderza >operatora i przechodzi do pętli, za każdym razem konwertując kodowanie podstawy 5 z powrotem na wartość ascii podstawy 10, a następnie wyprowadzając tę wartość. Gdy na stosie nie będzie już więcej wartości, ?operator przejdzie do ;i program się zakończy.

tallestpurpl
źródło

5

7 , 273 bajtów × 7 unikalnych bajtów = 1911, niekonkurencyjne (wyzwanie dla postdate)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Trzymaj unikalne postacie w dół

Drobnym drukiem

Punktacja

Odpowiedzi:

Bezsenność , 575 bajtów * 4 = 2300

Rozwiązanie 1b (niepublikowane): 783 bajtów * 3 = 2349

Rozwiązanie 1: 826 bajtów * 3 = 2478

CJam, 266 281 456 bajtów * 14 12 7 unikatowych = 3724 3372 3192

Wyjaśnienie

Biała spacja, 1157 937 bajtów * 3 unikalna = 3471 2811

Stary kod, gorszy wynik, ale bardziej interesujący

Rubinowy 144 bajtów * 39 Unikalny = 5616

Brainfuck, 1264 bajtów * 7 unikalnych = 8848

> <> (Ryby) - 578 bajtów * 8 unikalnych = 4624

Wyjaśnienie

7 , 273 bajtów × 7 unikalnych bajtów = 1911, niekonkurencyjne (wyzwanie dla postdate)

Python 2, 163 147 145 143 bajtów * 35 36 35 unikalny = 5705 5292 5220 5005

Edycje:

Python 2, 14508 11700 11088 10164 9486 9746 7860 145 bajtów * 36 unikalny = 5220

> <> (Ryby) - 138 bajtów * 65 Unikalne = 8970

05AB1E , 380 bajtów * 11 znaków = 4180 punktów

Perl 6, 139 bajtów * 36 unikalny = 5004

Java 8, 141 bajtów * 64 unikalnych znaków = 9 024

Perl 5 , 137 bajtów * 35 unikalny = 4795

Tcl , 345 bajtów, 345 x 13 = 4485

Tcl , 337 bajtów, 337 x 15 = 5055

Tcl , 329 bajtów, 329 x 16 = 5264

Tcl , 333 bajty, 333 x 16 = 5328

Tcl , 148 bajtów, 148 x 37 = 5476

Tcl , 277 bajtów, 277 x 21 = 5817

Tcl , 371 bajtów, 371 x 16 = 5936

Tcl , 401 bajtów, 401 x 16 = 6416

Tcl , 403 bajty, 403 x 16 = 6448

Tcl , 433 bajty, 433 x 15 = 6495

Tcl , 473 bajtów, 473 x 14 = 6622

Tcl , 133 bajty, 133 x 60 = 7980