Tieni giù i personaggi unici


23

È molto semplice: il tuo programma o funzione dovrebbe generare il seguente testo:

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

Stampa fine

È possibile scrivere un programma o una funzione , che restituisce l'output come stringa o lo stampa su STDOUT (o alternativa più vicina). Se lo si desidera, è possibile includere un'unica riga finale finale nell'output.

punteggio

Il numero di byte nel codice moltiplicato per il numero di byte univoci nel codice

Il punteggio più basso vince.

Ad esempio, una risposta al cervello o uno spazio bianco avrebbe un enorme vantaggio qui, poiché il moltiplicatore sarebbe molto basso (rispettivamente 8 e 3). Tuttavia, generalmente, scrivere programmi in quelle lingue produce un codice molto più lungo che può negare quel vantaggio.

Sono vietate le scappatoie standard che non sono più divertenti .


Suppongo che il case debba essere esatto?
EnragedTanker

@crayzeedude sì, questo è una specie di punto
durron597

Tutto apposto. Sto solo chiarendo. : p
EnragedTanker

1
@CarpetPython Ci sono stati dei dibattiti al riguardo nella sandbox e alla fine ho deciso che non c'era modo di livellare VERAMENTE il campo di gioco. Nota che gli spazi bianchi e l'insonnia hanno comunque i punteggi più alti!
durron597,

2
Come ho scritto da qualche parte, se assumiamo che l'uso di più byte per compensare caratteri meno unici si comporti in modo simile alla conversione di numeri in basi diverse, quindi approssimativamente bytecount~Log(X,unique), con X una costante per questo problema. Quindi costante ^ bytecount ~ unica. Calcola questo punteggio (log2) python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546. Quindi, tranne per la risposta brainfuck, è relativamente costante ...
blutorange

Risposte:


7

Insonnia , 575 byte * 4 = 2300

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

Utilizza 4 caratteri dye=.

Soluzione 1b (non pubblicata): 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=

Utilizza solo 3 caratteri ey=.

Soluzione 1: 826 byte * 3 = 2478

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

Solo utilizza 3 caratteri: yo~. Un programma viene utilizzato per generare questo.

Attualmente, tutti i programmi usano solo le istruzioni 0, 1, 2, 6. In altre parole, manipolano i bit in un singolo byte e stampano il risultato.


19

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

Provalo online.

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

Spiegazione

La strategia che ho usato è di trattare ogni carattere della stringa come una cifra di 123 base e codificarlo come un numero decimale nel programma. Il programma converte quindi quel numero di nuovo in base 123 e mappa ogni cifra di base 123 in un carattere. Perché è difficile spiegare perché il programma è nel suo stato attuale, spiegherò ogni versione di esso.

Ecco come appariva la fine del programma nella prima versione:

...2068438725 123b:c

Questo attua la strategia nel modo più semplice possibile. Il numero, codificato normalmente nella base 10, viene riconvertito nella base 123 e ogni cifra della base 123 viene ricondotta a un carattere. Ma questo utilizza 4 caratteri univoci non digitati, e riuscire a sbarazzarsi di uno qualsiasi di questi varrebbe probabilmente la taglia colpita dal fatto che è necessario utilizzare un codice meno semplice.

Innanzitutto, mi sono reso conto che avrei potuto sbarazzarmi di be degli :operatori creandoli in fase di esecuzione quando i loro valori di carattere ASCII sono stati riconvertiti in un carattere (con l' coperatore già presente ) e valutandoli con l' ~operatore. Si è rivelato un po 'complicato farlo con l' :operatore, poiché deve essere analizzato insieme al seguente coperatore. Ho risolto questo problema producendo i caratteri :e cquindi producendo e valutando il personaggio +, che concatena i precedenti due caratteri nella stringa :cche possono quindi essere valutati correttamente.

In secondo luogo, mi sono reso conto che l' ~operatore che ho appena introdotto aveva una nuova variante sovraccaricata a portata di mano: quando viene dato un numero, produce il complemento bit per bit. Usandolo due volte di seguito dopo un numero, potrei introdurre un'interruzione del token nell'origine senza alcun effetto computazionale risultante, permettendomi di sostituire gli spazi utilizzati per separare i numeri ~~.

Il risultato finale è 15 byte in più di codice alla fine, ma questo costo è notevolmente compensato dal vantaggio di eliminare 2 caratteri univoci su 14. Ecco un confronto tra la fine della prima versione e la fine della seconda versione:

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

Usare meno dei 2 operatori che stavo usando sarebbe impossibile, ma volevo ancora meno personaggi unici. Quindi il passo successivo è stato quello di eliminare le cifre. Modificando la codifica del numero in modo che ogni cifra decimale fosse davvero una cifra di base 5, potrei potenzialmente eliminare le cifre 6-9. Prima di eliminare qualsiasi cosa dalla fine del prgoram, sembrava così:

...4010014400 10b5b123b:c

Come accennato in precedenza, eliminare lo spazio è facile. Ma la b, :e cnon sarebbe così facile, come i loro codici di carattere sono 98, 58e 99, rispettivamente. Tutte queste cifre contenevano cifre contrassegnate per l'eliminazione, quindi ho dovuto trovare il modo di ricavarle tutte. E gli unici operatori numerici utili con valori di carattere non contenenti 5-9 erano decrementa, incrementa, moltiplica e aggiungi.

Per 98, inizialmente ho usato 100~~40c~40c~, che diminuisce 100due volte. Ma poi ho capito che potevo fare ancora un altro uso ~dell'operatore, poiché il complemento bit a bit mi consente di ottenere numeri negativi che, se aggiunti, mi permettono di emulare la sottrazione. Quindi ho usato 100~~1~43c~, che aggiunge 100ed -2ed è più piccolo di 2 byte. Per 58, ho usato 44~~14~~43c~, che aggiunge 44e 14. E per 99, ho usato 100~~40c~, che diminuisce 100.

Il risultato finale è piuttosto grande e offuscato, ma il costo del numero significativamente più grande e del codice di elaborazione è stato leggermente superato dal grande vantaggio di eliminare 5 caratteri univoci su 12. Ecco un confronto della fine finale del programma prima delle eliminazioni e dopo eliminazioni:

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

Ok, ora sono impressionato. Come si confrontano la base 6 cifre, la base 7 cifre, ecc. Rispetto alla base 5?
durron597

@ durron597 In realtà non fanno i calcoli più facile, come i codici di carattere degli operatori di cui ho bisogno ( 98, 58, e 99) sono ancora fuori portata. E l'incremento della base riduce solo la dimensione totale del programma dell'8-10%, il che non è sufficiente per compensare il punteggio del 10-15% ottenuto con un nuovo personaggio unico. Ri-includere l' boperatore allo stesso modo non ne vale la pena.
Runer112

Prendi un numero x e convertilo in base b. La sua lunghezza sarà floor(log_b(x)+1)e conterrà bsimboli diversi. Quindi il punteggio è b*floor(log_b(x)+1). x è un dato numero grande e se lo pianifichi per b, troverai che il minimo è praticamente a b = 3. Vale a dire, la lunghezza si riduce leggermente quando si utilizzano basi più alte (registro), ma le dimensioni del set di caratteri aumentano in modo lineare, quindi non ne vale la pena. Crea un semplice programma di spazi bianchi, ma ottiene solo un punteggio di 4134.
blutorange

@blutorange Dovresti installare il programma degli spazi bianchi. 4134 è sufficiente per il secondo posto
durron597

16

Spazio bianco, 1157 937 byte * 3 unico = 3471 2811

Su richiesta popolare (?), Sto pubblicando la mia soluzione di spazi bianchi.

Al fine di ridurre il codice necessario, ho hardcoded l'intera stringa come un numero binario (7 bit per ogni byte). Un semplice ciclo estrae i personaggi e li stampa.

Codice sorgente su filebin.ca.

NOTA: le specifiche consentono numeri interi arbitrari di grandi dimensioni , ma l' interprete Haskell sulla pagina ufficiale è limitato a 20 bit. Utilizzare, ad esempio, questo interprete rubino su github / hostilefork / whitespace.

Lo script ruby ​​per creare il programma degli spazi bianchi (l = WHITESPACE, t = TAB, u = NEWLINE, tutto dopo // ignorato, scrive in un file 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

Ad esempio, il programma degli spazi bianchi in forma leggibile dall'uomo. Vedi sotto per un semplice script per convertirlo in un vero programma di spazi bianchi.

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

Fondamentalmente, la stringa da emettere è un numero intero lungo ed è necessario ridurne il punteggio.

Prendi un numero x e convertilo in base b. La sua lunghezza sarà floor(log_b(x)+1)e conterrà bsimboli diversi. Quindi il punteggio è b*floor(log_b(x)+1). xè un dato numero elevato e se lo pianifichi per b, troverai che il minimo è praticamente b=3(ed b=2è quasi altrettanto buono). Vale a dire, la lunghezza si riduce leggermente quando si utilizzano basi più alte (registro), ma le dimensioni del set di caratteri aumentano in modo lineare, quindi non ne vale la pena.

Così ho cercato una lingua con solo 0/1, ma non ne ho trovata nessuna, e poi mi sono ricordato che c'era spazio bianco e l'ho provato. Nello spazio bianco, è possibile inserire direttamente numeri binari con 0 e 1.


Vecchio codice, punteggio peggiore ma più interessante

Vecchio codice su filebin .

Lo script ruby ​​che ho usato per creare il programma (l = WHITESPACE, t = TAB, u = NEWLINE, tutto dopo aver //ignorato, scrive su un file 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

Ad esempio, il programma degli spazi bianchi in forma leggibile dall'uomo. Vedi sotto per un semplice script per convertirlo in un vero programma di spazi bianchi.

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

Questo programma di spazi bianchi è piuttosto semplice, ma ci sono tre ottimizzazioni del golf:

  • usare lulper clonare la pila quando c'è un personaggio duplicato
  • usare ltlper clonare l'n-esima voce dello stack se è più breve di spingere direttamente il carattere
  • sposta tutti i byte in basso di 97 (mod 128), riduce i numeri binari

Un semplice script ruby ​​per convertire il mio codice di spazi bianchi leggibili dall'uomo in un vero programma di spazi bianchi (leggi un file prog.he scrive in un file 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

La nuova riga finale è facoltativa, è possibile salvare alcuni caratteri non stampandola.
durron597

Grazie, l'ho cambiato. Inizialmente, l'ho incluso perché l'interprete Haskell ha aggiunto un output di debug, ma con quello ruby ​​sembra pulito.
Blutorange,

7

Rubino 144 byte * 39 Unico = 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."

A volte il più semplice è il migliore.


Non si utilizzano semplificazioni nei dati. Gli esempi di cjam e di spazi bianchi hanno ottenuto punteggi impressionanti insieme ad alcune spiegazioni. Anche con il bonus per l'uso del codice ordinato in un linguaggio sano, è troppo terreno per truccarlo !!! Forse puoi rientrare nel concorso di punteggio lunghezza + unico.
Jose_X

6

Brainfuck, 1264 byte * 7 unico = 8848

Sì, è un punteggio terribile.

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

Ho scoperto che è possibile utilizzare meno caratteri univoci, ma la lunghezza sarebbe 10795, volte 5 = 53975.
mbomb007

potresti farlo solo se +.non sei sicuro che sarebbe comunque più piccolo.
captncraig,

Usando solo +e .ottengo 15018 * 2 = 30,036.
captncraig,

6

> <> (Pesci) - 578 byte * 8 unici = 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

Il mio punteggio non è competitivo come speravo, ma ho pensato che questa soluzione fosse ancora abbastanza interessante da pubblicare.

Spiegazione

La prima sezione del codice è una lunga stringa delle cifre 0-4 che rappresentano una rappresentazione di base 5 a 3 cifre per ogni carattere della stringa. Il codice rimanente sfrutta l' poperatore in Fish che consente di modificare il codice sorgente del programma mentre il programma è in esecuzione. Usando quell'operatore, sono stato in grado di generare il codice Fish necessario per riconvertire i caratteri di base 5 in base 10 e inviarli in output, quindi reinserire quel codice nel codice sorgente all'inizio del file prima che l'interprete raggiungesse la fine della linea e avvolto. Quando l'interprete raggiunge la fine della riga, il codice è stato modificato in questo modo:

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

Quando il codice si avvolge e colpisce l' voperatore, scende alla seconda riga, colpisce l' >operatore e procede al ciclo, convertendo ogni volta la codifica di base 5 in un valore ASCII di base 10 e quindi emettendo tale valore. Quando non ci sono più valori nello stack, l' ?operatore salterà a ;e il programma terminerà.


5

7 , 273 byte × 7 byte univoci = 1911, non competitivi (sfida postdate lingua)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Provalo online!

Sfortunatamente, questa è una vecchia sfida, nel senso che non posso vincere con una delle mie lingue più recenti. Tuttavia, il linguaggio è stato creato senza alcuna conoscenza della sfida (mi sono imbattuto casualmente in "domande correlate"), ma si è comunque rivelato essere perfetto.

Normalmente 7 programmi su PPCG vengono inviati in formato compresso, comprimendo otto comandi in tre byte (la lingua ha dodici comandi, ma solo otto possono apparire in un file sorgente, il che significa che tre bit sono sufficienti). Tuttavia, la lingua supporta anche un formato ottale in cui ogni comando è scritto come una cifra ASCII, ed è quello che ho usato qui, il che significa che vengono utilizzati solo sette byte distinti (il 6comando non è necessario in un programma che stampa una semplice stringa).

Il programma è molto semplice; è composto da due elementi dello stack, una lunga stringa che viene stampata alla lettera, a 7per separare gli elementi (purtroppo inevitabile) e 403che è un modo semplice per stampare una stringa costante in 7 ( 40sfugge al secondo elemento dello stack, mentre lo sposta su la parte superiore dello stack, quindi lo 3stampa e scarta il vecchio primo elemento dello stack, ovvero lo 403stesso).

Quindi, come ho potuto ottenere la stringa corta come 269 byte? 7 supporta più formati I / O e uno dei suoi formati è US-TTY , un set di caratteri (in particolare una variante di Baudot) che è stato ampiamente utilizzato prima dell'invenzione di ASCII. (L' 5inizio del secondo elemento dello stack, ovvero l'inizio del programma, specifica la codifica della stringa; il resto è il contenuto della stringa stessa.) È un set di caratteri a cinque bit e i comandi 0per5può essere tranquillamente memorizzato in stringhe pur essendo senza escape in modo coerente (in modo che la sua fuga una volta riproduca esattamente l'originale), quindi il linguaggio utilizza coppie di comandi (36 opzioni) per codificare i caratteri di US-TTY (32 opzioni, di cui 4 utilizzate direttive per il 7 interprete stesso). Naturalmente, ci sono più di 32 caratteri univoci che le persone potrebbero voler emettere (e più di 32 caratteri compaiono nella stringa), quindi due dei caratteri sono "codici di spostamento" che cambiano tra quattro set di caratteri (lettere maiuscole, lettere minuscole , figure e un'estensione "figure" definita dall'utente che 7 utilizza per i rimanenti caratteri ASCII che non sono negli altri set di caratteri, tuttavia, tutti i caratteri nella stringa sono "nativamente" in US-TTY, quindi i dettagli di l'estensione non importava). Qui'

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

Conto dieci turni aggiunti a 124 caratteri di input, un rapporto abbastanza trascurabile. Come tale, la capacità di usare solo poco più di due byte di input per carattere di input, per 7 byte unici, significa che il punteggio di questa sfida è incredibilmente buono. (Immagino che un linguaggio progettato appositamente per questa sfida utilizzerebbe una sorta di compressione delle stringhe, piuttosto che un set di caratteri preesistente, ma anche se Baudot e US-TTY non sono stati progettati per il golf, sono ancora abbastanza concisi .)


Tale scappatoia è impedire la scrittura di una lingua allo scopo di rispondere a una sfida, cosa che chiaramente non lo è. Ancora degno di un mio voto, anche se non posso accettarlo nonostante abbia il punteggio più basso fino ad oggi.
durron597,

2

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

Questo è probabilmente buono come ho intenzione di ottenerlo.

modifiche:

  1. Rimosso .capitalize()a favore dell'uso E.
  2. Modificato per utilizzare le 'virgolette di escape con barra rovesciata.
  3. Rimossi +e alcuni spazi per usare le virgole printnell'istruzione.
print"Elizabeth obnoxiously quoted (just too rowdy for my peace):",'"the quick brown fox jumps over the lazy dog,"'.upper(),"giving me a look."

Ho provato a iniziare con binario o esadecimale e convertirmi in stringa, ma i vantaggi si perdono nel processo di conversione.
mbomb007,

2

Python 2, 14508 11700 11088 10164 9486 9746 7860 145 byte * 36 unico = 5220

Ho visto il titolo e ho pensato che fosse una sfida interessante per il piuttosto prolisso Python. Questi sono i miei appunti mentre affrontavo questo problema.

Il mio primo tentativo ha ridotto gli uniques a 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))

Pensavo di poter fare di meglio. Usando map, uniques è sceso a 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)))

Circa in questo momento, ho notato nel testo della domanda che il punteggio era uniques * bytes, non solo unici! Ciò significava che i miei punteggi per quanto sopra erano 14508 e 11700. Non molto competitivo. Quindi ora riduco i byte memorizzando il testo come una stringa esadecimale:

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

La dimensione è stata ridotta ma caratteri più unici. Ma se ho usato una stringa decimale a 2 cifre compressa con un offset 32:

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

Questo ha lo stesso numero di byte ma salva 3 elementi unici.

Traccio un nuovo piano. Se impacco un intero lungo Python con caratteri a 7 bit, potrei estrarre ciascuno spostando:

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

Bene, questo ha ridotto il punteggio a 9486. Un esperimento interessante, ma in nessun posto abbastanza vicino. E se mi sbarazzassi dei nomi delle funzioni e facessi affidamento sulla formattazione delle stringhe?

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

Ora ho solo 22 uniques, ma il punteggio non migliora.

Ok, se avessi preso la strada ovvia e avessi stampato la stringa:

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

Punteggio di 7860. Avrei dovuto farlo prima. Ma non avrei imparato tanto.

Immagino che potrei ridurre gli unici di 26 se producessi dinamicamente le parti maiuscole, quindi:

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

Penso che Python non andrà molto meglio del 5220. Il compito di minimizzare i personaggi unici in Python è stato sicuramente istruttivo.

Aggiornamento: mbomb007 ha una soluzione Python migliore con un punteggio di 5005. Bel lavoro.


Ottime ottimizzazioni nella tua soluzione +1. Ho modificato il titolo come mi hai suggerito.
Logic Knight,

1

> <> (Pesce) - 138 byte * 65 Unico = 8970

Il percorso semplice, ovvero 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

Bene, per la mia prima incursione in> <> questa è stata una sfida. Penso di vedere alcuni miglioramenti, ma è stato divertente impararlo :)

O per renderlo eccessivamente complicato - 1567 byte * 27 Unico = 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\

Se si scrive la stringa all'indietro, è possibile rilasciare lo rstack invertendo :) Inoltre è possibile spostare il finale onello spazio vuoto all'inizio della seconda riga.
Sp3000,

@ Sp3000 Grazie per i suggerimenti!
Vlad274,

In che modo potresti evitare di avere f f + 2 + ocosì tante volte in quella complicata?
mbomb007,

Nel migliore, c'è un modo semplice per le maiuscole ? Passa attraverso una subroutine che aggiunge 32 a ciascuna in quella parte della stringa, risparmiando alcuni caratteri unici, forse?
mbomb007,

@ mbomb007 Potrei ottimizzarlo usando il registro, o potrei persino leggere uno spazio dal codice sorgente stesso. Sono super nuovo di Fish, quindi non so se sia possibile
Vlad274

1

05AB1E , 380 byte * 11 caratteri = 4180 punti

Questo è potenzialmente non competitivo

"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Provalo online!

Spinge la rappresentazione di base 5 dei caratteri ASCII uniti.
Si divide in pezzi di 3, converte nuovamente in decimale.
Converte il numero intero ASCII in carattere.
Si unisce di nuovo.


0

Perl 6, 139 byte * 36 unici = 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.'

0

Java 8, 141 byte * 64 caratteri univoci = 9.024

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

141 byte, 64 caratteri unici. Approcci diversi dal semplice "return the string" aumentano il conteggio dei byte senza risparmiare molto sui caratteri utilizzati.


0

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

Provalo online!


0

Tcl , 345 byte, 345 x 13 = 4485

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

Provalo online!


Tcl , 337 byte, 337 x 15 = 5055

\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

Provalo online!

Tcl , 329 byte, 329 x 16 = 5264

\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

Provalo online!


Tcl , 333 byte, 333 x 16 = 5328

\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

Provalo online!


Tcl , 148 byte, 148 x 37 = 5476

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

Provalo online!

Tcl , 277 byte, 277 x 21 = 5817

\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

Provalo online!

Tcl , 371 byte, 371 x 16 = 5936

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"

Provalo online!

Tcl , 401 byte, 401 x 16 = 6416

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"

Provalo online!


Tcl , 403 byte, 403 x 16 = 6448

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"

Provalo online!


Tcl , 433 byte, 433 x 15 = 6495

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"

Provalo online!

Tcl , 473 byte, 473 x 14 = 6622

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

Provalo online!

Tcl , 133 byte, 133 x 60 = 7980

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

Provalo online!



Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.