ง่ายมากโปรแกรมหรือฟังก์ชันของคุณควรสร้างข้อความต่อไปนี้:

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

พิมพ์ดี

คุณอาจเขียนโปรแกรมหรือฟังก์ชั่นซึ่งส่งกลับผลลัพธ์เป็นสตริงหรือพิมพ์ไปยัง STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด) คุณสามารถเลือกที่จะรวมบรรทัดใหม่ต่อท้ายหนึ่งบรรทัดในเอาต์พุตได้

เกณฑ์การให้คะแนน

จำนวนไบต์ในรหัสของคุณคูณด้วยจำนวนไบต์ที่ไม่ซ้ำกันในรหัสของคุณ

คะแนนต่ำสุดชนะ

ตัวอย่างเช่น brainfuck หรือคำตอบของช่องว่างจะมีประโยชน์มากที่นี่เนื่องจากตัวคูณจะต่ำมาก (8 และ 3 ตามลำดับ) อย่างไรก็ตามโดยทั่วไปแล้วการเขียนโปรแกรมในภาษาเหล่านั้นจะสร้างรหัสที่ยาวกว่าซึ่งอาจส่งผลเสียต่อข้อได้เปรียบนั้น

ช่องโหว่มาตรฐานซึ่งจะไม่ตลกจะห้าม

โรคนอนไม่หลับ 575 ไบต์ * 4 = 2300

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

ใช้ 4 dye=ตัวอักษร

โซลูชัน 1b (ไม่เผยแพร่): 783 ไบต์ * 3 = 2349

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

ใช้อักขระ 3 ตัวey=เท่านั้น

โซลูชันที่ 1: 826 ไบต์ * 3 = 2478

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

ใช้เพียง 3 yo~ตัวอักษร: โปรแกรมใช้ในการสร้างสิ่งนี้

ปัจจุบันโปรแกรมทั้งหมดใช้คำสั่ง 0, 1, 2, 6 เท่านั้นกล่าวอีกนัยหนึ่งพวกเขาจัดการบิตในไบต์เดียวและพิมพ์ผลลัพธ์

CJam, 266 281 456 bytes * 14 12 7 unique = 3724 3372 3192

ลองออนไลน์

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

คำอธิบาย

กลยุทธ์ที่ฉันใช้คือการใช้อักขระแต่ละตัวในสตริงเป็นฐาน 123 หลักและเข้ารหัสเป็นตัวเลขทศนิยมในโปรแกรม จากนั้นโปรแกรมจะแปลงตัวเลขนั้นกลับไปเป็นฐาน 123 และแมปตัวเลขฐาน 123 แต่ละหลักกลับไปเป็นอักขระ เพราะมันยากที่จะอธิบายว่าทำไมโปรแกรมถึงอยู่ในสถานะปัจจุบันฉันจะอธิบายแต่ละเวอร์ชั่นของมัน

นี่คือลักษณะสิ้นสุดของโปรแกรมในเวอร์ชันแรก:

...2068438725 123b:c

ใช้กลยุทธ์ในทางที่ตรงไปตรงมาที่สุด หมายเลขที่เข้ารหัสตามปกติในฐาน 10 จะถูกแปลงกลับเป็นฐาน 123 และแต่ละหลักฐาน 123 หลักจะถูกแมปกลับไปที่อักขระ แต่นี่ใช้อักขระที่ไม่ใช่ตัวเลข 4 ตัวและสามารถกำจัดหนึ่งในนั้นน่าจะคุ้มค่ากับขนาดที่ได้รับเนื่องจากต้องใช้รหัสที่ตรงไปตรงมาน้อยลง

ครั้งแรกฉันตระหนักว่าฉันสามารถกำจัดbและตัว:ดำเนินการโดยสร้างพวกเขาที่รันไทม์เนื่องจากค่าอักขระ ASCII ถูกแปลงกลับไปเป็นอักขระ (ด้วยตัวดำเนินการที่มีอยู่แล้วc) และประเมินด้วยตัว~ดำเนินการ มันกลายเป็นเรื่องยุ่งยากเล็กน้อยในการทำเช่นนี้กับ:ผู้ปฏิบัติงานเนื่องจากต้องมีการแยกวิเคราะห์พร้อมกับตัวcดำเนินการต่อไปนี้ ฉันจะแก้ไขเรื่องนี้โดยการผลิตตัวละคร:และcแล้วการผลิตและการประเมินผลตัวอักษร+ซึ่งเชื่อมอดีตตัวละครทั้งสองเข้าไปในสตริง:cซึ่งสามารถประเมินได้อย่างถูกต้องแล้ว

ประการที่สองฉันรู้ว่า~ผู้ประกอบการที่ฉันเพิ่งแนะนำมีตัวแปรที่โอเวอร์โหลดใหม่ที่มีประโยชน์: เมื่อได้รับหมายเลข ~~โดยใช้นี้เป็นครั้งที่สองในแถวหลังตัวเลขฉันจะแนะนำแบ่งโทเค็นในแหล่งที่มาไม่มีผลกระทบการคำนวณผลที่ช่วยให้ผมที่จะแทนที่ช่องว่างที่ใช้ในการแยกจากกันพร้อมหมายเลข

ผลลัพธ์สุดท้ายคือโค้ดอีก 15 ไบต์ในตอนท้าย แต่ค่าใช้จ่ายนี้เกินดุลอย่างมากเมื่อเทียบกับการกำจัดอักขระที่ไม่ซ้ำกัน 2 ตัวออกจาก 14 นี่เป็นการเปรียบเทียบการสิ้นสุดของเวอร์ชั่นแรกกับตอนท้ายของเวอร์ชั่นที่สอง:

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

การใช้โอเปอเรเตอร์น้อยกว่า 2 ตัวที่ฉันใช้จะเป็นไปไม่ได้ แต่ฉันก็ยังต้องการตัวอักษรที่ไม่ซ้ำใคร ดังนั้นขั้นตอนต่อไปคือการกำจัดตัวเลข ด้วยการเปลี่ยนการเข้ารหัสของตัวเลขเพื่อให้แต่ละหลักทศนิยมเป็นฐาน 5 หลักจริงๆฉันสามารถกำจัดตัวเลข 6-9 ได้ ก่อนที่จะกำจัดสิ่งใดจากปลาย prgoram ดูเหมือนว่า:

...4010014400 10b5b123b:c

ดังที่ได้กล่าวมาก่อนการกำจัดพื้นที่เป็นเรื่องง่าย แต่b, :และcจะไม่ง่ายดังนั้นเป็นรหัสตัวละครของพวกเขา98, 58และ99ตามลำดับ ตัวเลขทั้งหมดเหล่านี้มีเครื่องหมายกำกับไว้เพื่อกำจัดดังนั้นฉันจึงต้องหาวิธีที่จะได้รับพวกเขาทั้งหมด และโอเปอเรเตอร์ตัวเลขที่มีประโยชน์เพียงตัวเดียวที่มีค่าตัวอักษรที่ไม่มี 5-9 คือการลดลงการเพิ่มทวีคูณและการเพิ่ม

สำหรับ98ตอนแรกฉันใช้100~~40c~40c~ซึ่งลดลง100สองครั้ง แต่จากนั้นฉันก็รู้ว่าฉันสามารถใช้~โอเปอเรเตอร์อีกอันได้เพราะการเติมบิตบิตช่วยให้ฉันได้จำนวนลบซึ่งเมื่อบวกจะให้ฉันเลียนแบบการลบ ดังนั้นผมจึงใช้แล้ว100~~1~43c~ซึ่งจะเพิ่ม100และ-2และเป็น 2 ไบต์มีขนาดเล็กลง สำหรับ58ผมใช้44~~14~~43c~ซึ่งจะเพิ่มและ44 14และสำหรับ99ผมใช้ซึ่งการลดลง100~~40c~100

ผลลัพธ์สุดท้ายมีขนาดใหญ่และงงงวย แต่ค่าใช้จ่ายของจำนวนที่มากขึ้นอย่างมีนัยสำคัญและรหัสการประมวลผลมีน้ำหนักเกินเล็กน้อยโดยประโยชน์ใหญ่ของการกำจัดตัวละครที่ไม่ซ้ำกัน 5 ตัวออกจาก 12 นี่คือการเปรียบเทียบปลายสุดท้ายของโปรแกรม คัด:

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

ช่องว่าง1157 937 ไบต์ * 3 unique = 3471 2811

ตามคำขอยอดนิยม (?) ฉันกำลังโพสต์โซลูชันช่องว่างของฉัน

เพื่อลดรหัสที่จำเป็นฉัน hardcoded สตริงทั้งหมดเป็นเลขฐานสองหนึ่ง (7 บิตสำหรับแต่ละไบต์) การวนซ้ำอย่างง่ายจะแยกอักขระและพิมพ์

ซอร์สโค้ดบน filebin.ca

หมายเหตุ: ข้อมูลจำเพาะอนุญาตให้ใช้จำนวนเต็มขนาดใหญ่โดยพลการแต่ล่าม Haskell ในหน้าอย่างเป็นทางการจะถูก จำกัด ที่ 20 บิต ใช้ตัวอย่างเช่นล่ามทับทิมนี้ใน github / hostilefork / whitespaces

สคริปต์ ruby ​​เพื่อสร้างโปรแกรมช่องว่าง (l = WHITESPACE, t = TAB, u = NEWLINE ทุกอย่างหลังจาก // ละเว้นละเว้นเขียนไปยังไฟล์prog.h):

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

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

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

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

// output string loop
ulllu // label 0

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

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

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

สำหรับภาพประกอบโปรแกรมช่องว่างในรูปแบบที่มนุษย์สามารถอ่านได้ ดูสคริปต์ง่าย ๆ ด้านล่างเพื่อแปลงเป็นโปรแกรมช่องว่างจริง

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

// output string loop
ulllu // label 0

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

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

ululu // jump to 0

ulltu // label 1
uuu

โดยทั่วไปสตริงที่จะส่งออกเป็นจำนวนเต็มยาวและคุณต้องลดคะแนน

ใช้ตัวเลข x และแปลงเป็นฐาน b ความยาวของมันจะเป็นfloor(log_b(x)+1)และมันจะมีbสัญลักษณ์ต่างกัน b*floor(log_b(x)+1)ดังนั้นคะแนนคือ xเป็นจำนวนมากที่ให้และถ้าคุณพล็อตนี้สำหรับ b คุณจะพบว่าค่าต่ำสุดนั้นค่อนข้างมากที่b=3(และb=2เกือบดีเท่า) นั่นคือความยาวจะลดลงเล็กน้อยเมื่อคุณใช้ฐานที่สูงขึ้น (ล็อก) แต่ขนาดของชุดอักขระเพิ่มขึ้นเป็นเส้นตรงดังนั้นจึงไม่คุ้มค่า

ดังนั้นฉันจึงมองหาภาษาที่มีเพียง 0/1 ของ แต่ฉันไม่พบใด ๆ แล้วฉันจำได้ว่ามีช่องว่างและพยายาม ในช่องว่างคุณสามารถป้อนหมายเลขไบนารีด้วย 0 และ 1 โดยตรง

รหัสเก่าคะแนนแย่กว่า แต่น่าสนใจกว่า

รหัสเดิมใน filebin

สคริปต์ ruby ​​ที่ฉันใช้ในการสร้างโปรแกรม (l = WHITESPACE, t = TAB, u = NEWLINE ทุกอย่างหลังจาก//ละเว้นถูกเขียนไปยังไฟล์prog.h):

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

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

EOS = "lttltl" #26
STACK = []

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

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

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

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

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

ulltu // label 1
uuu
    eos
end

สำหรับภาพประกอบโปรแกรมช่องว่างในรูปแบบที่มนุษย์สามารถอ่านได้ ดูสคริปต์ง่าย ๆ ด้านล่างเพื่อแปลงเป็นโปรแกรมช่องว่างจริง

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

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

ulltu // label 1
uuu

โปรแกรมพื้นที่สีขาวนี้ค่อนข้างง่าย แต่มีการปรับแต่งกอล์ฟสามแบบ:

• ใช้lulเพื่อโคลนสแต็กเมื่อมีอักขระซ้ำกัน
• ใช้ltlเพื่อโคลนรายการ n-th ของสแต็กหากสั้นกว่าการกดถ่านโดยตรง
• เลื่อนลงทุกไบต์ 97 (mod 128) ทำให้เลขฐานสองเล็กลง

สคริปต์ทับทิมง่าย ๆ ในการแปลงรหัสช่องว่างที่มนุษย์อ่านได้ไปเป็นโปรแกรมช่องว่างจริง (อ่านไฟล์prog.hและเขียนเป็นไฟล์prog.ws):

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

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

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

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

บางครั้งสิ่งที่ง่ายที่สุดคือสิ่งที่ดีที่สุด

Brainfuck, 1264 ไบต์ * 7 unique = 8848

ใช่มันเป็นคะแนนที่แย่มาก

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

> <> (ปลา) - 578 ไบต์ * 8 ไม่ซ้ำกัน = 4624

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

คะแนนของฉันไม่สามารถแข่งขันได้อย่างที่หวัง แต่ฉันคิดว่าวิธีนี้ยังน่าสนใจพอที่จะโพสต์

คำอธิบาย

ส่วนแรกของรหัสคือสตริงที่มีความยาวของตัวเลข 0-4 ที่แสดงถึงตัวเลข 3 ฐาน 5 หลักสำหรับแต่ละอักขระในสตริง รหัสที่เหลือใช้ประโยชน์จากpโอเปอเรเตอร์ใน Fish ที่ให้คุณแก้ไขซอร์สโค้ดของโปรแกรมในขณะที่โปรแกรมกำลังทำงาน ด้วยการใช้โอเปอเรเตอร์นั้นฉันสามารถสร้างรหัสปลาที่จำเป็นในการแปลงฐาน 5 ตัวอักษรกลับไปเป็นฐาน 10 และส่งออกแล้วใส่รหัสนั้นกลับเข้าไปในซอร์สโค้ดที่จุดเริ่มต้นของไฟล์ก่อนที่ล่ามจะถึงจุดสิ้นสุด ของเส้นและพันรอบ ๆ เมื่อล่ามมาถึงจุดสิ้นสุดของบรรทัดรหัสจะถูกปรับเปลี่ยนให้มีลักษณะดังนี้:

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

เมื่อโค้ดล้อมรอบและกระทบvผู้ปฏิบัติงานมันจะลงไปที่บรรทัดที่สองให้>ผู้ปฏิบัติงานและดำเนินการวนรอบทุกครั้งที่แปลงการเข้ารหัส 5 ฐานกลับเป็นค่าฐาน 10 ascii จากนั้นจึงส่งออกค่านั้น เมื่อไม่มีค่าเพิ่มเติมในสแต็ก?ผู้ประกอบการจะข้ามไปที่;และโปรแกรมจะสิ้นสุด

7 , 273 ไบต์× 7 ไบต์ที่ไม่ซ้ำกัน = 1911, ไม่ใช่การแข่งขัน (ภาษาท้าทายวันที่ postdates)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

ลองออนไลน์!

น่าเสียดายนี่เป็นความท้าทายแบบเก่าซึ่งหมายความว่าฉันจะไม่ชนะด้วยภาษาใหม่ล่าสุดของฉัน อย่างไรก็ตามภาษานั้นถูกสร้างขึ้นโดยที่ไม่มีความรู้เกี่ยวกับความท้าทาย (ฉันแค่สุ่มข้ามมันไปใน "คำถามที่เกี่ยวข้อง") แต่อย่างไรก็ตามกลับกลายเป็นว่าเหมาะสมมาก

7 โปรแกรมใน PPCG ปกติจะได้รับการส่งในรูปแบบที่บรรจุ, บรรจุแปดคำสั่งเป็นสามไบต์ (ภาษามีสิบสองคำสั่ง, แต่มีเพียงแปดคำสั่งเท่านั้นที่สามารถปรากฏในไฟล์ต้นฉบับ, หมายความว่าสามบิตเพียงพอ) อย่างไรก็ตามภาษายังรองรับรูปแบบฐานแปดซึ่งแต่ละคำสั่งเขียนเป็นตัวเลข ASCII และนั่นคือสิ่งที่ฉันใช้ที่นี่ซึ่งหมายความว่าใช้เพียงเจ็ดไบต์ที่แตกต่างกัน ( 6คำสั่งไม่จำเป็นในโปรแกรมที่เพิ่งพิมพ์ สตริงธรรมดา)

โปรแกรมนี้ง่ายมาก มันประกอบด้วยสององค์ประกอบสแต็คสตริงยาวที่เพิ่งได้รับการพิมพ์คำต่อคำ, 7เพื่อแยกองค์ประกอบ (น่าเสียดายที่หลีกเลี่ยงไม่ได้) และ403ซึ่งเป็นวิธีที่ง่ายในการพิมพ์สตริงคงที่ใน 7 ( 40หนีองค์ประกอบสแต็กที่สองในขณะที่ย้ายไป ด้านบนสุดของสแต็กจากนั้น3พิมพ์และทิ้งองค์ประกอบสแต็กแรกอันเก่าเช่น403ตัวเอง)

ดังนั้นฉันจะได้รับสายสั้นเป็น 269 bytes อย่างไร 7 รองรับรูปแบบ I / O หลายรูปแบบและหนึ่งในรูปแบบคือUS-TTY , ชุดอักขระ (โดยเฉพาะ, ตัวแปรของ Baudot) ซึ่งใช้กันอย่างแพร่หลายก่อนที่ ASCII จะถูกประดิษฐ์ ( 5ที่จุดเริ่มต้นขององค์ประกอบสแต็กที่สองเช่นเริ่มต้นของโปรแกรมระบุการเข้ารหัสของสตริงส่วนที่เหลือคือเนื้อหาสตริงตัวเอง) มันเป็นชุดอักขระห้าบิตและคำสั่ง0ให้5สามารถจัดเก็บไว้ในสตริงได้อย่างปลอดภัยในขณะที่ไม่ถูกใช้ Escape อย่างต่อเนื่อง (เพื่อการหลบหนีครั้งเดียวจะทำซ้ำอย่างแน่นอน) ดังนั้นภาษาจึงใช้คู่ของคำสั่ง (36 ตัวเลือก) เพื่อเข้ารหัสอักขระของ US-TTY (32 ตัวเลือก สั่งการตัวแปล 7 ตัวเอง) แน่นอนว่ามีอักขระที่ไม่ซ้ำกันมากกว่า 32 ตัวที่ผู้คนอาจต้องการส่งออก (และมากกว่า 32 ตัวอักษรปรากฏในสตริง) ดังนั้นอักขระสองตัวคือ "รหัสกะ" ที่สลับระหว่างชุดอักขระสี่ตัว (ตัวอักษรตัวพิมพ์ใหญ่ตัวอักษรตัวพิมพ์เล็ก , ตัวเลขและ "ส่วนขยายตัวเลข" ที่ผู้ใช้กำหนดซึ่ง 7 ใช้สำหรับอักขระ ASCII ที่เหลือซึ่งไม่ได้อยู่ในชุดอักขระอื่น ๆ อย่างไรก็ตามอักขระทั้งหมดในสตริงเป็น "natively" ใน US-TTY ดังนั้นรายละเอียดของ ส่วนขยายไม่สำคัญ) นี่'

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

ฉันนับการเพิ่มสิบกะการป้อนข้อมูล 124 อักขระเป็นอัตราส่วนเล็กน้อย ดังนั้นความสามารถในการใช้อินพุตที่มีอักขระเพียงสองไบต์ต่ออักขระอินพุตเพียงคูณหนึ่งไบต์ที่ไม่ซ้ำกัน 7 ครั้งหมายความว่าคะแนนของความท้าทายนี้ดีมากอย่างไม่น่าเชื่อ (ฉันเดาว่าภาษาที่ถูกออกแบบมาโดยเฉพาะสำหรับความท้าทายนี้จะใช้การบีบอัดสตริงบางประเภทแทนที่จะเป็นชุดอักขระที่มีอยู่ก่อน แต่แม้ว่า Baudot และ US-TTY ไม่ได้ออกแบบมาสำหรับการเล่นกอล์ฟพวกเขายังค่อนข้างรัดกุม .)

Python 2, 163 147 145 143 ไบต์ * 35 36 35 unique = 5705 5292 5220 5005

นั่นอาจเป็นเรื่องดีเท่าที่ฉันจะได้รับ

การแก้ไข:

1. ลบออกในความโปรดปรานของการใช้.capitalize()E
2. เปลี่ยนเป็นใช้'แทนเครื่องหมายแบคสแลช
3. ลบออก+และช่องว่างบางส่วนเพื่อใช้เครื่องหมายจุลภาคในprintคำสั่ง

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 ไบต์ * 36 unique = 5220

ฉันเห็นชื่อและคิดว่านี่เป็นความท้าทายที่น่าสนใจสำหรับ Python ที่พูดมาก นี่คือบันทึกของฉันเมื่อฉันจัดการกับปัญหานี้

ความพยายามครั้งแรกของฉันลดความเป็นเอกลักษณ์ลงเหลือ 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))

ฉันคิดว่าฉันสามารถทำได้ดีกว่า ด้วยการใช้mapงานของเก่าจะลดลงเป็น 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)))

ในเวลานี้ฉันสังเกตเห็นในข้อความคำถามว่าคะแนนนั้นuniques * bytesไม่ใช่แค่ของเก่า! นั่นหมายถึงคะแนนของฉันสำหรับข้างต้นคือ 1,450 และ 1,700,700 ไม่การแข่งขันสูงมาก ดังนั้นตอนนี้ฉันลดไบต์โดยเก็บข้อความเป็นสตริงฐานสิบหก:

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

ขนาดลดลง แต่มีลักษณะเฉพาะตัวมากขึ้น แต่ถ้าฉันใช้สตริงทศนิยม 2 หลักที่อัดแน่นด้วย 32 ออฟเซ็ต:

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

มีจำนวนไบต์เท่ากัน แต่บันทึกได้ 3 แบบ

ฉันฟักแผนใหม่ ถ้าฉันใส่ Python จำนวนเต็มยาวด้วยตัวอักษร 7 บิตฉันสามารถแยกแต่ละอันด้วยการเลื่อน:

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

ดีที่ลดคะแนนเป็น 9486 การทดลองที่น่าสนใจ แต่ไม่มีที่ไหนใกล้พอ ตอนนี้ถ้าฉันกำจัดชื่อฟังก์ชั่นและพึ่งพาการจัดรูปแบบสตริง?

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

ตอนนี้ฉันมีของเก่าเพียง 22 อัน แต่คะแนนไม่ดีขึ้น

ตกลงเกิดอะไรขึ้นถ้าฉันใช้วิธีที่ชัดเจนและเพิ่งพิมพ์สตริง:

# 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 ฉันควรทำสิ่งนี้ก่อน แต่ฉันจะไม่ได้เรียนรู้อะไรมากมาย

ฉันเดาว่าฉันสามารถลดความไม่เหมือนใครลงได้ 26 ถ้าฉันผลิตชิ้นส่วนตัวพิมพ์ใหญ่แบบไดนามิกดังนั้น:

# 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 จะไม่ได้รับดีกว่า 5220 มากนักงานในการย่อตัวอักขระที่ไม่ซ้ำกันใน Python ให้แน่ใจว่าเป็นประโยชน์

อัปเดต: mbomb007 มีโซลูชัน Python ที่ดีกว่าให้คะแนน 5005 ทำงานได้ดี

> <> (ปลา) - 138 ไบต์ * 65 ไม่ซ้ำกัน = 8970

เส้นทางง่ายๆคือ 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

สำหรับการโจมตีครั้งแรกของฉันไปสู่> <> นี่เป็นความท้าทาย ฉันคิดว่าฉันเห็นการปรับปรุงบางอย่าง แต่มันสนุกที่ได้เรียนรู้ :)

หรือเพื่อทำให้มันซับซ้อนเกินไป - 1567 ไบต์ * 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 ไบต์ * 11 ตัวอักษร = 4180 คะแนน

นี่อาจจะไม่ใช่การแข่งขัน

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

ลองออนไลน์!

พุชการแสดงฐาน 5 ของ ASCII chars เข้าด้วยกัน
แบ่งเป็น 3 ส่วนแล้วแปลงกลับเป็นทศนิยม
แปลงจำนวนเต็ม ASCII กลับเป็นอักขระ
กลับมารวมกันอีกครั้ง

Perl 6, 139 bytes * 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 ไบต์ * 64 อักขระที่ไม่ซ้ำ = 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 ไบต์, 64 อักขระที่ไม่ซ้ำ วิธีการอื่นนอกเหนือจาก "การคืนค่าสตริง" แบบธรรมดาจะเพิ่มจำนวนไบต์โดยไม่บันทึกจำนวนอักขระที่ใช้

Perl 5 , 137 ไบต์ * 35 ที่ไม่ซ้ำ = 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.'

ลองออนไลน์!

Tcl , 345 ไบต์, 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

ลองออนไลน์!

\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

ลองออนไลน์!

\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

ลองออนไลน์!

\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

ลองออนไลน์!

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

ลองออนไลน์!

\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

ลองออนไลน์!

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"

ลองออนไลน์!

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"

ลองออนไลน์!

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"

ลองออนไลน์!

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"

ลองออนไลน์!

Tcl , 473 ไบต์, 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

ลองออนไลน์!

Tcl , 133 ไบต์, 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."

ลองออนไลน์!