Ini sangat sederhana: Program atau fungsi Anda harus menghasilkan teks berikut:

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

Cetak halus

Anda dapat menulis sebuah program atau fungsi , yang mengembalikan output sebagai string atau mencetaknya ke STDOUT (atau alternatif terdekat). Anda dapat secara opsional memasukkan satu baris baru dalam output.

Mencetak gol

Jumlah byte dalam kode Anda dikalikan dengan jumlah byte unik dalam kode Anda

Skor terendah menang.

Misalnya, jawaban brainfuck atau spasi putih akan memiliki keuntungan besar di sini, karena pengali akan sangat rendah (masing-masing 8 dan 3). Namun, umumnya, menulis program dalam bahasa-bahasa tersebut menghasilkan kode yang jauh lebih lama yang dapat meniadakan keuntungan itu.

Celah standar yang tidak lagi lucu yang dilarang .

code-challenge string kolmogorov-complexity

— durron597
sumber

Saya berasumsi bahwa casing harus tepat?

— EnragedTanker

@crayzeedude ya, itu intinya

— durron597

Baik. Hanya mengklarifikasi. : p

— EnragedTanker

1

@CarpetPython Ada beberapa perdebatan tentang hal ini di kotak pasir, dan akhirnya saya memutuskan tidak ada cara untuk BENAR-BENAR tingkatkan lapangan bermain. Perhatikan bahwa spasi putih dan insomnia tetap memiliki skor tertinggi!

— durron597

2

Seperti yang saya tulis di suatu tempat, jika kita mengasumsikan bahwa menggunakan lebih banyak byte untuk mengkompensasi karakter yang kurang unik berperilaku sama dengan mengubah angka menjadi basis yang berbeda, maka kira-kira bytecount~Log(X,unique), dengan X beberapa konstanta untuk masalah ini. Jadi unik ^ bytecount ~ konstan. Menghitung skor ini (log2) memberi

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

. Jadi kecuali untuk jawaban brainfuck, itu relatif konstan ...

— blutorange

7

Insomnia , 575 byte * 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=

Menggunakan 4 karakter dye=.

Solusi 1b (tidak dipublikasikan): 783 byte * 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=

Hanya menggunakan 3 karakter ey=.

Solusi 1: 826 byte * 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~

Hanya menggunakan 3 karakter: yo~. Suatu program digunakan untuk menghasilkan ini.

Saat ini, semua program hanya menggunakan instruksi 0, 1, 2, 6. Dengan kata lain, mereka memanipulasi bit dalam satu byte dan mencetak hasilnya.

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
sumber

19

CJam, 266 281 456 byte * 14 12 7 unik = 3724 3372 3192

Cobalah online.

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

Penjelasan

Strategi yang saya gunakan adalah memperlakukan setiap karakter dalam string sebagai digit basis-123 dan menyandikannya sebagai angka desimal dalam program. Program kemudian mengonversi angka itu kembali ke basis 123 dan memetakan setiap basis-123 digit kembali ke karakter. Karena sulit menjelaskan mengapa program ini dalam kondisi saat ini, saya akan menjelaskan setiap versi.

Beginilah akhir dari program pada versi pertama:

...2068438725 123b:c

Ini mengimplementasikan strategi dengan cara yang paling mudah. Angka, yang dikodekan secara normal dalam basis 10, dikonversi kembali ke basis 123 dan setiap digit basis-123 dipetakan kembali ke sebuah karakter. Tetapi ini menggunakan 4 karakter non-digit yang unik, dan mampu menghilangkan salah satu dari mereka kemungkinan akan sebanding dengan ukurannya karena harus menggunakan kode yang lebih sederhana.

Pertama, saya menyadari bahwa saya dapat menyingkirkan bdan :operator dengan menciptakan mereka pada saat runtime sebagai nilai karakter ASCII mereka dikonversi kembali ke karakter (dengan coperator yang sudah ada ) dan mengevaluasi mereka dengan ~operator. Ternyata agak sulit untuk melakukan ini dengan :operator, karena harus diurai bersama dengan coperator berikut . Saya memecahkan ini dengan menghasilkan karakter :dan ckemudian memproduksi dan mengevaluasi karakter +, yang menggabungkan dua karakter sebelumnya ke dalam string :cyang kemudian dapat dievaluasi dengan benar.

Kedua, saya menyadari bahwa ~operator yang baru saja saya perkenalkan memiliki varian kelebihan muatan baru yang praktis: ketika diberi nomor, ia menghasilkan komplemen bitwise. Dengan menggunakan ini dua kali berturut-turut setelah angka, saya bisa memperkenalkan token break pada sumber tanpa efek komputasi yang dihasilkan, memungkinkan saya untuk mengganti spasi yang digunakan untuk memisahkan angka ~~.

Hasil akhirnya adalah 15 byte lebih banyak kode pada akhirnya, tetapi biaya ini jauh lebih besar daripada manfaat menghilangkan 2 karakter unik dari 14. Berikut adalah perbandingan akhir versi pertama dengan akhir versi kedua:

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

Menggunakan kurang dari 2 operator yang saya gunakan tidak mungkin, tetapi saya masih menginginkan lebih sedikit karakter unik. Jadi langkah selanjutnya adalah menghilangkan angka. Dengan mengubah pengkodean angka sehingga setiap angka desimal benar-benar angka dasar-5, saya berpotensi menghilangkan angka 6-9. Sebelum menghilangkan apapun dari ujung prgoram, itu terlihat seperti ini:

...4010014400 10b5b123b:c

Seperti yang disebutkan sebelumnya, menghilangkan ruang itu mudah. Tapi b, :, dan ctidak akan begitu mudah, karena kode karakter mereka 98, 58dan 99masing-masing. Semua ini berisi digit yang ditandai untuk dihilangkan, jadi saya harus menemukan cara untuk mendapatkan semuanya. Dan satu-satunya operator numerik yang berguna dengan nilai karakter yang tidak mengandung 5-9 adalah pengurangan, penambahan, gandakan, dan tambahkan.

Karena 98, saya awalnya menggunakan 100~~40c~40c~, yang menurun 100dua kali. Tetapi kemudian saya menyadari bahwa saya dapat menggunakan ~operator ini lagi, karena komplemen bitwise memungkinkan saya mendapatkan angka negatif yang, ketika ditambahkan, biarkan saya meniru pengurangan. Jadi saya kemudian menggunakan 100~~1~43c~, yang menambah 100dan -2dan 2 byte lebih kecil. Untuk 58, saya menggunakan 44~~14~~43c~, yang menambah 44dan 14. Dan untuk 99, saya menggunakan 100~~40c~, yang menurun 100.

Hasil akhirnya cukup besar dan membingungkan, tetapi biaya dari jumlah yang signifikan lebih besar dan kode pemrosesan sedikit lebih besar daripada manfaat besar menghilangkan 5 karakter unik dari 12. Berikut adalah perbandingan akhir akhir program sebelum eliminasi dan setelah eliminasi:

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

Ok, sekarang saya terkesan. Bagaimana basis 6 digit, basis 7 digit, dll. Dibandingkan dengan basis 5?

— durron597

@ durron597 Mereka tidak benar-benar membuat perhitungan lebih mudah, sebagai kode karakter dari operator saya perlu ( 98, 58, dan 99) masih di luar jangkauan. Dan menambah basis hanya mengurangi ukuran total program sebesar 8-10%, yang tidak cukup untuk menebus skor 10-15% yang diperoleh dengan memiliki karakter unik yang baru. Memasukkan ulang boperator juga tidak sepadan.

— Runer112

Ambil angka x, dan ubah menjadi basis b. Panjangnya akan floor(log_b(x)+1), dan itu akan berisi bsimbol yang berbeda. Jadi nilainya b*floor(log_b(x)+1). x adalah angka besar yang diberikan, dan jika Anda plot ini untuk b, Anda akan menemukan minimum cukup banyak pada b = 3. Yaitu, panjangnya berkurang sedikit ketika Anda menggunakan basis yang lebih tinggi (log), tetapi ukuran charset meningkat secara linear, sehingga tidak sepadan. Membuat program spasi putih sederhana, tetapi hanya mendapat skor 4134.

— blutorange

@blutorange Anda harus memasang program spasi putih. 4134 sudah cukup untuk tempat kedua

— durron597

16

Spasi, 1157 937 byte * 3 unik = 3471 2811

Dengan permintaan populer (?), Saya memposting solusi spasi putih saya.

Untuk mengurangi kode yang diperlukan, saya meng-hardcode seluruh string sebagai satu nomor biner (7 bit untuk setiap byte). Sebuah loop sederhana mengekstraksi karakter dan mencetaknya.

Kode sumber di filebin.ca.

CATATAN: Spesifikasi memungkinkan untuk bilangan bulat besar yang sewenang-wenang , tetapi juru bahasa Haskell pada halaman resmi dibatasi hingga 20 bit. Gunakan, misalnya, penerjemah ruby ini di ruang github / hostilefork / whites.

Skrip ruby untuk membuat program spasi putih (l = WHITESPACE, t = TAB, u = NEWLINE, semuanya setelah // diabaikan, menulis ke file 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

Sebagai ilustrasi, program spasi putih dalam bentuk yang dapat dibaca manusia. Lihat di bawah ini untuk skrip sederhana untuk mengubahnya menjadi program spasi putih yang sebenarnya.

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

Pada dasarnya, string ke output adalah bilangan bulat panjang, dan Anda perlu mengurangi nilainya.

Ambil angka x, dan ubah menjadi basis b. Panjangnya akan floor(log_b(x)+1), dan itu akan berisi bsimbol yang berbeda. Jadi nilainya b*floor(log_b(x)+1). xadalah angka besar yang diberikan, dan jika Anda plot ini untuk b, Anda akan menemukan minimum cukup banyak b=3(dan b=2hampir sama baiknya). Yaitu, panjangnya berkurang sedikit ketika Anda menggunakan basis yang lebih tinggi (log), tetapi ukuran charset meningkat secara linear, sehingga tidak sepadan.

Jadi saya mencari bahasa dengan hanya 0/1, tapi saya tidak menemukannya, dan kemudian saya ingat ada spasi putih dan mencobanya. Di spasi putih, Anda dapat memasukkan angka biner dengan 0 dan 1 secara langsung.

Kode lama, skor lebih buruk tetapi lebih menarik

Kode lama pada filebin .

Skrip ruby yang saya gunakan untuk membuat program (l = WHITESPACE, t = TAB, u = NEWLINE, semuanya setelah //diabaikan, menulis ke file 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

Sebagai ilustrasi, program spasi putih dalam bentuk yang dapat dibaca manusia. Lihat di bawah ini untuk skrip sederhana untuk mengubahnya menjadi program spasi putih yang sebenarnya.

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

Program spasi putih ini sendiri agak sederhana, tetapi ada tiga optimasi golf:

gunakan luluntuk mengkloning tumpukan ketika ada karakter duplikat
gunakan ltluntuk mengkloning entri ke-n stack jika lebih pendek daripada mendorong char secara langsung
menggeser ke bawah semua byte dengan 97 (mod 128), membuat angka biner lebih kecil

Skrip ruby sederhana untuk mengonversi kode spasi putih yang dapat dibaca manusia menjadi program spasi putih yang sebenarnya (baca file prog.hdan tulis ke file 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
sumber

Baris baru tambahan bersifat opsional, Anda dapat menyimpan beberapa karakter dengan tidak mencetaknya.

— durron597

Terima kasih, ubahlah. Awalnya, saya memasukkannya karena interpreter Haskell menambahkan beberapa output debug, tetapi dengan ruby, itu terlihat bersih.

— blutorange

7

Ruby 144 Bytes * 39 Unique = 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."

Terkadang yang paling sederhana adalah yang terbaik.

— MegaTom
sumber

Anda tidak menggunakan penyederhanaan dalam data. Contoh-contoh cjam dan spasi putih mendapat skor mengesankan bersama dengan beberapa penjelasan. Bahkan dengan bonus untuk menggunakan kode rapi dalam bahasa yang waras, terlalu banyak alasan untuk berbaikan !!! Mungkin Anda bisa masuk kembali dalam kontes penilaian panjang + unik.

— Jose_X

6

Brainfuck, 1264 byte * 7 unik = 8848

Ya, itu skor yang mengerikan.

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

— mbomb007
sumber

Saya menemukan bahwa mungkin untuk menggunakan lebih sedikit karakter unik, tetapi panjangnya adalah 10795, kali 5 = 53975.

— mbomb007

Anda bisa melakukannya dengan hanya +.tidak yakin itu akan menjadi lebih kecil.

— captncraig

Hanya menggunakan +dan .saya mendapatkan 15018 * 2 = 30,036.

— captncraig

6

> <> (Ikan) - 578 byte * 8 unik = 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

Skor saya tidak kompetitif seperti yang saya harapkan, tetapi saya pikir solusi ini masih cukup menarik untuk dikirim.

Penjelasan

Bagian pertama dari kode adalah string panjang dari digit 0-4 yang mewakili representasi basis 5 digit 3 untuk setiap karakter dalam string. Kode yang tersisa mengambil keuntungan dari poperator di Fish yang memungkinkan Anda untuk mengedit kode sumber program saat program sedang berjalan. Dengan menggunakan operator itu, saya dapat menghasilkan kode Ikan yang diperlukan untuk mengubah basis 5 karakter kembali ke basis 10 dan mengeluarkannya, dan kemudian memasukkan kode itu kembali ke kode sumber di awal file sebelum penerjemah mencapai akhir. dari garis dan melilit. Ketika penerjemah mencapai akhir baris, kode telah dimodifikasi agar terlihat seperti ini:

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

Ketika kode membungkus dan mengenai voperator, ia turun ke baris kedua, mengenai >operator dan berlanjut ke loop, setiap kali mengubah basis 5 mengkodekan kembali ke nilai ascii basis 10 dan kemudian mengeluarkan nilai itu. Ketika tidak ada lagi nilai pada stack, ?operator akan melompat ke ;dan program akan berakhir.

— tallestpurpl
sumber

5

7 , 273 byte × 7 byte unik = 1911, nonkompetisi (tantangan tanggal kiriman bahasa)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Pertahankan karakter unik

Cetak halus

Mencetak gol

Insomnia , 575 byte * 4 = 2300

Solusi 1b (tidak dipublikasikan): 783 byte * 3 = 2349

Solusi 1: 826 byte * 3 = 2478

CJam, 266 281 456 byte * 14 12 7 unik = 3724 3372 3192

Penjelasan

Spasi, 1157 937 byte * 3 unik = 3471 2811

Kode lama, skor lebih buruk tetapi lebih menarik

Ruby 144 Bytes * 39 Unique = 5616

Brainfuck, 1264 byte * 7 unik = 8848

> <> (Ikan) - 578 byte * 8 unik = 4624

Penjelasan

7 , 273 byte × 7 byte unik = 1911, nonkompetisi (tantangan tanggal kiriman bahasa)

Python 2, 163 147 145 143 byte * 35 36 35 unik = 5705 5292 5220 5005

Suntingan:

Python 2, 14508 11700 11088 10164 9486 9746 7860 145 byte * 36 unique = 5220

> <> (Ikan) - 138 Bytes * 65 Unique = 8970

05AB1E , 380 byte * 11 karakter = skor 4180

Perl 6, 139 byte * 36 unik = 5004

Java 8, 141 byte * 64 karakter unik = 9.024

Perl 5 , 137 byte * 35 unik = 4795

Tcl , 345 byte, 345 x 13 = 4485

Tcl , 337 byte, 337 x 15 = 5055

Tcl , 329 byte, 329 x 16 = 5264

Tcl , 333 byte, 333 x 16 = 5328

Tcl , 148 byte, 148 x 37 = 5476

Tcl , 277 byte, 277 x 21 = 5817

Tcl , 371 byte, 371 x 16 = 5936

Tcl , 401 byte, 401 x 16 = 6416

Tcl , 403 byte, 403 x 16 = 6448

Tcl , 433 byte, 433 x 15 = 6495

Tcl , 473 byte, 473 x 14 = 6622

Tcl , 133 byte, 133 x 60 = 7980