C'est très simple: votre programme ou fonction doit générer le texte suivant:

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

Petits caractères

Vous pouvez écrire un programme ou une fonction , qui renvoie la sortie sous forme de chaîne ou l'imprime dans STDOUT (ou l'alternative la plus proche). Vous pouvez éventuellement inclure une seule nouvelle ligne de fin dans la sortie.

Notation

Le nombre d'octets dans votre code multiplié par le nombre d'octets uniques dans votre code

Le score le plus bas l'emporte.

Par exemple, un brainfuck ou une réponse d'espaces blancs aurait un énorme avantage ici, car le multiplicateur serait très faible (8 et 3 respectivement). Cependant, généralement, l'écriture de programmes dans ces langues produit un code beaucoup plus long qui peut annuler cet avantage.

Les failles standard qui ne sont plus drôles sont interdites .

Insomnie , 575 octets * 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=

Utilise 4 caractères dye=.

Solution 1b (non publiée): 783 octets * 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=

N'utilise que 3 caractères ey=.

Solution 1: 826 octets * 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~

Utilise seulement 3 caractères: yo~. Un programme est utilisé pour générer cela.

Actuellement, tous les programmes utilisent uniquement les instructions 0, 1, 2, 6. En d'autres termes, ils manipulent les bits dans un seul octet et impriment le résultat.

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

Essayez-le en ligne.

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

Explication

La stratégie que j'ai utilisée consiste à traiter chaque caractère de la chaîne comme un chiffre de base 123 et à le coder comme un nombre décimal dans le programme. Le programme reconvertit ensuite ce nombre en base 123 et mappe chaque chiffre de base 123 en un caractère. Parce qu'il est difficile d'expliquer pourquoi le programme est dans son état actuel, j'expliquerai chaque version de celui-ci.

Voici à quoi ressemblait la fin du programme dans la première version:

...2068438725 123b:c

Cela met en œuvre la stratégie de la manière la plus simple possible. Le nombre, codé normalement en base 10, est reconverti en base 123 et chaque chiffre de base 123 est mappé en retour à un caractère. Mais cela utilise 4 caractères non numériques uniques, et être en mesure de se débarrasser de l'un d'entre eux vaut probablement la taille atteinte car il faut utiliser un code moins simple.

Tout d' abord, je me suis aperçu que je pouvais me débarrasser des bet les :opérateurs en les créant à l' exécution comme leurs valeurs de caractères ASCII reconvertis en un caractère (avec le déjà copérateur) et de les évaluer avec l' ~opérateur. Il s'est avéré être un peu délicat de le faire avec l' :opérateur, car il doit être analysé avec l' copérateur suivant . J'ai résolu ce problème en produisant les caractères :, cpuis en produisant et en évaluant le caractère +, qui concatène les deux anciens caractères dans la chaîne :cqui peut ensuite être évaluée correctement.

Deuxièmement, je me suis rendu compte que l' ~opérateur que je venais d'introduire avait une nouvelle variante pratique surchargée: quand on lui donne un nombre, il produit le complément au niveau du bit. En l'utilisant deux fois de suite après un nombre, je pouvais introduire une rupture de jeton dans la source sans effet de calcul résultant, me permettant de remplacer les espaces utilisés pour séparer les nombres par ~~.

Le résultat final est 15 octets de code supplémentaires à la fin, mais ce coût est largement compensé par l'avantage d'éliminer 2 caractères uniques sur 14. Voici une comparaison de la fin de la première version avec la fin de la deuxième version:

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

Utiliser moins que les 2 opérateurs que j'utilisais serait impossible, mais je voulais toujours moins de caractères uniques. La prochaine étape consistait donc à éliminer les chiffres. En changeant l'encodage du nombre afin que chaque chiffre décimal soit vraiment un chiffre de base 5, je pourrais potentiellement éliminer les chiffres 6-9. Avant d'éliminer quoi que ce soit de la fin du programme, cela ressemblait à ceci:

...4010014400 10b5b123b:c

Comme mentionné précédemment, l'élimination de l'espace est facile. Mais b, :et cne serait pas si facile, car leurs codes de caractères sont 98, 58et 99, respectivement. Tous contenaient des chiffres marqués pour élimination, j'ai donc dû trouver des moyens de les dériver tous. Et les seuls opérateurs numériques utiles avec des valeurs de caractères ne contenant pas 5-9 étaient décrémenter, incrémenter, multiplier et ajouter.

Pour 98, j'ai d'abord utilisé 100~~40c~40c~, qui décrémente 100deux fois. Mais j'ai réalisé que je pouvais encore utiliser l' ~opérateur, car le complément au niveau du bit me permet d'obtenir des nombres négatifs qui, une fois ajoutés, me permettent d'émuler la soustraction. J'ai donc utilisé 100~~1~43c~, ce qui ajoute 100et -2et est 2 octets plus petit. Pour 58, j'ai utilisé 44~~14~~43c~, qui ajoute 44et 14. Et pour 99, j'ai utilisé 100~~40c~, qui diminue 100.

Le résultat final est assez grand et obscur, mais le coût du nombre et du code de traitement beaucoup plus importants a été légèrement dépassé par le gros avantage d'éliminer 5 caractères uniques sur 12. Voici une comparaison de la fin finale du programme avant les éliminations et après éliminations:

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

Espace, 1157 937 octets * 3 unique = 3471 2811

Par demande populaire (?), Je publie ma solution d'espace blanc.

Afin de réduire le code nécessaire, j'ai codé en dur la chaîne entière en un seul nombre binaire (7 bits pour chaque octet). Une simple boucle extrait les caractères et les imprime.

Code source sur filebin.ca.

REMARQUE: les spécifications permettent des entiers arbitraires de grande taille , mais l' interpréteur Haskell sur la page officielle est limité à 20 bits. Utilisez, par exemple, cet interpréteur ruby ​​sur github / hostilefork / whitespaces.

Le script ruby ​​pour créer le programme d'espaces (l = WHITESPACE, t = TAB, u = NEWLINE, tout ce qui après // est ignoré, écrit dans un fichier 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

À titre d'illustration, le programme d'espaces sous forme lisible par l'homme. Voir ci-dessous pour un script simple pour le convertir en un véritable programme d'espaces blancs.

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

Fondamentalement, la chaîne à afficher est un entier long et vous devez réduire son score.

Prenez un nombre x et convertissez-le en base b. Sa longueur sera floor(log_b(x)+1)et il contiendra bdifférents symboles. Le score est donc b*floor(log_b(x)+1). xest un grand nombre donné, et si vous tracez cela pour b, vous constaterez que le minimum est à peu près b=3(et b=2presque aussi bon). C'est-à-dire que la longueur diminue légèrement lorsque vous utilisez des bases plus élevées (log), mais la taille du jeu de caractères augmente linéairement, donc cela n'en vaut pas la peine.

J'ai donc cherché une langue avec seulement 0/1, mais je n'en ai pas trouvé, puis je me suis souvenu qu'il y avait des espaces et je l'ai essayé. Dans les espaces, vous pouvez saisir directement des nombres binaires avec des 0 et des 1.

Ancien code, score moins bon mais plus intéressant

Ancien code sur filebin .

Le script ruby ​​que j'ai utilisé pour créer le programme (l = WHITESPACE, t = TAB, u = NEWLINE, tout après //ignoré, écrit dans un fichier 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

À titre d'illustration, le programme d'espaces sous forme lisible par l'homme. Voir ci-dessous pour un script simple pour le convertir en un véritable programme d'espaces blancs.

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

Ce programme d'espaces en lui-même est assez simple, mais il existe trois optimisations de golf:

• utiliser lulpour cloner la pile quand il y a un personnage en double
• utiliser ltlpour cloner la nième entrée de la pile si elle est plus courte que de pousser directement le caractère
• décaler tous les octets de 97 (mod 128), rend les nombres binaires plus petits

Un script ruby ​​simple pour convertir mon code d'espaces lisible par l'homme en un véritable programme d'espaces (lire un fichier prog.het écrire dans un fichier 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 octets * 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."

Parfois, le plus simple est le meilleur.

Brainfuck, 1264 octets * 7 unique = 8848

Oui, c'est un score terrible.

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

> <> (Poisson) - 578 octets * 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

Mon score n'est pas aussi compétitif que je l'espérais, mais je pensais que cette solution était encore suffisamment intéressante pour être publiée.

Explication

La première section de code est une longue chaîne de chiffres 0-4 qui représente une représentation de base à 5 chiffres pour chaque caractère de la chaîne. Le code restant profite de l' popérateur de Fish qui vous permet de modifier le code source du programme pendant son exécution. En utilisant cet opérateur, j'ai pu générer le code Fish nécessaire pour reconvertir les caractères de base 5 en base 10 et les sortir, puis remettre ce code dans le code source au début du fichier avant que l'interprète n'atteigne la fin de la ligne et enroulé autour. Lorsque l'interpréteur atteint la fin de la ligne, le code a été modifié pour ressembler à ceci:

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

Lorsque le code s'enroule autour et frappe l' vopérateur, il descend à la deuxième ligne, frappe l' >opérateur et passe en boucle, convertissant à chaque fois le codage de base 5 en une valeur ascii de base 10, puis émettant cette valeur. Lorsqu'il n'y a plus de valeurs sur la pile, l' ?opérateur passera à ;et le programme se terminera.

7 , 273 octets × 7 octets uniques = 1911, non concurrentiels (défi de postdates de langue)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Essayez-le en ligne!

Malheureusement, c'est un vieux défi, ce qui signifie que je ne gagne pas avec l'une de mes langues les plus récentes. Cependant, le langage a été créé sans aucune connaissance du défi (je suis juste tombé au hasard sur lui dans des "questions connexes"), mais il s'est néanmoins avéré être parfaitement adapté.

7 programmes sur PPCG sont normalement soumis dans un format compressé, regroupant huit commandes en trois octets (la langue a douze commandes, mais seulement huit peuvent apparaître dans un fichier source, ce qui signifie que trois bits suffisent). Cependant, le langage prend également en charge un format octal dans lequel chaque commande est écrite sous la forme d'un chiffre ASCII, et c'est ce que j'ai utilisé ici, ce qui signifie que seuls sept octets distincts sont utilisés (la 6commande n'est pas nécessaire dans un programme qui imprime simplement une chaîne simple).

Le programme est très simple; il se compose de deux éléments de pile, une longue chaîne qui est simplement imprimée textuellement, a 7pour séparer les éléments (malheureusement inévitable), et 403qui est un moyen simple d'imprimer une chaîne constante en 7 ( 40échappe le deuxième élément de pile, tout en le déplaçant vers le haut de la pile, puis l' 3imprime et jette l'ancien premier élément de pile, c'est-à 403- dire lui - même).

Alors, comment ai-je obtenu la chaîne aussi courte que 269 octets? 7 prend en charge plusieurs formats d'E / S, et l'un de ses formats est US-TTY , un jeu de caractères (en particulier, une variante de Baudot) qui était largement utilisé avant l'invention de l'ASCII. (Le 5début du deuxième élément de pile, c'est-à-dire le début du programme, spécifie le codage de la chaîne; le reste est le contenu de la chaîne lui-même.) Il s'agit d'un jeu de caractères à cinq bits et les commandes 0à5peut être stocké en toute sécurité dans des chaînes tout en étant échappé de manière cohérente (de sorte que l'échapper une fois reproduira exactement l'original), de sorte que le langage utilise des paires de commandes (36 options) pour coder les caractères de US-TTY (32 options, dont 4 pour directives à l'interprète lui-même). Bien sûr, il y a plus de 32 caractères uniques que les gens pourraient vouloir sortir (et plus de 32 caractères apparaissent dans la chaîne), donc deux des caractères sont des "codes de décalage" qui basculent entre quatre jeux de caractères (lettres majuscules, lettres minuscules) , des chiffres et une "extension de chiffres" définie par l'utilisateur que 7 utilise pour les caractères ASCII restants qui ne figurent pas dans les autres jeux de caractères; cependant, tous les caractères de la chaîne sont "nativement" dans US-TTY donc les détails de l'extension n'a pas d'importance). Ici'

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

Je compte dix décalages ajoutés à 124 caractères d'entrée, un ratio assez négligeable. En tant que tel, la possibilité d'utiliser seulement un peu plus de deux octets d'entrée par caractère d'entrée, multiplié par 7 octets uniques, signifie que le score de ce défi est incroyablement bon. (Je suppose qu'un langage spécialement conçu pour ce défi utiliserait une sorte de compression de chaîne, plutôt qu'un jeu de caractères préexistant, mais même si Baudot et US-TTY n'étaient pas conçus pour le golf, ils sont toujours assez concis .)

Python 2, 163 147 145 143 octets * 35 36 35 uniques = 5705 5292 5220 5005

C'est probablement aussi bon que je vais l'obtenir.

Modifications:

1. Supprimé .capitalize()en faveur de l'utilisation E.
2. Changé pour utiliser à la 'place des guillemets d'échappement de barre oblique inverse.
3. Supprimé +et certains espaces pour utiliser des virgules dans l' printinstruction.

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

J'ai vu le titre et j'ai pensé que c'était un défi intéressant pour le Python plutôt verbeux. Ce sont mes notes lorsque j'ai abordé ce problème.

Mon premier essai a réduit les uniques à 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))

Je pensais que je pouvais faire mieux. En utilisant map, les uniques se résumaient à 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)))

À peu près à cette époque, j'ai remarqué dans le texte de la question que le score était uniques * bytes, pas seulement unique! Cela signifiait que mes scores pour ce qui précède étaient 14508 et 11700. Pas très compétitif. Donc, je réduit maintenant les octets en stockant le texte sous forme de chaîne hexadécimale:

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

La taille a été réduite mais les caractères plus uniques. Mais si j'utilisais une chaîne décimale à 2 chiffres avec un décalage de 32:

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

Cela a le même nombre d'octets mais enregistre 3 uniques.

Je fais éclore un nouveau plan. Si j'emballe un entier long Python avec des caractères 7 bits, je pourrais extraire chacun en décalant:

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

Eh bien, cela a réduit le score à 9486. Une expérience intéressante, mais loin d'être suffisante. Maintenant, que se passe-t-il si je me débarrasse des noms de fonction et que je me fie au formatage des chaînes?

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

Je n'ai plus que 22 uniques, mais le score ne s'améliore pas.

Ok, que se passe-t-il si je prends la voie évidente et que j'imprime la chaîne:

# 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 de 7860. J'aurais dû le faire en premier. Mais je n'aurais pas autant appris.

Je suppose que je pourrais réduire les uniques de 26 si je produisais dynamiquement les parties majuscules, donc:

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

Je pense que Python ne sera pas beaucoup mieux que 5220. La tâche de minimiser les caractères uniques en Python était certes instructive.

Mise à jour: mbomb007 a une meilleure solution Python avec un score de 5005. Beau travail.

> <> (Poisson) - 138 octets * 65 Unique = 8970

L'itinéraire simple, c'est-à-dire 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

Eh bien, pour ma première incursion dans> <>, c'était un défi. Je pense que je vois des améliorations, mais c'était amusant de l'apprendre :)

Ou pour le rendre trop compliqué - 1567 octets * 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 octets * 11 caractères = 4180 score

Ceci est potentiellement non concurrentiel

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Essayez-le en ligne!

Pousse la représentation en base 5 des caractères ASCII réunis.
Se divise en morceaux de 3, reconvertit en décimal.
Convertit un entier ASCII en caractère.
Rejoint ensemble.

Perl 6, 139 octets * 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 octets * 64 caractères uniques = 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 octets, 64 caractères uniques. Les approches autres que le simple "retour de la chaîne" augmentent le nombre d'octets sans économiser beaucoup sur les caractères utilisés.

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

Essayez-le en ligne!

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

Essayez-le en ligne!

\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

Essayez-le en ligne!

\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

Essayez-le en ligne!

\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

Essayez-le en ligne!

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

Essayez-le en ligne!

\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

Essayez-le en ligne!

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"

Essayez-le en ligne!

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"

Essayez-le en ligne!

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"

Essayez-le en ligne!

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"

Essayez-le en ligne!

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

Essayez-le en ligne!

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

Essayez-le en ligne!