Rất đơn giản: Chương trình hoặc chức năng của bạn sẽ tạo ra văn bản sau:

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

Bản đẹp

Bạn có thể viết một chương trình hoặc hàm , trả về đầu ra dưới dạng một chuỗi hoặc in nó thành STDOUT (hoặc thay thế gần nhất). Bạn có thể tùy ý bao gồm một dòng mới duy nhất trong đầu ra.

Chấm điểm

Số lượng byte trong mã của bạn nhân với số byte duy nhất trong mã của bạn

Điểm số thấp nhất chiến thắng.

Ví dụ, một câu trả lời Brainfuck hoặc khoảng trắng sẽ có lợi thế rất lớn ở đây, vì hệ số nhân sẽ rất thấp (tương ứng 8 và 3). Tuy nhiên, nhìn chung, việc viết chương trình bằng các ngôn ngữ đó tạo ra mã dài hơn nhiều có thể phủ nhận lợi thế đó.

Sơ hở tiêu chuẩn mà không còn vui được cấm .

Mất ngủ , 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=

Sử dụng 4 ký tự dye=.

Giải pháp 1b (chưa được công bố): 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=

Chỉ sử dụng 3 ký tự ey=.

Giải pháp 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~

Chỉ sử dụng 3 ký tự : yo~. Một chương trình được sử dụng để tạo ra điều này.

Hiện tại, tất cả các chương trình chỉ sử dụng các hướng dẫn 0, 1, 2, 6. Nói cách khác, chúng thao tác các bit trong một byte đơn và in ra kết quả.

CJam, 266 281 456 byte * 14 12 7 duy nhất = 3724 3372 3192

Hãy thử trực tuyến.

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

Giải trình

Chiến lược tôi đã sử dụng là coi mỗi ký tự trong chuỗi là một chữ số cơ sở 123 và mã hóa thành số thập phân trong chương trình. Chương trình sau đó chuyển đổi số đó trở về cơ sở 123 và ánh xạ từng chữ số cơ sở 123 trở lại thành một ký tự. Bởi vì thật khó để giải thích tại sao chương trình ở trạng thái hiện tại, tôi sẽ giải thích từng phiên bản của chương trình.

Đây là kết thúc của chương trình trong phiên bản đầu tiên:

...2068438725 123b:c

Điều này thực hiện chiến lược theo cách đơn giản nhất có thể. Số, được mã hóa bình thường trong cơ sở 10, được chuyển đổi trở lại cơ sở 123 và mỗi chữ số cơ sở 123 được ánh xạ trở lại thành một ký tự. Nhưng điều này sử dụng 4 ký tự không có chữ số duy nhất và có thể loại bỏ bất kỳ một trong số chúng có thể có giá trị kích thước do phải sử dụng mã ít đơn giản hơn.

Đầu tiên, tôi nhận ra rằng tôi có thể loại bỏ bcác :toán tử và toán tử bằng cách tạo chúng khi chạy khi các giá trị ký tự ASCII của chúng được chuyển đổi thành ký tự (với ctoán tử đã có ) và đánh giá chúng với ~toán tử. Hóa ra là một chút khó khăn để làm điều này với :toán tử, vì nó phải được phân tích cú pháp cùng với ctoán tử sau . Tôi đã giải quyết điều này bằng cách tạo ra các ký tự :, csau đó tạo và đánh giá ký tự +, nối hai ký tự trước đó thành chuỗi :ccó thể được đánh giá đúng.

Thứ hai, tôi nhận ra rằng ~toán tử mà tôi vừa giới thiệu có một biến thể quá tải mới tiện dụng: khi được cung cấp một số, nó tạo ra phần bù bit. Bằng cách sử dụng hai lần liên tiếp sau một số, tôi có thể đưa ra một sự phá vỡ mã thông báo trong nguồn mà không có hiệu ứng tính toán kết quả, cho phép tôi thay thế các khoảng trắng được sử dụng để tách các số bằng ~~.

Kết quả cuối cùng là thêm 15 byte mã ở cuối, nhưng chi phí này vượt xa rất nhiều nhờ lợi ích của việc loại bỏ 2 ký tự duy nhất trong số 14. Đây là so sánh kết thúc của phiên bản đầu tiên với cuối phiên bản thứ hai:

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

Sử dụng ít hơn 2 toán tử tôi đang sử dụng là không thể, nhưng tôi vẫn muốn có ít ký tự duy nhất. Vì vậy, bước tiếp theo là loại bỏ các chữ số. Bằng cách thay đổi mã hóa của số để mỗi chữ số thập phân thực sự là một chữ số cơ bản 5, tôi có khả năng loại bỏ các chữ số 6-9. Trước khi loại bỏ bất cứ thứ gì từ cuối prgoram, nó trông như thế này:

...4010014400 10b5b123b:c

Như đã đề cập trước đây, loại bỏ không gian là dễ dàng. Nhưng b, :và csẽ không được dễ dàng như vậy, như mã nhân vật của họ 98, 58và 99, tương ứng. Tất cả đều chứa các chữ số được đánh dấu để loại bỏ, vì vậy tôi phải tìm cách rút ra tất cả. Và các toán tử số hữu ích duy nhất có giá trị ký tự không chứa 5-9 là giảm, tăng, nhân và thêm.

Đối với 98, tôi ban đầu sử dụng 100~~40c~40c~, mà giảm 100hai lần. Nhưng sau đó tôi nhận ra rằng tôi có thể sử dụng ~toán tử khác, vì phần bù bit cho phép tôi nhận được các số âm mà khi thêm vào, hãy để tôi mô phỏng phép trừ. Vì vậy, sau đó tôi đã sử dụng 100~~1~43c~, nó thêm 100và -2nhỏ hơn 2 byte. Đối với 58, tôi đã sử dụng 44~~14~~43c~, trong đó thêm 44và 14. Và cho 99, tôi đã sử dụng 100~~40c~, mà giảm 100.

Kết quả cuối cùng là khá lớn và bị xáo trộn, nhưng chi phí cho số lượng lớn hơn và mã xử lý lớn hơn một chút so với lợi ích lớn của việc loại bỏ 5 ký tự duy nhất trong số 12. Đây là so sánh kết thúc cuối cùng của chương trình trước khi loại bỏ và sau loại bỏ:

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

Khoảng trắng, 1157 937 byte * 3 unique = 3471 2811

Theo yêu cầu phổ biến (?), Tôi đang đăng giải pháp khoảng trắng của mình.

Để giảm mã cần thiết, tôi đã mã hóa toàn bộ chuỗi dưới dạng một số nhị phân (7 bit cho mỗi byte). Một vòng lặp đơn giản trích xuất các ký tự và in chúng.

Mã nguồn trên filebin.ca.

GHI CHÚ: Các thông số kỹ thuật cho phép các số nguyên lớn tùy ý , nhưng trình thông dịch Haskell trên trang chính thức bị giới hạn ở 20 bit. Sử dụng, ví dụ, trình thông dịch ruby ​​này trên github / hostilefork / whitespaces.

Tập lệnh ruby ​​để tạo chương trình khoảng trắng (l = WHITESPACE, t = TAB, u = NEWLINE, mọi thứ sau // bị bỏ qua, ghi vào tệp 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

Để minh họa, chương trình khoảng trắng ở dạng người có thể đọc được. Xem bên dưới để biết một kịch bản đơn giản để chuyển đổi nó thành một chương trình khoảng trắng thực tế.

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

Về cơ bản, chuỗi đầu ra là một số nguyên dài và bạn cần giảm điểm của nó.

Lấy một số x và chuyển đổi nó thành cơ sở b. Chiều dài của nó sẽ là floor(log_b(x)+1), và nó sẽ chứa bcác biểu tượng khác nhau. Vì vậy, điểm số là b*floor(log_b(x)+1). xlà một số lượng lớn nhất định và nếu bạn vẽ biểu đồ này cho b, bạn sẽ thấy mức tối thiểu là khá nhiều b=3(và b=2gần như là tốt). Tức là, độ dài giảm đi một chút khi bạn sử dụng các cơ sở (log) cao hơn, nhưng kích thước của bộ ký tự tăng tuyến tính, vì vậy nó không đáng.

Do đó, tôi đã tìm một ngôn ngữ chỉ có 0/1, nhưng tôi không tìm thấy ngôn ngữ nào, và sau đó tôi nhớ có khoảng trắng và thử nó. Trong khoảng trắng, bạn có thể nhập trực tiếp các số nhị phân với 0 và 1.

Mã cũ, điểm kém hơn nhưng thú vị hơn

Mã cũ trên filebin .

Tập lệnh ruby ​​tôi đã sử dụng để tạo chương trình (l = WHITESPACE, t = TAB, u = NEWLINE, mọi thứ sau khi //bị bỏ qua, ghi vào tệp 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

Để minh họa, chương trình khoảng trắng ở dạng người có thể đọc được. Xem bên dưới để biết một kịch bản đơn giản để chuyển đổi nó thành một chương trình khoảng trắng thực tế.

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

Bản thân chương trình khoảng trắng này khá đơn giản, nhưng có ba tối ưu hóa chơi gôn:

• sử dụng lulđể sao chép ngăn xếp khi có một ký tự trùng lặp
• sử dụng ltlđể sao chép mục nhập thứ n của ngăn xếp nếu nó ngắn hơn việc đẩy trực tiếp char
• thay đổi tất cả các byte xuống 97 (mod 128), làm cho các số nhị phân nhỏ hơn

Một tập lệnh ruby ​​đơn giản để chuyển đổi mã khoảng trắng có thể đọc được của con người tôi thành một chương trình khoảng trắng thực tế (đọc một tệp prog.hvà ghi vào một tệp 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 byte * 39 Duy nhất = 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."

Đôi khi đơn giản nhất là tốt nhất.

Brainfuck, 1264 byte * 7 duy nhất = 8848

Vâng, đó là một số điểm khủng khiếp.

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

> <> (Cá) - 578 byte * 8 unique = 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

Điểm của tôi không cạnh tranh như tôi mong đợi, nhưng tôi nghĩ giải pháp này vẫn đủ thú vị để đăng.

Giải trình

Phần đầu tiên của mã là một chuỗi dài gồm các chữ số 0-4 đại diện cho biểu diễn 5 chữ số cơ sở 3 cho mỗi ký tự trong chuỗi. Mã còn lại tận dụng ptoán tử trong Fish cho phép bạn chỉnh sửa mã nguồn của chương trình trong khi chương trình đang chạy. Bằng cách sử dụng toán tử đó, tôi có thể tạo mã Fish cần thiết để chuyển đổi các ký tự cơ sở 5 trở lại cơ sở 10 và xuất chúng, sau đó đưa mã đó trở lại mã nguồn ở đầu tệp trước khi trình thông dịch kết thúc của dòng và quấn quanh. Khi trình thông dịch đến cuối dòng, mã đã được sửa đổi để trông như thế này:

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

Khi mã bao quanh và chạm vào vtoán tử, nó đi xuống dòng thứ hai, chạm vào >toán tử và tiến hành vòng lặp, mỗi lần chuyển đổi mã hóa cơ sở 5 trở lại giá trị ascii cơ sở 10 và sau đó xuất giá trị đó. Khi không còn giá trị nào trên ngăn xếp, ?toán tử sẽ bỏ qua ;và chương trình sẽ kết thúc.

7 , 273 byte × 7 byte duy nhất = 1911, không lọc (thách thức postdates ngôn ngữ)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Hãy thử trực tuyến!

Thật không may, đây là một thách thức cũ, có nghĩa là tôi không thể giành chiến thắng với một trong những ngôn ngữ mới nhất của mình. Tuy nhiên, ngôn ngữ được tạo ra mà không có kiến ​​thức về thử thách (tôi chỉ tình cờ tìm thấy nó trong "các câu hỏi liên quan"), nhưng dù sao cũng có khá nhiều điều phù hợp.

7 chương trình trên PPCG thường được gửi ở định dạng đóng gói, đóng gói tám lệnh thành ba byte (ngôn ngữ có mười hai lệnh, nhưng chỉ tám chương trình có thể xuất hiện trong tệp nguồn, nghĩa là ba bit là đủ). Tuy nhiên, ngôn ngữ cũng hỗ trợ định dạng bát phân trong đó mỗi lệnh được viết dưới dạng chữ số ASCII và đó là những gì tôi đã sử dụng ở đây, có nghĩa là chỉ có bảy byte riêng biệt được sử dụng ( 6lệnh không cần thiết trong chương trình chỉ in một chuỗi đơn giản).

Chương trình rất đơn giản; nó bao gồm hai thành phần ngăn xếp, một chuỗi dài vừa được in nguyên văn, một 7để tách các thành phần (không may là không thể tránh khỏi) và 403đó là cách đơn giản để in một chuỗi không đổi trong 7 ( 40thoát khỏi phần tử ngăn xếp thứ hai, trong khi di chuyển nó sang trên cùng của ngăn xếp, sau đó 3in nó và loại bỏ phần tử ngăn xếp đầu tiên cũ, tức là 403chính nó).

Vậy làm thế nào tôi có được chuỗi ngắn tới 269 byte? 7 hỗ trợ nhiều định dạng I / O và một trong các định dạng của nó là US-TTY , một bộ ký tự (cụ thể là một biến thể của Baudot) được sử dụng rộng rãi trước khi ASCII được phát minh. (Phần 5đầu của phần tử ngăn xếp thứ hai, tức là phần đầu của chương trình, chỉ định mã hóa của chuỗi; phần còn lại là chính nội dung chuỗi.) Đó là một bộ ký tự năm bit và các lệnh 0để5có thể được lưu trữ an toàn trong các chuỗi trong khi không bị ngắt kết nối một cách nhất quán (để thoát khỏi nó một lần sẽ tái tạo chính xác bản gốc), vì vậy ngôn ngữ sử dụng các cặp lệnh (36 tùy chọn) để mã hóa các ký tự của US-TTY (32 tùy chọn, với 4 được sử dụng cho chỉ thị cho 7 phiên dịch viên). Tất nhiên, có hơn 32 ký tự duy nhất mà mọi người có thể muốn xuất ra (và hơn 32 ký tự xuất hiện trong chuỗi), vì vậy hai trong số các ký tự là "mã dịch chuyển" chuyển đổi giữa bốn bộ ký tự (chữ hoa, chữ thường , số liệu và "phần mở rộng số liệu" do người dùng xác định, 7 sử dụng cho các ký tự ASCII còn lại không có trong các bộ ký tự khác, tuy nhiên, tất cả các ký tự trong chuỗi đều "nguyên bản" trong US-TTY, vì vậy các chi tiết về phần mở rộng không thành vấn đề). Đây'

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

Tôi đếm mười ca được thêm vào 124 ký tự đầu vào, một tỷ lệ khá không đáng kể. Như vậy, khả năng chỉ sử dụng hơn hai byte đầu vào cho mỗi ký tự đầu vào, gấp 7 byte duy nhất, có nghĩa là điểm số trong thử thách này là cực kỳ tốt. (Tôi đoán một ngôn ngữ được thiết kế dành riêng cho thử thách này sẽ sử dụng một số kiểu nén chuỗi, thay vì một bộ ký tự có sẵn, nhưng ngay cả khi Baudot và US-TTY không được thiết kế để chơi gôn, chúng vẫn khá súc tích .)

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

Điều đó có lẽ tốt như tôi sẽ có được nó.

Chỉnh sửa:

1. Loại bỏ có .capitalize()lợi cho việc sử dụng E.
2. Thay đổi để sử dụng 'thay vì dấu gạch chéo thoát dấu ngoặc kép.
3. Đã xóa +và một số khoảng trắng để sử dụng dấu phẩy trong printcâu lệnh.

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 byte * 36 unique = 5220

Tôi đã nhìn thấy tiêu đề và nghĩ rằng đây là một thử thách thú vị cho Python khá dài dòng. Đây là những ghi chú của tôi khi tôi giải quyết vấn đề này.

Lần thử đầu tiên của tôi đã giảm số lượng xuống còn 31:

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))

Tôi nghĩ rằng tôi có thể làm tốt hơn. Bằng cách sử dụng map, cổ vật đã giảm xuống còn 26:

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)))

Vào khoảng thời gian này, tôi nhận thấy trong văn bản câu hỏi rằng điểm số uniques * bytes, không chỉ là sự kỳ lạ! Điều đó có nghĩa là điểm số của tôi ở trên là 14508 và 11700. Không cạnh tranh lắm. Vì vậy, bây giờ tôi giảm các byte bằng cách lưu trữ văn bản dưới dạng chuỗi hex:

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

Kích thước đã giảm nhưng nhân vật độc đáo hơn. Nhưng nếu tôi sử dụng chuỗi thập phân 2 chữ số được đóng gói với độ lệch 32:

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

Điều này có cùng số byte nhưng tiết kiệm được 3 lần.

Tôi ấp ủ một kế hoạch mới. Nếu tôi đóng gói một số nguyên dài Python có 7 ký tự, tôi có thể trích xuất từng số bằng cách dịch chuyển:

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

Vâng, điều đó đã làm giảm điểm số xuống còn 9486. Một thử nghiệm thú vị, nhưng không nơi nào đủ tốt. Bây giờ nếu tôi thoát khỏi tên hàm và dựa vào định dạng chuỗi thì sao?

# 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)

Bây giờ tôi chỉ có 22 điểm duy nhất, nhưng điểm số không được cải thiện.

Ok, nếu tôi lấy theo cách rõ ràng và chỉ in chuỗi:

# 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.'

Điểm số 7860. Tôi nên làm điều này đầu tiên. Nhưng tôi sẽ không học được nhiều như vậy.

Tôi đoán rằng tôi có thể giảm số cổ phần xuống 26 nếu tôi tự động sản xuất các bộ phận chữ hoa, vì vậy:

# 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.'

Tôi nghĩ rằng Python sẽ không tốt hơn nhiều so với 5220. Nhiệm vụ tối thiểu hóa các ký tự duy nhất trong Python chắc chắn là mang tính hướng dẫn.

Cập nhật: mbomb007 có giải pháp Python tốt hơn đạt 5005. Công việc tuyệt vời.

> <> (Cá) - 138 byte * 65 Unique = 8970

Tuyến đường đơn giản, tức là Hello World:

!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

Chà, lần đầu tiên tôi bước vào> <> đây là một thử thách. Tôi nghĩ rằng tôi thấy một số cải tiến, nhưng thật vui khi học nó :)

Hoặc để làm cho nó quá phức tạp - 1567 byte * 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 byte * 11 ký tự = 4180 điểm

Điều này có khả năng không cạnh tranh

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Hãy thử trực tuyến!

Đẩy đại diện cơ sở 5 của ký tự ASCII được nối với nhau.
Chia thành 3 phần, chuyển đổi thành số thập phân.
Chuyển đổi số nguyên ASCII trở lại ký tự.
Tham gia trở lại với nhau.

Perl 6, 139 byte * 36 unique = 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 byte * 64 ký tự duy nhất = 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 byte, 64 ký tự duy nhất. Các cách tiếp cận khác với "trả về chuỗi" đơn giản làm tăng số byte mà không tiết kiệm nhiều cho các ký tự được sử dụng.

Perl 5 , 137 byte * 35 unique = 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.'

Hãy thử trực tuyến!

Tcl , 345 byte, 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

Hãy thử trực tuyến!

\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

Hãy thử trực tuyến!

\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

Hãy thử trực tuyến!

\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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

\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

Hãy thử trực tuyến!

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"

Hãy thử trực tuyến!

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"

Hãy thử trực tuyến!

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"

Hãy thử trực tuyến!

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"

Hãy thử trực tuyến!

Tcl , 473 byte, 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

Hãy thử trực tuyến!

Tcl , 133 byte, 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."

Hãy thử trực tuyến!