Es ist sehr einfach: Ihr Programm oder Ihre Funktion sollte den folgenden Text generieren:

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

Kleingedrucktes

Sie können ein Programm oder eine Funktion schreiben , die die Ausgabe als Zeichenfolge zurückgibt, oder sie an STDOUT (oder die nächstgelegene Alternative) ausgeben. Optional können Sie eine einzelne nachgestellte Newline in die Ausgabe aufnehmen.

Wertung

Die Anzahl der Bytes in Ihrem Code multipliziert mit der Anzahl der eindeutigen Bytes in Ihrem Code

Die niedrigste Punktzahl gewinnt.

Ein Brainfuck oder eine Whitespace-Antwort wären hier von großem Vorteil, da der Multiplikator sehr niedrig wäre (8 bzw. 3). Im Allgemeinen führt das Schreiben von Programmen in diesen Sprachen jedoch zu viel längerem Code, wodurch dieser Vorteil möglicherweise zunichte gemacht wird.

Standardlücken, die nicht mehr lustig sind, sind verboten .

Schlaflosigkeit , 575 Bytes * 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=

Verwendet 4 Zeichen dye=.

Lösung 1b (unveröffentlicht): 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=

Verwendet nur 3 Zeichen ey=.

Lösung 1: 826 Bytes * 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~

Verwendet nur 3 Zeichen: yo~. Ein Programm wird verwendet, um dies zu generieren.

Derzeit verwenden alle Programme nur die Anweisungen 0, 1, 2, 6. Mit anderen Worten, sie manipulieren die Bits in einem einzelnen Byte und drucken das Ergebnis aus.

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

Probieren Sie es online aus.

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

Erläuterung

Die Strategie, die ich angewendet habe, besteht darin, jedes Zeichen in der Zeichenfolge als Basisziffer 123 zu behandeln und diese im Programm als Dezimalzahl zu codieren. Das Programm konvertiert diese Zahl dann zurück in die Basis 123 und ordnet jede Basis-123-Ziffer einem Zeichen zu. Da es schwierig ist zu erklären, warum sich das Programm im aktuellen Zustand befindet, erkläre ich jede Version.

So sah das Ende des Programms in der ersten Version aus:

...2068438725 123b:c

Dadurch wird die Strategie so einfach wie möglich umgesetzt. Die normalerweise in Basis 10 codierte Zahl wird zurück in Basis 123 konvertiert, und jede Basis-123-Ziffer wird zurück auf ein Zeichen abgebildet. Es werden jedoch 4 eindeutige nicht-stellige Zeichen verwendet, und die Möglichkeit, eines dieser Zeichen zu entfernen, ist wahrscheinlich den Größenunterschied wert, da weniger einfacher Code verwendet werden muss.

Zuerst wurde mir klar, dass ich die bund die :Operatoren loswerden könnte, indem ich sie zur Laufzeit als ASCII-Zeichenwerte erstelle, die zurück in ein Zeichen konvertiert werden (mit dem bereits vorhandenen cOperator), und sie mit dem ~Operator auswerte . Es stellte sich als etwas schwierig heraus, dies mit dem :Operator zu tun , da es zusammen mit dem folgenden cOperator analysiert werden muss. Ich habe dieses Problem gelöst, indem ich die Zeichen erstellt :und cdann das Zeichen erstellt und ausgewertet habe +, wodurch die beiden vorherigen Zeichen zu einer Zeichenfolge verknüpft wurden, :cdie dann ordnungsgemäß ausgewertet werden kann.

Zweitens wurde mir klar, dass der ~Operator , den ich gerade vorgestellt habe, eine praktische neue überladene Variante hat: Wenn er eine Zahl erhält, wird das bitweise Komplement erzeugt. Indem ich dies zweimal hintereinander nach einer Zahl verwende, kann ich eine Token-Unterbrechung in der Quelle einführen, ohne dass sich daraus ein rechnerischer Effekt ergibt. Dadurch kann ich die Leerzeichen ersetzen, mit denen Zahlen voneinander getrennt werden ~~.

Das Endergebnis ist 15 weitere Byte Code am Ende, aber diese Kosten werden durch den Vorteil der Eliminierung von 2 eindeutigen Zeichen von 14 bei weitem aufgewogen. Hier ist ein Vergleich des Endes der ersten Version mit dem Ende der zweiten Version:

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

Es wäre unmöglich, weniger als die zwei Operatoren zu verwenden, die ich verwendet habe, aber ich wollte immer noch weniger eindeutige Zeichen. Der nächste Schritt war also die Beseitigung von Ziffern. Durch Ändern der Codierung der Zahl, sodass jede Dezimalstelle wirklich eine 5-stellige Basisstelle ist, könnte ich möglicherweise die Ziffern 6 bis 9 eliminieren. Bevor irgendetwas vom Ende des Programms entfernt wurde, sah es so aus:

...4010014400 10b5b123b:c

Wie bereits erwähnt, ist das Beseitigen des Platzes einfach. Aber das b, :und cwäre nicht so einfach sein, da ihre Zeichencodes sind 98, 58und 99jeweils. Diese enthielten alle Ziffern, die zur Eliminierung markiert waren, daher musste ich Wege finden, sie alle abzuleiten. Die einzigen nützlichen numerischen Operatoren mit Zeichenwerten, die 5-9 nicht enthalten, waren Dekrementieren, Inkrementieren, Multiplizieren und Addieren.

Denn 98ich habe anfangs verwendet 100~~40c~40c~, was 100zweimal dekrementiert . Aber dann wurde mir klar, dass ich den ~Operator noch einmal verwenden könnte, da ich durch bitweise Ergänzung negative Zahlen erhalte, die, wenn sie hinzugefügt werden, die Subtraktion emulieren. Also habe ich dann verwendet 100~~1~43c~, was addiert 100und -2und 2 Bytes kleiner ist. Denn 58ich habe verwendet 44~~14~~43c~, was 44und hinzufügt 14. Und dafür habe 99ich verwendet 100~~40c~, was dekrementiert 100.

Das Endergebnis ist ziemlich groß und verschleiert, aber die Kosten für die erheblich größere Anzahl und den Verarbeitungscode wurden durch den großen Vorteil der Eliminierung von 5 von 12 eindeutigen Zeichen leicht aufgewogen Eliminierungen:

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

Leerzeichen, 1157 937 Bytes * 3 eindeutig = 3471 2811

Auf vielfachen Wunsch veröffentliche ich meine Whitespace-Lösung.

Um den benötigten Code zu reduzieren, habe ich die gesamte Zeichenfolge als eine Binärzahl (7 Bits für jedes Byte) fest codiert. Eine einfache Schleife extrahiert die Zeichen und druckt sie aus.

Quellcode auf filebin.ca.

HINWEIS: In den Spezifikationen sind beliebige große Ganzzahlen zulässig , der Haskell-Interpreter auf der offiziellen Seite ist jedoch auf 20 Bit beschränkt. Verwenden Sie diesen Ruby-Interpreter beispielsweise für Github / Hostilefork / Whitespaces.

Das Ruby-Skript zum Erstellen des Whitespace-Programms (l = WHITESPACE, t = TAB, u = NEWLINE, alles nach // ignoriert, schreibt in eine Datei 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

Zur Veranschaulichung das Whitespace-Programm in lesbarer Form. Im Folgenden finden Sie ein einfaches Skript zum Konvertieren in ein tatsächliches Whitespace-Programm.

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

Grundsätzlich ist die auszugebende Zeichenfolge eine lange Ganzzahl, und Sie müssen ihre Punktzahl reduzieren.

Nimm eine Zahl x und wandle sie in die Basis b um. Seine Länge wird sein floor(log_b(x)+1)und es wird bverschiedene Symbole enthalten . Die Punktzahl ist also b*floor(log_b(x)+1). xist eine gegebene große Zahl, und wenn Sie dies für b plotten, werden Sie feststellen, dass das Minimum ziemlich genau bei liegt b=3(und b=2fast so gut ist). Dh, die Länge verringert sich geringfügig, wenn Sie höhere Basen (log) verwenden, aber die Größe des Zeichensatzes nimmt linear zu, sodass es sich nicht lohnt.

Also habe ich nach einer Sprache mit nur 0/1 gesucht, aber keine gefunden, und dann habe ich mich daran erinnert, dass es Whitespace gibt, und es ausprobiert. In Leerzeichen können Sie Binärzahlen mit 0 und 1 direkt eingeben.

Alter Code, schlechteres Ergebnis, aber interessanter

Alter Code in der Ablage .

Das Ruby-Skript, mit dem ich das Programm erstellt habe (l = WHITESPACE, t = TAB, u = NEWLINE, alles, was //ignoriert wurde, wird in eine Datei geschrieben 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

Zur Veranschaulichung das Whitespace-Programm in lesbarer Form. Im Folgenden finden Sie ein einfaches Skript zum Konvertieren in ein tatsächliches Whitespace-Programm.

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

Dieses Whitespace-Programm selbst ist recht einfach, es gibt jedoch drei Optimierungen beim Golfen:

• Verwenden Sie luldiese Option, um den Stapel zu klonen, wenn ein doppeltes Zeichen vorhanden ist
• Verwenden Sie ltldiese Option, um den n-ten Eintrag des Stapels zu klonen, wenn er kürzer ist als das direkte Drücken des Zeichens
• Verschieben Sie alle Bytes um 97 (Mod 128), um die Binärzahlen zu verkleinern

Ein einfaches Ruby-Skript zum Konvertieren meines lesbaren Whitespace-Codes in ein tatsächliches Whitespace-Programm (eine Datei lesen prog.hund in eine Datei schreiben 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."

Manchmal ist das Einfachste das Beste.

Brainfuck, 1264 Bytes * 7 eindeutig = 8848

Ja, es ist eine schreckliche Bilanz.

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

> <> (Fisch) - 578 Byte * 8 eindeutig = 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

Mein Punktestand ist nicht so wettbewerbsfähig wie ich es mir erhofft hatte, aber ich fand diese Lösung immer noch interessant genug, um zu posten.

Erläuterung

Der erste Codeabschnitt ist eine lange Zeichenfolge mit den Ziffern 0-4, die eine dreistellige Basis-5-Darstellung für jedes Zeichen in der Zeichenfolge darstellt. Der verbleibende Code nutzt den pOperator in Fish, mit dem Sie den Quellcode des Programms bearbeiten können, während das Programm ausgeführt wird. Mit diesem Operator konnte ich den für die Konvertierung der Zeichen der Basis 5 in die Basis 10 erforderlichen Fischcode generieren und ausgeben und diesen Code dann wieder in den Quellcode am Anfang der Datei einfügen, bevor der Interpreter das Ende erreichte der Linie und umwickelt. Wenn der Interpreter das Ende der Zeile erreicht, wurde der Code folgendermaßen geändert:

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

Wenn der Code den vOperator umschließt und trifft , geht er in die zweite Zeile, trifft den >Operator und geht zur Schleife über, wobei jedes Mal die Codierung der Basis 5 zurück in einen ASCII-Wert der Basis 10 konvertiert und dann dieser Wert ausgegeben wird. Wenn sich keine weiteren Werte auf dem Stapel befinden, springt der ?Bediener zum ;und das Programm wird beendet.

7 , 273 Bytes × 7 eindeutige Bytes = 1911, nicht konkurrierend

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Probieren Sie es online!

Leider ist dies eine alte Herausforderung, was bedeutet, dass ich mit einer meiner neuesten Sprachen nicht gewinnen kann. Die Sprache wurde jedoch ohne Kenntnis der Herausforderung erstellt (ich bin nur zufällig in "verwandten Fragen" darauf gestoßen), aber es stellte sich dennoch heraus, dass sie perfekt zu mir passte.

7 Programme auf PPCG werden normalerweise im gepackten Format gesendet, wobei acht Befehle in drei Bytes gepackt werden (die Sprache hat zwölf Befehle, aber in einer Quelldatei können nur acht erscheinen, was bedeutet, dass drei Bits ausreichen). Die Sprache unterstützt jedoch auch ein oktales Format, in dem jeder Befehl als ASCII-Ziffer geschrieben ist, und das habe ich hier verwendet, was bedeutet, dass nur sieben verschiedene Bytes verwendet werden (der 6Befehl ist in einem Programm, das nur druckt, nicht erforderlich) eine einfache Zeichenfolge).

Das Programm ist sehr einfach; Es besteht aus zwei Stack-Elementen, einer langen Zeichenfolge, die nur wörtlich gedruckt wird 7, um die Elemente zu trennen (leider unvermeidlich). Dies 403ist eine einfache Methode, um eine konstante Zeichenfolge in 7 zu drucken ( 40das zweite Stack-Element wird ausgeblendet, während es verschoben wird) oben auf dem Stapel, 3druckt ihn dann aus und verwirft das alte erste Stapelelement (dh das Element 403selbst).

Wie habe ich die Zeichenfolge auf 269 Byte gekürzt? 7 unterstützt mehrere E / A-Formate. Eines der Formate ist US-TTY , ein Zeichensatz (insbesondere eine Variante von Baudot), der vor der Erfindung von ASCII häufig verwendet wurde. (Am 5Anfang des zweiten Stack-Elements, dh am Anfang des Programms, wird die Codierung des Strings angegeben. Der Rest ist der String-Inhalt selbst.) Es handelt sich um einen Fünf-Bit-Zeichensatz und die Befehle 0an5können sicher in Strings gespeichert werden, während sie konsistent entkapselt sind (so dass das einmalige Entkoppeln das Original exakt wiedergibt). Daher verwendet die Sprache Befehlspaare (36 Optionen), um US-TTY-Zeichen zu kodieren (32 Optionen, wobei 4 für verwendet werden) Direktiven zum 7-Interpreter selbst). Natürlich gibt es mehr als 32 eindeutige Zeichen, die möglicherweise ausgegeben werden sollen (und es werden mehr als 32 Zeichen in der Zeichenfolge angezeigt), sodass zwei der Zeichen "Shift-Codes" sind, die zwischen vier Zeichensätzen (Großbuchstaben, Kleinbuchstaben) wechseln , figures und eine benutzerdefinierte "figures extension", die 7 für die verbleibenden ASCII-Zeichen verwendet, die nicht in den anderen Zeichensätzen enthalten sind, wobei jedoch alle Zeichen in der Zeichenfolge in US-TTY "nativ" sind die erweiterung spielte keine rolle). Hier'

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

Ich zähle zehn Schichten, die zu 124 Zeichen der Eingabe hinzugefügt werden, ein ziemlich vernachlässigbares Verhältnis. Die Fähigkeit, nur etwas mehr als zwei Bytes Eingabe pro Eingabezeichen zu verwenden, mal 7 eindeutige Bytes, bedeutet, dass die Punktzahl bei dieser Herausforderung unglaublich gut ist. (Ich denke, eine Sprache, die speziell für diese Herausforderung entwickelt wurde, würde eine Art String-Komprimierung anstelle eines bereits vorhandenen Zeichensatzes verwenden. Obwohl Baudot und US-TTY nicht für das Golfen entwickelt wurden, sind sie immer noch ziemlich prägnant .)

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

Das ist wahrscheinlich ungefähr so ​​gut, wie ich es bekommen werde.

Bearbeitungen:

1. Für die .capitalize()Verwendung entfernt E.
2. Geändert, um 'Anführungszeichen anstelle von Backslash zu verwenden .
3. Entfernt +und einige Leerzeichen, um Kommas in der printAnweisung zu verwenden.

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

Ich habe den Titel gesehen und fand, dass dies eine interessante Herausforderung für den eher wortreichen Python war. Dies sind meine Notizen, als ich dieses Problem anging.

Mein erster Versuch reduzierte die Unikate auf 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))

Ich dachte, ich könnte es besser machen. Unter Verwendung von mapkam es zu 26 Unikaten:

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

Ungefähr zu dieser Zeit bemerkte ich im Fragetext, dass die Punktzahl uniques * bytesnicht nur einzigartig war! Das bedeutete, dass ich für die oben genannten Punkte 14508 und 11700 Punkte erhielt. Nicht sehr konkurrenzfähig. Deshalb reduziere ich jetzt die Bytes, indem ich den Text als Hex-Zeichenfolge speichere:

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

Die Größe wurde reduziert, aber mehr eindeutige Zeichen. Aber wenn ich eine gepackte 2-stellige Dezimalzeichenfolge mit einem Versatz von 32 verwendet habe:

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

Dies hat die gleiche Anzahl von Bytes, speichert aber 3 Unikate.

Ich habe einen neuen Plan. Wenn ich eine lange Python-Ganzzahl mit 7-Bit-Zeichen packe, könnte ich jedes durch Verschieben extrahieren:

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

Nun, das reduzierte die Punktzahl auf 9486. Ein interessantes Experiment, aber bei weitem nicht gut genug. Was ist nun, wenn ich die Funktionsnamen loswird und mich auf die Formatierung von Zeichenfolgen verlasse?

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

Ich habe jetzt nur 22 Unikate, aber die Punktzahl verbessert sich nicht.

Ok, was ist, wenn ich den offensichtlichen Weg eingeschlagen habe und nur die Zeichenfolge ausgedruckt habe:

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

Score von 7860. Ich hätte das zuerst tun sollen. Aber ich hätte nicht so viel gelernt.

Ich denke, ich könnte Uniques um 26 reduzieren, wenn ich die Großbuchstaben dynamisch produziere. Also:

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

Ich denke, Python wird nicht viel besser als 5220. Die Aufgabe, die eindeutigen Zeichen in Python zu minimieren, war allerdings aufschlussreich.

Update: mbomb007 hat eine bessere Python-Lösung mit 5005. Gute Arbeit.

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

Die einfache Route, dh Hallo Welt:

!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

Nun, für meinen ersten Ausflug in> <> war dies eine Herausforderung. Ich denke, ich sehe einige Verbesserungen, aber es hat Spaß gemacht, es zu lernen :)

Oder um es zu kompliziert zu machen - 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 Byte * 11 Zeichen = 4180 Punkte

Dies ist möglicherweise nicht konkurrierend

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Probieren Sie es online!

Schiebt die Basis 5-Darstellung von zusammengefügten ASCII-Zeichen.
Teilt sich in 3er-Teile, konvertiert zurück in Dezimalzahl.
Konvertiert ASCII-Ganzzahlen zurück in Zeichen.
Schließt sich wieder zusammen.

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 Bytes * 64 eindeutige Zeichen = 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 Bytes, 64 eindeutige Zeichen. Andere Ansätze als das einfache "return the string" erhöhen die Byteanzahl, ohne viel an verwendeten Zeichen zu sparen.

Perl 5 , 137 Bytes * 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.'

Probieren Sie es online!

Tcl , 345 Bytes, 345 × 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

Probieren Sie es online!

\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

Probieren Sie es online!

\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

Probieren Sie es online!

\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

Probieren Sie es online!

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

Probieren Sie es online!

\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

Probieren Sie es online!

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"

Probieren Sie es online!

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"

Probieren Sie es online!

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"

Probieren Sie es online!

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"

Probieren Sie es online!

Tcl , 473 Bytes, 473 × 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

Probieren Sie es online!

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

Probieren Sie es online!