Çok basit: Programınız veya işlevin aşağıdaki metni üretmelidir:

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

İnce baskı

Bir yazabilirsiniz program veya fonksiyon , bir dize veya STDOUT (veya en yakın alternatif) için yazdırmadan olarak çıkış verir. İsteğe bağlı olarak çıktıya tek bir izleyen yeni satır ekleyebilirsiniz.

puanlama

Kodunuzdaki bayt sayısı, kodunuzdaki benzersiz bayt sayısı ile çarpılır.

En düşük puan kazanır.

Örneğin, bir beyin fırtınası veya boşluk cevabı, çarpan çok düşük olacağı için burada büyük bir avantaja sahip olacaktı (sırasıyla 8 ve 3). Ancak, genellikle, bu dillerde programlar yazmak, bu avantajı olumsuz etkileyebilecek daha uzun kodlar üretir.

Komik artık Standart boşluklar vardır yasaklandı .

Uykusuzluk , 575 bayt * 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 karakter kullanır dye=.

Çözüm 1b (yayınlanmamış): 783 bayt * 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=

Sadece 3 karakter kullanır ey=.

Çözüm 1: 826 bayt * 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~

Sadece 3 karakterleri kullanır: yo~. Bunu üretmek için bir program kullanılır.

Şu anda, tüm programlar sadece 0, 1, 2, 6 talimatlarını kullanır. Başka bir deyişle, bitleri tek bir baytta değiştirir ve sonucu yazdırır.

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

Çevrimiçi deneyin.

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

açıklama

Kullandığım strateji, dizedeki her karakteri base-123 rakamı olarak ele almak ve bunu programdaki ondalık sayı olarak kodlamak. Ardından, program bu sayıyı tekrar temel 123'e dönüştürür ve her temel-123 basamağını karaktere geri eşler. Programın neden mevcut durumda olduğunu açıklamak zor olduğundan, her sürümünü açıklayacağım.

İşte programın sonu ilk versiyonda nasıl görünüyordu:

...2068438725 123b:c

Bu, stratejiyi mümkün olan en basit şekilde uygular. Normal olarak 10 tabanına kodlanan sayı, tekrar 123 tabanına dönüştürülür ve her bir baz-123 basamağı, bir karaktere geri eşlenir. Ancak, bu rakam 4 benzersiz rakam içermeyen karakter kullanır ve herhangi birinden kurtulmak, daha az basit kod kullanmak zorunda kaldığından büyük olasılıkla isabet etmeye değecektir.

İlk önce, ASCII karakter değerleri bir karaktere (halihazırdaki operatörle birlikte) bir karaktere (halihazırdaki operatörle birlikte) dönüştürülürken çalışma zamanında bunları oluşturarak bve :operatörlerden kurtulabileceğimi fark ettim . Aşağıdaki operatörle birlikte ayrıştırılması gerektiğinden , operatörle bunu yapmak biraz zor oldu . Ben karakterleri üreterek bu çözüldü ve ardından üreten ve karakterini değerlendirirken dizeye eski iki karakter birleştirir sonra düzgün değerlendirilebilir.c~:c:c+:c

İkincisi, ~henüz tanıttığım operatörün yeni ve aşırı yüklenmiş bir varyantı olduğunu fark ettim : bir sayı verildiğinde, bitsel tamamlayıcıyı üretir. Bir sayıdan sonra üst üste iki kez kullanarak, kaynakta sonuç hesaplama işlemi yapmadan belirteç kırma yapabilir, sayıları ayırmak için kullanılan boşlukları değiştirmeme izin verebilirim ~~.

Nihai sonuç sonunda kodun 15 baytı daha olur, ancak bu maliyet 14'ten 2 benzersiz karakterin elimine edilmesiyle büyük ölçüde ağır basar. İşte ilk sürümün ikinci sürümün sonu ile karşılaştırılması:

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

Kullandığım 2 operatörden daha azını kullanmak imkansız olurdu, ama yine de daha az benzersiz karakter istedim. Böylece bir sonraki adım rakamları ortadan kaldırmaktı. Sayının kodlamasını değiştirerek, her bir ondalık basamağın gerçekten bir temel-5 basamak olmasını sağlayarak, potansiyel olarak 6-9 basamaklarını kaldırabilirim. Prgoramın sonundan bir şey çıkarmadan önce, şöyle görünüyordu:

...4010014400 10b5b123b:c

Daha önce de belirtildiği gibi, alanı ortadan kaldırmak kolaydır. Ama b, :ve conların karakter kodları olarak, o kadar kolay olmazdı 98, 58ve 99sırasıyla. Bunların hepsi eleme için işaretlenmiş rakamları içeriyordu, bu yüzden hepsini elde etmenin yollarını bulmalıydım. Ve 5-9 içermeyen karakter değerlerine sahip tek faydalı sayısal işleçler, azalma, artış, çarpma ve eklemedir.

Çünkü 98başlangıçta iki kere 100~~40c~40c~azaltan kullandım 100. Fakat daha sonra ~operatörün başka bir kullanımını daha kullanabileceğimi farkettim , çünkü bitsel tamamlayıcı eklenirse çıkarmayı taklit etmeme izin veren negatif sayıları almamı sağlıyor. Böylece daha sonra 2 bayt daha küçük 100~~1~43c~olan 100ve ekleyen kullandım -2. Için 58, ben 44~~14~~43c~ekler 44ve kullandım 14. Ve 99kullandım 100~~40c~, hangi azalışları kullandım 100.

Nihai sonuç oldukça büyük ve karışıktır, ancak önemli ölçüde daha büyük sayı ve işlem kodunun maliyeti, 12 karakterden 5 benzersiz karakterin elimine edilmesinin büyük yararı ile biraz daha ağır basılmıştır. eliminasyonları:

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

Boşluk, 1157 937 bayt * 3 benzersiz = 3471 2811

Popüler (?) İsteği ile boşluk çözümümü gönderiyorum.

İhtiyaç duyulan kodu azaltmak için, dizenin tamamını bir ikili sayı olarak kodladım (her bayt için 7 bit). Basit bir döngü karakterleri ayıklar ve yazdırır.

Filebin.ca kaynak kodu.

NOT: Spesifikasyonlar keyfi büyük tam sayılara izin verir , ancak resmi sayfadaki Haskell yorumlayıcısı 20 bit ile sınırlıdır. Örneğin, bu yakut yorumlayıcıyı github / hostilefork / whitespaces üzerinde kullanın.

Boşluk programı oluşturmak için ruby ​​betiği (l = WHITESPACE, t = SEKME, u = NEWLINE, // yoksayılan her şey, bir dosyaya yazar 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

Örnek olarak, boşluk programı insan tarafından okunabilir biçimdedir. Gerçek bir boşluk programına dönüştürmek için basit bir komut dosyası için aşağıya bakın.

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

Temel olarak, çıkacak dize uzun bir tamsayıdır ve puanını azaltmanız gerekir.

X sayısını al ve b tabanına dönüştür. Uzunluğu olacak floor(log_b(x)+1)ve bfarklı semboller içerecektir . Yani skor b*floor(log_b(x)+1). xverilen bir sayıdır ve bunu b için çizerseniz, asgari miktarın oldukça fazla olduğunu b=3(ve b=2neredeyse kadar iyidir) göreceksiniz . Yani, daha yüksek tabanları (kütük) kullandıkça uzunluk biraz azalır, ancak karakter grubunun boyutu doğrusal olarak artar, buna değmez.

Böylece sadece 0 / 1'leri olan bir dil aradım, fakat bir şey bulamadım, sonra boşluğun olduğunu hatırladım ve denedim. Boşlukta, doğrudan 0 ve 1 ile ikili sayıları girebilirsiniz.

Eski kod, daha kötü skor ama daha ilginç

Filebin'deki eski kod .

Programı oluşturmak için kullandığım ruby ​​betiği (l = WHITESPACE, t = SEKME, u = NEWLINE, //ihmal edildikten sonra her şey , bir dosyaya yazar 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

Örnek olarak, boşluk programı insan tarafından okunabilir biçimdedir. Gerçek bir boşluk programına dönüştürmek için basit bir komut dosyası için aşağıya bakın.

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

Bu boşluk programının kendisi oldukça basit, ancak üç golf optimizasyonu var:

• lulyinelenen bir karakter olduğunda yığını klonlamak için kullanın
• ltlchar'ı doğrudan itmekten daha kısa ise yığının n. girişini klonlamak için kullanın .
• Tüm baytları 97 (mod 128) aşağı kaydırmak, ikili sayıları daha küçük hale getirir

İnsan tarafından okunabilen boşluk kodumu gerçek bir boşluk programına dönüştürmek için basit bir yakut komut dosyası (bir dosyayı okuyup bir dosyaya prog.hyazar 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

Ruby 144 Bayt * 39 Benzersiz = 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."

Bazen en basit olanı en iyisidir.

Brainfuck, 1264 bayt * 7 benzersiz = 8848

Evet, çok kötü bir skor.

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

> <> (Balık) - 578 bayt * 8 benzersiz = 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

Puanım umduğum kadar rekabetçi değildi, ancak bu çözümün yayınlanacak kadar ilginç olduğunu düşündüm.

açıklama

Kodun ilk bölümü, dizedeki her karakter için 3 basamaklı bir taban 5 temsilini temsil eden 0-4 basamak uzun bir dizedir. Kalan kod p, program çalışırken programın kaynak kodunu düzenlemenizi sağlayan Balık'taki operatörden yararlanır . Bu operatörü kullanarak, taban 5 karakterlerini taban 10'a geri dönüştürmek için gereken Balık kodunu üretip bunları çıkarıp, yorumlayıcı sonuna ulaşmadan önce bu kodu kaynak koduna geri koydum. Hattın etrafına sarılı. Tercüman satırın sonuna geldiğinde, kod şöyle görünecek şekilde değiştirildi:

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

Kod etrafa dolandığında ve voperatöre çarptığında, ikinci satıra iner, >operatöre çarpar ve döngüye ilerler, her seferinde baz 5 kodunu tekrar baz 10 ascii değerine dönüştürür ve sonra bu değeri verir. Yığında daha fazla değer bulunmadığında, ?operatör operatöre atlayacaktır ;ve program sona erecektir.

7 , 273 bayt × 7 benzersiz bayt = 1911, rekabete aykırı (dil posta günleri mücadelesi)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Çevrimiçi deneyin!

Ne yazık ki, bu eski bir meydan okumadır, yani en yeni dillerden biriyle kazanamayacağım. Bununla birlikte, dil hiçbir zorluk bilgisi olmadan yaratılmıştır (“ilgili sorularda” rastgele rastgele rastladım), ancak yine de mükemmel bir uyum sağladığı ortaya çıktı.

PPCG'deki 7 program normalde paketlenmiş biçimde gönderilir ve sekiz komutu üç bayta paketler (dil on iki komut içerir, ancak kaynak dosyada yalnızca sekiz komut görünebilir, bu da üç bitin yeterli olduğu anlamına gelir). Ancak, dil aynı zamanda her komutun bir ASCII hanesi olarak yazıldığı sekizli bir formatı da destekler ve burada kullandım, yani sadece yedi ayrı baytın kullanıldığı anlamına gelir ( 6komut sadece yazdırılan bir programda gerekli değildir) basit bir dize).

Program çok basit; iki yığın öğesinden oluşur; uzun bir dize, yalnızca 7öğeleri 403yazdırmak için (ne yazık ki kaçınılmazdır), ve sadece 7'ye sabit bir dize 40basmanın basit bir yolu olan ( ikinci yığın öğesinden kaçar, yığının üstü, sonra 3onu yazdırır ve eski birinci yığın öğesini, yani 403kendisini atar .

Peki stringi 269 bayt kadar kısa nasıl aldım? 7 çoklu G / Ç formatlarını destekler ve formatlarından biri, ASCII icat edilmeden önce yaygın olarak kullanılan bir karakter seti (özellikle bir Baudot çeşidi) olan US-TTY'dir . ( 5Bu beş bit karakter kümesi vardır ve komutları, kalan ip içeriği kendisidir., İkinci yığın elemanının başlangıcında, yani, program başlangıcında, dize kodlamasını belirtir) 0için5Sürekli olarak çıkarılmadan dizelerde güvenle saklanabilir (böylece bir kez kaçmak orijinali tam olarak çoğaltacaktır), böylece dil US-TTY'nin karakterlerini kodlamak için komut çiftlerini (36 seçenek) kullanır (4 seçenek için 4 seçenek kullanılır) 7 tercümanın kendisine direktifler). Elbette, insanların çıktısını almak isteyebilecekleri 32'den fazla benzersiz karakter var (ve dizede 32'den fazla karakter var), bu yüzden karakterlerden ikisi dört karakter kümesi (büyük harfler, küçük harfler) arasında geçiş yapan "shift kodları" dır. , rakamlar ve diğer karakter setlerinde bulunmayan kalan ASCII karakterleri için 7'nin kullandığı kullanıcı tanımlı bir "rakam uzantısı" dır, ancak karakter dizisindeki tüm karakterler US-TTY’de "yerel" olur. uzatma önemli değildi). İşte'

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

Oldukça ihmal edilebilir bir oran olan 124 karakter girişine eklenen 10 vardiya sayıyorum. Bu nedenle, giriş karakteri başına yalnızca iki bayttan fazla giriş, 7 kez benzersiz bayt kullanma yeteneği, bu zorluktaki puanın inanılmaz derecede iyi olduğu anlamına gelir. (Sanırım bu zorluk için özel olarak tasarlanan bir dil, önceden var olan bir karakter dizisinden ziyade bir çeşit string sıkıştırma kullanacaktı, ancak Baudot ve US-TTY golf oynamak için tasarlanmamış olsalar bile, hala oldukça özlü .)

Python 2, 163 147 145 143 bayt * 35 36 35 benzersiz = 5705 5292 5220 5005

Muhtemelen alacağım kadar iyi.

Düzenlemeler:

1. .capitalize()Kullanarak lehine kaldırıldı E.
2. 'Ters eğik çizgi çıkış tırnakları yerine kullanmak için değiştirildi .
3. Kaldırıldı +ve printifadede virgül kullanılacak bazı alanlar .

print"Elizabeth obnoxiously quoted (just too rowdy for my peace):",'"the quick brown fox jumps over the lazy dog,"'.upper(),"giving me a look."

Python 2,14508 11700 11088 10164 9486 9746 7860 145 bayt * 36 benzersiz = 5220

Ünvanı gördüm ve bunun oldukça wordy Python için ilginç bir zorluk olduğunu düşündüm. Bunlar bu problemin üstesinden geldiğim gibi notlarım.

İlk denemem benzersiz olanı 31'e indirdi:

print''.join(chr([69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46][r])for r in range(124))

Daha iyisini yapabileceğimi düşündüm. Kullanarak map, benzersiz 26'ya indi:

print''.join(map(chr,(69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46)))

Bu sırada soru metninde puanın uniques * bytessadece benzersiz olmadığını fark ettim ! Bu, yukarıdaki puanlarımın 14508 ve 11700 olduğu anlamına geliyordu. Çok rekabetçi değil. Bu yüzden şimdi metni onaltılık bir dize olarak saklayarak baytları azaltıyorum:

# 308*36 = 11088
print''.join(chr(int('456c697a6162657468206f626e6f78696f75736c792071756f74656420286a75737420746f6f20726f77647920666f72206d79207065616365293a202254484520515549434b2042524f574e20464f58204a554d5053204f56455220544845204c415a5920444f472c2220676976696e67206d652061206c6f6f6b2e'[i*2:i*2+2],16)) for i in range(124))

Boyut küçüldü, ancak daha eşsiz karakterlere sahipti. Ancak, 32 ofset ile paketlenmiş 2 basamaklı bir ondalık sayı kullanırsam:

# 308*33 = 10164
print''.join(chr(int('37767390656669847200796678798873798583768900818579846968000874858384008479790082798768890070798200778900806965676909260002524037004953413543003450475546003847560042534548510047543750005240370044335857003647391202007173867378710077690065007679797514'[i*2:i*2+2])+32) for i in range(124))

Bu aynı bayt sayısına sahiptir ancak 3 benzersiz tasarruf sağlar.

Yeni bir plan çiziyorum. 7 bit karakterli bir Python uzun tamsayı toplarsam, her birini kaydırarak çıkarabilirim:

# 306*31 = 9486
h=1073974643401006528619595312441225198653732186368270382545648881135648217524502741093886285232362673460172159947573049818819511630304840724474679255867143965214892747087773876949021986013520804726327302180335979259392708372721217579101211940864406962137554744750
w=''
while h:w=chr(h&127)+w;h>>=7
print w

Bu skoru 9486'ya düşürdü. İlginç bir deney, ancak hiçbir yerde yeterince iyi değil. Şimdi, fonksiyon isimlerinden kurtulur ve string formatlamaya güvenirsem ne olur?

# 443 * 22 = 9746
print('%c'*124)%(69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46)

Şimdi sadece 22 benzersiz var, ama puan düzelmiyor.

Tamam, bariz şekilde yürüdüysem ve sadece ipi basarsam:

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

7860 puan. Bunu önce yapmalıydım. Fakat çok fazla şey öğrenemezdim.

Sanırım üst kısımdaki parçaları dinamik olarak üretersem, benzersiz sayıları 26 azaltabilirim.

# 145*36 = 5220
print'Elizabeth obnoxiously quoted (just too rowdy for my peace): '+'"the quick brown fox jumps over the lazy dog,"'.upper()+' giving me a look.'

Python’un 5220’den daha iyi olmayacağını düşünüyorum. Python’daki benzersiz karakterleri küçültme görevi kesinlikle öğretici oldu.

Güncelleme: mbomb007 5005 puanlama daha iyi bir Python çözümü var. Güzel iş.

> <> (Balık) - 138 Bayt * 65 Benzersiz = 8970

Basit rota, yani Merhaba Dünya:

!v'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'r!
 >l?!;o

Eh, benim ilk baskı için> <> bu zordu. Sanırım bazı gelişmeler görüyorum ama bunu öğrenmek eğlenceliydi :)

Veya aşırı karmaşık hale getirmek için - 1567 bytes * 27 Unique = 42309

!\f8+3*:o2*f2*-:o3-:of+2+:ofa+-:o1+:o3+:of+:oc-:o\7+:od-:oc+:o1+:o9+: of-:o6+:o6+:o2-:o7-: od+:o\8-:o4+:o6-:o5+:of -:o1-:o\\6+:ob+ :o2-:o1+:o\:o5-:o:o\3+ :o3-:o8+:of4+-:oab ++:o\f4+-:o9+ :o3+: o\!
!5:of+a+:o1-:off+2+o:f-6-oa-:o8-:of3*1-:oa-:o2-:!fo3*7+:o2+:o:d+o:o5!f+:o7-:off+2+o6+:o8-!f:off!f+2+o4-:off+2+ob+!f:o3+::\ff    f f          f        f  f                  f    f        f     \!f-
 -                                               f                   f                    f     f                 f       ff    3 f          f        f  f                  f    f        f       f
 :                                               +                   +                    +     +                 +       ++    * +          +        +  +                  +    +        +       +
 o                                               2                   2                    2     2                 2       2a    1 2          2        2  2                  2    2        2       2
 c                                               +                   +                    +     +                 +       ++    + +          +        +  +                  +    +        +       +
 +                                               o                   o                    o     o                 o      \oo4-o \ o;         o        o  o                  o    o        o       o
 \:off+2+o9-:ob-:o4-:o2+:o2+:of4*%:of2++:o2,3+:o2 +:o3*f-3-:oc-:o3-:o\c+:o4+:oc-:o6-:o8+:o\9-:of 1++:o3-:o8+:o9-:o\8-:o9+:  o9+: o\e-:ob+:o8- :o3+:o3+ :o\4-:o7+:o2-f-:od+:o\2+:o c-:o3-:o\7+:ob\

05AB1E , 380 bayt * 11 karakter = 4180 puan

Bu potansiyel olarak yarışmacı değil

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Çevrimiçi deneyin!

Birleştirilen ASCII karakterlerinin taban 5 gösterimini iter.
3 parça halinde böler, tekrar ondalık basamağa dönüştürür.
ASCII tamsayısını karaktere geri döndürür.
Tekrar bir araya gelir.

Perl 6, 139 bayt * 36 benzersiz = 5004

say 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "'~"the quick brown fox jumps over the lazy dog".uc~'," giving me a look.'

Java 8, 141 bayt * 64 benzersiz karakter = 9.024

()->{return"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG,\" giving me a look.";}

141 bayt, 64 benzersiz karakter. Basit "string string" dışındaki yaklaşımlar, kullanılan karakterlerden fazla tasarruf etmeden byte sayısını arttırır.

Perl 5 , 137 bayt * 35 benzersiz = 4795

say'Elizabeth obnoxiously quoted (just too rowdy for my peace): "',uc'the quick brown fox jumps over the lazy dog','," giving me a look.'

Çevrimiçi deneyin!

Tcl , 345 bayt, 345 x 13 = 4485

\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 \50\\\144\\\144\51 "055451724142456450 5742565770515765635471 616557644544 \5052656364 645757 6257674471 465762 5571 6045414345\51\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Çevrimiçi deneyin!

\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\\144\\\144) "055451724142456450 5742565770515765635471 616557644544 (52656364 645757 6257674471 465762 5571 6045414345)\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Çevrimiçi deneyin!

\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\d\\d) "055451724142456450 5742565770515765635471 6165576445d (52656364 645757 625767d71 465762 5571 6045414345)\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Çevrimiçi deneyin!

\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\d\\d) "055451724142456450 5742565770515765635471 6165576445d \5052656364 645757 625767d71 465762 5571 6045414345\51\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Çevrimiçi deneyin!

puts "Elizabeth obnoxiously quoted (just too rowdy for my peace): \"[string tou "the quick brown fox jumps over the lazy dog"],\" giving me a look."

Çevrimiçi deneyin!

\160u\164s [subs\164 [\162\145\147sub \55\141\154\154 (\\d\\d) "0554517241b456450 ob56o7051ous5471 61uo6445d(52us64 64oo 62o67d71 46o62 5571 6045414345): 241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\" 475166515647 5545 41 54oo53" \\\\1\\1]]\56

Çevrimiçi deneyin!

puts "\105\154\151\172\141\142\145t\150 o\142\156o\170\151ous\154\171 \161uot\145\144 \50\152ust too \162o\167\144\171 \146o\162 \155\171 p\145\141\143\145\51\72 \"\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\" \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Çevrimiçi deneyin!

puts "\105\154\151\172\141\142\145\164\150 o\142\156o\170\151o\165\163\154\171 \161\165o\164\145\144 \50\152\165\163\164 \164oo \162o\167\144\171 \146o\162 \155\171 \160\145\141\143\145\51\72 \"\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\" \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Çevrimiçi deneyin!

puts "\105\154\151\172\141\142\145\164\150 o\142\156o\170\151o\165\163\154\171 \161\165o\164\145\144 \50\152\165\163\164 \164oo \162o\167\144\171 \146o\162 \155\171 \160\145\141\143\145\51\72 \42\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\42 \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Çevrimiçi deneyin!

puts "\105\154\151\172\141\142\145\164\150 \157\142\156\157\170\151\157\165\163\154\171 \161\165\157\164\145\144 \50\152\165\163\164 \164\157\157 \162\157\167\144\171 \146\157\162 \155\171 \160\145\141\143\145\51\72 \42\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\42 \147\151\166\151\156\147 \155\145 \141 \154\157\157\153\56"

Çevrimiçi deneyin!

Tcl , 473 bayt, 473 x 14 = 6622

puts \105\154\151\172\141\142\145\164\150\40\157\142\156\157\170\151\157\165\163\154\171\40\161\165\157\164\145\144\40\50\152\165\163\164\40\164\157\157\40\162\157\167\144\171\40\146\157\162\40\155\171\40\160\145\141\143\145\51\72\40\42\124\110\105\40\121\125\111\103\113\40\102\122\117\127\116\40\106\117\130\40\112\125\115\120\123\40\117\126\105\122\40\124\110\105\40\114\101\132\131\40\104\117\107\54\42\40\147\151\166\151\156\147\40\155\145\40\141\40\154\157\157\153\56

Çevrimiçi deneyin!

Tcl , 133 bayt, 133 x 60 = 7980

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

Çevrimiçi deneyin!