Kolmogorov-mania


32

La complessità di Kolmogorov di una stringa s è definita come la lunghezza del programma P più breve che genera s. Se la lunghezza di P è inferiore alla lunghezza di s, allora si dice che s è comprimibile , altrimenti s è incomprimibile . La maggior parte delle stringhe sono incomprimibili ...

Scrivi il programma più breve che genera questa stringa (senza spazi e senza nuove righe):

d9 a6 b6 33 56 a7 95 4b 29 b0 ac 7f 2a aa 6d 19 b8 4b 4c f8 b6 2a ac 95 
a1 4b 4e a5 9d b3 e7 c9 4c 49 59 ec 94 b3 aa 6c 93 8f 11 5a 4d 39 75 82 
ec ea 24 cc d3 2d c3 93 38 4e b7 a6 0d d2 b5 37 23 54 ad 1b 79 aa 6e 49 
55 52 94 5a a7 3a 6a e9 e4 52 cd 2d 79 ad c6 12 b5 99 5b b4 76 51 17 4e 
94 f3 9a a2 e7 15 6a 55 14 4d 4e 4a a3 5c 2f ab 63 cc b5 a6 a4 92 96 8a 
2e c3 d8 88 9b 8c a9 16 f5 33 22 5b a2 e2 cc 1b 27 d4 e8 db 17 a4 39 85 
ca aa 5b 4f 36 24 d3 c6 f6 94 ad d7 0f 71 24 e1 b1 c5 ef 65 35 6c 8d d7 
1a 87 1e 25 df 5d c0 13 b2 6f 5a 57 28 98 bd 41 66 04 ed a2 52 c9 ac 83 
b3 6c 56 7e d1 c6 cc 53 4a 62 c5 59 a9 b2 d4 af 22 a5 a9 f4 b2 99 23 32 
f8 fb ae 48 6a 8a 9a b5 46 7a 36 59 9f 92 d3 25 b5 19 bd 8a 4a 49 62 a5 
e4 59 fb e5 ba a2 35 dd a9 36 1d a9 c9 69 89 77 6a b2 34 2d 1d 22 61 c5 
c2 66 1c e2 76 74 52 a5 d9 84 b9 8a a6 b5 14 ec 29 58 b2 bc 96 16 16 48 
f5 c5 bd 2f 32 1b 3d 4f 4b 2e b2 6b 9a d9 32 a4 4b 5c bc 92 b7 b3 26 39 
fa 42 2d 64 ed 1a 79 49 4c a3 b7 85 b2 a6 e2 8c d9 55 90 e1 a8 87 4b 60 
a6 e1 ba c4 bb ec 32 39 76 90 a6 b4 c6 65 79 61 91 aa 3d 54 b7 18 3d 15 
4b 06 db 30 8a 4d 4a a1 35 75 5d 3b d9 98 ac 55 5b 10 dd b3 e2 cc f1 5e 
b3 2b 53 90 b6 ee 2b ac 8f 88 8d 95 5a 75 df 59 2d 1c 5a 4c e8 f4 ea 48 
b9 56 de a0 92 91 a9 15 4c 55 d5 e9 3a 76 8e 04 ba e7 b2 aa e9 ab 2a d6 
23 33 45 3d c4 e9 52 e3 6a 47 50 ba af e4 e5 91 a3 14 63 95 26 b3 8b 4c 
bc aa 5a 92 7a ab ad a6 db 53 2e 97 06 6d ba 3a 66 49 4d 95 d7 65 c2 aa 
c3 1a 92 93 3f ca c2 6c 2b 37 55 13 c9 88 4a 5c 62 6b a6 ae cc de 72 94 

L'output dovrebbe apparire come:

d9a6b63356a7954b29b0ac7f2aaa6d19b84b4cf8b62aac95a14b4e...7294

Nota: non è consentito alcun input dell'utente, né accesso al web, né librerie (tranne quello richiesto per la stampa dell'output).

Modifica I: la sequenza sembra casuale ... ma risulta essere altamente comprimibile gestendo un po ' di numeri primi ...

Modifica II: ben fatto! Esaminerò le risposte nelle prossime ore, quindi assegnerò la taglia. Questa è la mia idea su come potrebbe essere risolto:

  1. Se provi a comprimere i dati non vai lontano ...
  2. In internet puoi trovare l' enciclopedia on-line (OEIS) (ben nota? );
  3. provare le prime cifre esadecimali d9, a6, b6, 33, ...(o la loro rappresentazione decimale) non dà alcun risultato;
  4. ma se converti i numeri in binario ( 1,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0) e cercandoli su OEIS, ottieni questo risultato .
  5. Come notato da Claudiu, ho anche dato un piccolo suggerimento nella domanda (Modifica I sopra) ... :-)

Il vincitore è : Peter Taylor (GolfScript, 50), con una menzione speciale per Claudiu (Python, 92), il primo che lo ha "risolto".


2
In che modo è più interessante di altre domande sulla complessità di komogorov ?
Maniglia della porta

2
@Doorknob: forse niente ... almeno fino a quando qualcuno non invierà una risposta :-)
Marzio De Biasi,

5
Questo dovrebbe essere un gioco di "Indovina la costante"?
Peter Taylor,

7
Non dare la soluzione! La gente ci sta lavorando :-)
Mau,

3
Penso che il concorso dovrebbe essere diviso in due parti. La prima parte è un premio assegnato a coloro che hanno trovato la risposta. La seconda parte è un premio assegnato a coloro che sanno davvero come comprimere il codice e generare il più piccolo. In questo momento, è più una domanda "indovina il mio algoritmo", che esclude gli ottusi come me, ma anche i professionisti del golf in codice reale (che non sono neanche io), e quelli che conoscono APL e le altre lingue chiare (ancora non io ).

Risposte:


11

GolfScript (50 byte)

$ wc -c codegolf24909.min.gs 
50 codegolf24909.min.gs
$ md5sum codegolf24909.min.gs 
ce652060039fba071d17333a1199fd72  codegolf24909.min.gs
$ time golfscript.rb codegolf24909.min.gs 
d9a6b63356a7954b29b0ac7f2aaa6d19b84b4cf8b62aac95a14b4ea59db3e7c94c4959ec94b3aa6c938f115a4d397582ecea24ccd32dc393384eb7a60dd2b5372354ad1b79aa6e495552945aa73a6ae9e452cd2d79adc612b5995bb47651174e94f39aa2e7156a55144d4e4aa35c2fab63ccb5a6a492968a2ec3d8889b8ca916f533225ba2e2cc1b27d4e8db17a43985caaa5b4f3624d3c6f694add70f7124e1b1c5ef65356c8dd71a871e25df5dc013b26f5a572898bd416604eda252c9ac83b36c567ed1c6cc534a62c559a9b2d4af22a5a9f4b2992332f8fbae486a8a9ab5467a36599f92d325b519bd8a4a4962a5e459fbe5baa235dda9361da9c96989776ab2342d1d2261c5c2661ce2767452a5d984b98aa6b514ec2958b2bc96161648f5c5bd2f321b3d4f4b2eb26b9ad932a44b5cbc92b7b32639fa422d64ed1a79494ca3b785b2a6e28cd95590e1a8874b60a6e1bac4bbec32397690a6b4c665796191aa3d54b7183d154b06db308a4d4aa135755d3bd998ac555b10ddb3e2ccf15eb32b5390b6ee2bac8f888d955a75df592d1c5a4ce8f4ea48b956dea09291a9154c55d5e93a768e04bae7b2aae9ab2ad62333453dc4e952e36a4750baafe4e591a314639526b38b4cbcaa5a927aabada6db532e97066dba3a66494d95d765c2aac31a92933fcac26c2b375513c9884a5c626ba6aeccde7294

real    365m11.938s
user    364m45.620s
sys     0m6.520s

Poiché tutti gli altri stanno ora rivelando il loro codice, prevederò anche la richiesta di OP di non offuscare:

38200,{:x,{)x\%!},,2=},4/{3\{2&!!1$++}/.57>39*+}%+

Dissezione generale

  • Calcola i numeri primi più piccoli di N con N = 38200: questo dà i primi 4032 numeri primi:38200,{:x,{)x\%!},,2=},
  • Vogliamo un bit per primo, con una conversione esadecimale, quindi suddividili in gruppi di 4: 4/
  • Per ogni gruppo, associa ogni primo pa p&2 != 0, ed esegui una conversione da base 2 a base 16: {3\{2&!!1$++}/.57>39*+}%(qui è dove si trovano i trucchi interessanti)
  • Ora abbiamo una matrice di valori ASCII, più la stringa vuota da stdin; concatenali per ottenere una singola stringa per l'output:+

Dissezione più dettagliata della conversione di base

Dato uno stack contenente una stringa vuota e un elenco di numeri primi, dobbiamo fare due conversioni:

  1. Converti ogni primo in un bit indicando se è uguale a 2 o 3 (mod 4)
  2. Converti i bit in cifre esadecimali

Ci sono molti modi ugualmente lunghi per fare 1; per esempio

{4%1>}%
{4%2/}%
{2/1&}%
{2/2%}%
{2&!!}%

o anche

{2&}% followed by a 2/ after the base conversion

Per 2, l'approccio ovvio è

2base 16base{'0123456789abcdef'=}%+

Ma base è una parola lunga, e poiché 16 = 2 4 possiamo facilmente salvare alcuni caratteri con

4/{2base'0123456789abcdef'=}%+

Ora lo spreco più ovvio sono i 18 caratteri dedicati a quella stringa. Vogliamo solo una funzione dalla cifra al codice ASCII. Vogliamo mappare 0a '0' = 48, ..., 9a '9' = 57, 10a 'a' = 97, ... 15a 'f' = 102.

4/{2base.9>39*+48+}%+

Ma ora getta nel mix un divieto base. Dobbiamo implementarlo da soli. L'implementazione ovvia (in questa direzione, quella facile) è che k baseè una piega {\k*+}*. L'alternativa leggermente più un'iterazione semplice, che necessita di un caso base: 0\{\k*+}/. Base 2 è leggermente speciale: 1$++equivale a \2*+per la stessa lunghezza e ho adottato questo approccio.

Entrambi sono più lunghi del carattere 5 2base, ma poiché ora stiamo iterando i valori, possiamo estrarre nella parte 1 per avere un singolo ciclo. Noi sostituiamo

{2&!!}%4/{2base.9>39*+48+}%+

con

4/{{2&!!1$++}*.9>39*+48+}%+

per un bel risparmio di 1 carattere, oppure

4/{0\{2&!!1$++}/.9>39*+48+}%+

per una perdita di 1 carattere.

Ma anche se la perdita di 1 carattere sembra un passo indietro, considera cosa succede a quello 0. Viene moltiplicato per 16 e aggiunto all'output di conversione di base. E l'ultima cosa che facciamo è aggiungere un multiplo di 16 all'output. Quindi possiamo unire i due come

4/{3\{2&!!1$++}/.57>39*+}%+

Il più corto e l'intelligenza del bonus lo rendono più interessante.


1
360 minuti! Questo è abbastanza tempo. Mi chiedo quale approccio hai preso .. il mio impiega <1 min
Claudiu

4
@Claudiu, potrei renderlo molto più veloce, ma aggiungerebbe circa 5 caratteri, e questa è complessità kolmogorov piuttosto che code-golf con vincoli temporali.
Peter Taylor,

Quanto potresti buttarlo giù se lo usassi base? Tutte le altre soluzioni usano un equivalente (i miei usi hex, quello C printf("%x"), gli haskell showHex)
Claudiu

1
@Claudiu, in realtà il mio attuale approccio migliore baseè più lungo di questo, perché ho fatto la maggior parte dell'ottimizzazione dopo aver chiarito che non potevo usarlo. basemi dà un valore compreso tra 0 e 15, quindi ha ancora bisogno di un po 'di lavoro per la conversione 0-9a-f. Potrei rivisitare usando basead un certo punto, ma non stasera.
Peter Taylor,

32

Python, 92 caratteri

Qui ci sono signore e signori, il codice stesso!

>>> code = "R=range;print hex(int(''.join(`i/2%2`for i in R(38198)if all(i%x for x in R(2,i))),2))[2:-1]"
>>> len(code)
92
>>> exec code
d9a6b63356a7954b29b0ac7f2aaa6d19b84b4cf8b62aac95a14b4ea59db3e7c94c4959ec94b3aa6c938f115a4d397582ecea24ccd32dc393384eb7a60dd2b5372354ad1b79aa6e495552945aa73a6ae9e452cd2d79adc612b5995bb47651174e94f39aa2e7156a55144d4e4aa35c2fab63ccb5a6a492968a2ec3d8889b8ca916f533225ba2e2cc1b27d4e8db17a43985caaa5b4f3624d3c6f694add70f7124e1b1c5ef65356c8dd71a871e25df5dc013b26f5a572898bd416604eda252c9ac83b36c567ed1c6cc534a62c559a9b2d4af22a5a9f4b2992332f8fbae486a8a9ab5467a36599f92d325b519bd8a4a4962a5e459fbe5baa235dda9361da9c96989776ab2342d1d2261c5c2661ce2767452a5d984b98aa6b514ec2958b2bc96161648f5c5bd2f321b3d4f4b2eb26b9ad932a44b5cbc92b7b32639fa422d64ed1a79494ca3b785b2a6e28cd95590e1a8874b60a6e1bac4bbec32397690a6b4c665796191aa3d54b7183d154b06db308a4d4aa135755d3bd998ac555b10ddb3e2ccf15eb32b5390b6ee2bac8f888d955a75df592d1c5a4ce8f4ea48b956dea09291a9154c55d5e93a768e04bae7b2aae9ab2ad62333453dc4e952e36a4750baafe4e591a314639526b38b4cbcaa5a927aabada6db532e97066dba3a66494d95d765c2aac31a92933fcac26c2b375513c9884a5c626ba6aeccde7294
>>> import hashlib; hashlib.sha256(code).hexdigest()
'60fa293bbe895f752dfe208b7b9e56cae4b0c8e4cdf7c5cf82bf7bab60af3db6'

Marzio ha lasciato un suggerimento intelligente dicendo che "risulta altamente comprimibile gestire un po ' di numeri primi". Ero sicuro che il "pezzettino" non fosse in corsivo per caso, quindi ho convertito la stringa esadecimale in bit e ho cercato di trovare schemi. All'inizio ho pensato che rappresentasse tutti i numeri primi come frammenti e li concatenasse insieme, ma non ha funzionato. Quindi magari prendendo solo poche cifre o rilasciando tutti gli zero nella stringa di bit - ancora no. Forse è una stringa del bit meno significativo dei primi primi? Non proprio. Ma alla fine ho trovato quello che ha funzionato - è una stringa del secondo bit meno significativo dal primo, tuttavia molti numeri primi.

Quindi, il mio codice fa proprio questo: genera abbastanza primi, prendi il secondo bit di ciascuno ( i/2%2), concatenali come una stringa binaria, quindi convertilo in base-10 ( int(..., 2)) e poi in base-16 ( hex(...)).


1
Grande! Sono nuovo nel code golf, ma la roba hash è un buon modo per far divertire gli altri a scoprire "come farlo". Aspetterò due giorni, quindi aprirò una taglia (che ricompenserò sulla fiducia :).
Marzio De Biasi,

5
@MarzioDeBiasi: certo che funziona! O forse meglio dire che lo ricompenserai il giorno prima della scadenza della ricompensa, e se il vincitore non rivela la sua risposta vince il 2 ° posto, ecc ... perché affidarsi alla fiducia quando non è necessario ?
Claudiu,

Perché il codice in hashlib non è stato conteggiato? Non è in esecuzione il codice per generare output?
philcolbourn,

2
@philcolbourn: No, il codice non usa hashlib. È solo per generare l'hash sha256, quindi domani posso dimostrare di aver scritto il codice quando l'ho pubblicato per la prima volta. Vedrai domani!
Claudiu,

@Claudiu: ora dovresti spiegarmi come hai risolto il problema! Molto bene!
rubik,

9

Haskell, 105

Hash SHA1: a24bb0f4f8538c911eee59dfc2d459194ccb969c

Produzione:

d9a6b63356a7954b29b0ac7f2aaa6d19b84b4cf8b62aac95a14b4ea59db3e7c94c4959ec94b3aa6c938f115a4d397582ecea24ccd32dc393384eb7a60dd2b5372354ad1b79aa6e495552945aa73a6ae9e452cd2d79adc612b5995bb47651174e94f39aa2e7156a55144d4e4aa35c2fab63ccb5a6a492968a2ec3d8889b8ca916f533225ba2e2cc1b27d4e8db17a43985caaa5b4f3624d3c6f694add70f7124e1b1c5ef65356c8dd71a871e25df5dc013b26f5a572898bd416604eda252c9ac83b36c567ed1c6cc534a62c559a9b2d4af22a5a9f4b2992332f8fbae486a8a9ab5467a36599f92d325b519bd8a4a4962a5e459fbe5baa235dda9361da9c96989776ab2342d1d2261c5c2661ce2767452a5d984b98aa6b514ec2958b2bc96161648f5c5bd2f321b3d4f4b2eb26b9ad932a44b5cbc92b7b32639fa422d64ed1a79494ca3b785b2a6e28cd95590e1a8874b60a6e1bac4bbec32397690a6b4c665796191aa3d54b7183d154b06db308a4d4aa135755d3bd998ac555b10ddb3e2ccf15eb32b5390b6ee2bac8f888d955a75df592d1c5a4ce8f4ea48b956dea09291a9154c55d5e93a768e04bae7b2aae9ab2ad62333453dc4e952e36a4750baafe4e591a314639526b38b4cbcaa5a927aabada6db532e97066dba3a66494d95d765c2aac31a92933fcac26c2b375513c9884a5c626ba6aeccde7294

Modifica: Codice:

import Numeric;f(x:z)s=f[y|y<-z,0/=mod y x]$s*2+quot(mod x 4)2;f[]s=s;main=putStr$showHex(f[2..38198]0)""

Ho perso la regola di non utilizzare alcuna funzione di libreria tranne la stampa (putStr). Suppongo che gli operatori matematici, sebbene tecnicamente funzioni, siano ammessi.


9

C, 136 116 109 109 103 caratteri

OK allora, ecco il mio sforzo:

i;p;q;main(n){for(;n++,q<4032;){for(i=1;++i<n&&n%i;);if(i==n)p+=p+(n&2)/2,p=++q&3?p:printf("%x",p)*0;}}

MD5 hash = f638552ef987ca302d1b6ecbf0b50e66

1
Poiché printfrestituisce il numero di caratteri scritti, che qui è sempre diverso da zero, è possibile utilizzare !printf(...)invece di printf(...)*0salvare un carattere.
user12205,

@ace * schiaffeggia la fronte * Ah, perché non ci ho pensato ?? Grazie asso, come sempre :-) (può anche lasciare il codice così com'è, dal momento che dovrebbe corrispondere all'hash MD5.)
ossifrage squeamish

7

JS, 764

se consideriamo questa stringa come base64, possiamo avere una versione più piccola usando la versione un-base-64-ed:

btoa("wÖºo­÷离÷ÛÖôiÎßÙ¦éÝ}oÎáÇüo­iÏyk^áæ¹õÖ÷{·=áÎ=ç×÷÷i®÷×^ZáÝýï6yÇÛw}swßÎo¶ºÑ×voûÛ~xiÝ[ïÖéî=çv÷Zk½Úé§½{vqÝïÖs­vo}å¶øï®u×¾÷÷õ¦¶{½yé®y×áîk~\Ùöëwoºkv÷¯Ùç7wÏ<õ¿kÝz÷Ûn[kg¶qÍ[Û·x{Ç[×¶¸ßß9q¦å¾ß­¸ww:¯xi×{ÑþõÛµoW9yþ¹ßñ×{Õ¯;Õí¹uþ]sMwonå®{ÛÏ|mÞ5ë­8yÖ¶çg=iÏ7o~ç®ÞwW:qÎwá®¶s}kÖöwÛf¹k×øoo}Û}öÇÛiî<é¯õ¦ùã®Úß®}õÿvw}¹o}mßá®=ëf¹{}}·¹m¦¶ß]kÝúÕÖ½sÞ½óÞûé¦ößÕݶëW9snºÕÇ¶ï®øçf¹wß8oßk¦ù×ÛÞ|ofÜ÷­z×®<9mÝßm[ÝÞá½onõ§}ßf¸á¾\mÏvo¶÷Û­ý}®6ÙÞ¸yÝZïÞ=áÆ·o¿9ofº{owÞy÷GµkÏ;á¾´k§µm§8m·ßmýï¯tk¦øs®¹ïÞµ÷VÝÞxo½|ÝÝyá½:u½ôñ®á¦µßùåÝÛwß|iÎyå½tuÖ÷{g^^o}çto§Ù¶ñÿ<ñßyå®ùuþ}ÙÝ\å®{Çøy®<oÞzuæ´÷oukÝyáÎyw½Ý®úñí8m§»of{ÖÙ§zÛ}÷ãÝs½çg·é®;çFÚi÷¸{uk}xëyÛ¦÷ñ¾mÆå¯ví¦iÖºu¾wÙï{Ó®m­Úë®=áßyw¾¹sfs}Z÷owÝ÷snÙ½ûçwsß<á®\ënk¦qÇ^ïox")

Ma penso che l'autore voglia invece trovare la logica dietro questa stringa non casuale.


1
per evitare la "corsa al ribasso" ho aggiunto alcuni dettagli alla domanda :-)
Marzio De Biasi,

4

Mathetmatica - 56

Il mistero è già risolto, quindi basta implementare l'idea

⌊.5Prime@Range@4032⌋~Mod~2~FromDigits~2~IntegerString~16

Bello. Sono curioso di sapere quale sia la possibilità più breve ora che il gatto è fuori dalla borsa
Claudiu,

Lo chiami "nessuna libreria (tranne quella richiesta per stampare l'output)"?
Peter Taylor,

@PeterTaylor Sì, nessuna importazione - nessuna libreria.
swish

A giudicare dai commenti, non credo sia stato così interpretato da OP.
Peter Taylor,

3

J - 46 char

Non mi preoccupare, sto solo registrando il golf J qui per i posteri. Non è stato abbastanza intelligente da capire il trucco.

4[1!:2&4'0123456789abcdef'{~#.2|<.-:p:i.1007 4

Ha spiegato:

  • p:i.1007 4- Crea una matrice di 1007 righe di 4 colonne degli interi da 0, quindi prendi i numeri primi corrispondenti a quegli interi. Sì, p:è un J incorporato. Sì, siamo a quattro primi in breve.

  • 2|<.-:- Dimezza ogni numero ( -:), posizionalo ( <.) e prendi quel modulo 2 ( 2|). Ciò equivale a prendere la parte significativa del leasing successivo.

  • #.- Converti ogni riga del risultato dalla base 2 in un numero intero. Questo ci dà 1007 numeri da 0 a 15 inclusi.

  • '0123456789abcdef'{~#.- Prendi ogni riga di questa matrice di bit come binario per un numero e usa quel numero per selezionare dall'elenco di cifre esadecimali. Questo converte ogni quattro bit nell'esagono.

  • 1!:2&4- L'interprete J ha un problema con l'output di stringhe più lunghe di 256 caratteri, quindi dobbiamo inviare questi dati direttamente a stdout. Ne vinci alcuni, ne perdi alcuni.

  • 4[- Infine, scarta il risultato 1!:2e invece emetti i 4 mancanti dall'output. Lo facciamo perché è più breve che includere quegli ultimi quattro numeri primi e restituire un risultato vuoto qui.


0

JS, 503

A seguito dell'idea di @xem:

s='Ù¦¶3V§K)°¬*ªm¸KLø¶*¬¡KN¥³çÉLIY쳪lZM9uìê$ÌÓ-Ã8N·¦\nÒµ7#T­yªnIURZ§:jéäRÍ-y­Æµ[´vQNó¢çjUMNJ£\/«c̵¦¤.ÃØ©õ3"[¢âÌ'+"'"+'ÔèÛ¤9ʪ[O6$ÓÆö­×q$á±Åïe5l×%ß]À²oZW(½Afí¢Rɬ³lV~ÑÆÌSJbÅY©²Ô¯"¥©ô²#2øû®HjµFz6YÓ%µ½JIb¥äYûåº\n5Ý©6©Éiwj²4-"aÅÂfâvtR¥Ù¹¦µì)X²¼HõŽ/2=OK.²kÙ2¤K\¼·³&9úB-díyIL£·²¦âÙUá¨K`¦áºÄ»ì29v¦´Æeyaª=T·=KÛ0MJ¡5u];Ù¬U[ݳâÌñ^³+S¶î+¬ZußY-ZLèôêH¹VÞ ©LUÕé:vºç²ªé«*Ö#3E=ÄéRãjGPº¯äå£c&³L¼ªZz«­¦ÛS.mº:fIM×eªÃ?ÊÂl+7UÉJ\bk¦®ÌÞr'
r=''
for(var i=0;i<s.length;i++) r+=s.charCodeAt(i).toString(16);
console.log(r)

0

Mathematica, 55

Prime~Array~4031~BitAnd~2~FromDigits~2~IntegerString~16

Testato su Mathematica 8. Questo si avvale di due osservazioni:

  • Mathematica's in FromDigitsrealtà non controlla l'intervallo delle cifre fornite, quindi se lo applichi a un elenco del modulo {2,0,2,2,0,...}otterrai solo il doppio del risultato come se ti stessi applicando {1,0,1,1,0,...}. Ma questa è esattamente la forma generata da BitAnding i numeri primi con 2.
  • L'ultimo bit del numero di cui desideriamo la rappresentazione esadecimale è zero (come evidenziato dalla stringa che termina con una cifra pari), quindi è solo due volte il numero che otterresti con un numero primo in meno. Ma un fattore due è esattamente ciò che otteniamo dall'utilizzo dell'osservazione precedente, quindi tutto si adatta perfettamente.
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.