Scegli il tuo famoso informatico o pioniere dell'informatica preferito che è nato nel 1942 o prima (poiché il 1943 segna l'inizio della creazione del "primo" computer ). Dovrebbero avere una pagina di Wikipedia o un altro sito che elenca il loro anno di nascita e racconta come i loro risultati si riferiscono all'informatica. Puoi scegliere lo stesso di qualcun altro, ma la scelta di qualcuno di nuovo è incoraggiata.

Prendi un nome con cui sono comunemente conosciuti. Questo sarà probabilmente il loro nome e cognome, ma potrebbe includere abbreviazioni o nomi secondari se questo è più comune. Ad esempio, per Tony Hoare entrambi Tony Hoaree C. A. R. Hoaresarebbe accettabile.

Tutti i caratteri nel nome devono essere ASCII stampabili . Se il nome contiene caratteri non ASCII stampabili, va bene se scegli qualcosa di approssimativo. ad es. Kurt Godelinvece di Kurt Gödel.

Prendi l'insieme di caratteri unici nel nome (ad es. C. ARHoare) E spostali nella scala ASCII stampabile entro l'anno di nascita del tuo scienziato, facendo un giro ~nello spazio. (Fondamentalmente aggiungi l'anno di nascita modulo 95.) Questo ti darà un (molto probabilmente) nuovo set di caratteri ASCII stampabili.

Ad esempio, CAR Hoare è nato nel 1934, quindi si sposta ogni personaggio nel C. ARHoare1934 (34 mod 95) ePBctj2$5(.

Questo frammento di stack farà tutto il turno per te:

function go() {var name = document.getElementById("name").value;var year = parseInt(document.getElementById("year").value);var unique = {};for (var i = 0; i < name.length; i++) { unique[name.charAt(i)] = true; } var result = ''; for (var char in unique) { result += String.fromCharCode((char.charCodeAt(0) - 32 + year) % 95 + 32); } document.getElementById("result").value = result; }

Name: <input type="text" id="name" value="C. A. R. Hoare"><br>
Birth Year: <input type="text" id="year" value="1934"><br>
<button type="button" onclick="go()">Ok</button><br>
Result: <input type="text" id="result" readonly>

Sfida

Usando questo set e solo questo set (nessuna scheda, nessuna nuova riga) di caratteri ASCII stampabili spostati, scrivi un programma che stampa Hello, [name]!su stdout o alternativa più vicina, dove ha [name]lo stesso nome esatto che hai scelto sopra e spostato per ottenere i caratteri del tuo programma. Puoi usare più personaggi del set o non usarne affatto. Ad esempio, il programma teorico PetBee($25stampa Hello, C. A. R. Hoare!.

punteggio

Il tuo punteggio è la dimensione del tuo codice in byte per il numero di caratteri univoci nel nome che scegli. Vince la piaga più bassa.

Insonnia, 103 99 98 * 8 = 784

George Boole , 1815

Tutti e 5 i programmi sottostanti hanno la stessa lunghezza (98) e lo stesso output.

oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyy*qL|yqoLq**LoooyoLqy|qLLo*qyLq*oq|L|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyyL*qq|oL|yq*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LL|qyyLy*qq*L|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLq|oLq*yLyoyyoLyq|oLq|yq*LqooLoyyoyLyLoyyoyLoooyoLo|q|LLq|yyLooooyoLqyL

stampe Hello, George Boole!

Insonnia, 103 * 6 = 618 (probabilmente ottimale e unico)

Se G Boole( George Boole , 1815) è accettabile ...

ooyoyoLoyyoyoyyLyoyoooLLoyooyyLoyyyoLooyoyoooooLyoyyoLoyoyyyoLooyyyooLoyoyooooLLyyooyoyoLyoyoooLoyooooL

stampe Hello, G Boole!

Insonnia, 94 92 89 85 83 * 10 = 830

Kurt Godel, 1906.

kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujjku{jxuukujrxzjuxjk{urxjxukzj{j

stampe Hello, Kurt Godel!

Ho scritto un programma per cercare la soluzione. La mia seconda versione del programma dovrebbe essere più vicina all'ottimale della mia prima versione.

Come da nitpick di @Martin Büttner ( 100 92 88 85 caratteri, stesso set di caratteri):

kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujju{jxuukujrxuxjzxjk{urxjxjxukzj{j

stampe Hello, Kurt Goedel!

Interprete

CJam, 230 117 115 114 113 110 107 106 byte * 13 = 1378

23)3*c11(2#)c111(((c3*))))22 2*c32c23 3*c3))$(113))c1$)))2$)2$(32c3)))$(3)$))1($)1($)3))$)1($)1$(12$(((33c

Provalo qui.

Ho scelto Edsger Dijkstra, nato nel 1930, che mi dà c#2&$1>b()* 3(che ho davvero scelto perché era il primo che ho trovato il cui nome ha prodotto caratteri utili per CJam; da allora ho controllato una dozzina di nomi e nessuno sembrava promettente).

Il codice fondamentalmente solo costruisce i codici ASCII utilizzando 1, 2, 3, *, #(elevamento a potenza) e (, )(decremento, incremento) e li converte in un personaggio con c. Per salvare alcuni personaggi, a volte posso copiare un personaggio precedente con $( 0$copia l'elemento dello stack superiore, 1$copia l' elemento dello stack dal secondo all'alto e così via).

Ecco la suddivisione del codice in caratteri (anche questo è eseguibile):

23)3*c    "(23+1)*3 -> 72 -> H";
11(2#)c   "(11-1)^2+1 -> 101 -> e";
111(((c   "111-3 -> 108 -> l";
3*)       "Turn l into string lll and split off the third l.";
)))       "l+3 -> o";
22 2*c    "22*2 -> 44 -> ,";
32c       "32 -> Space";
23 3*c    "23*3 -> 69 -> E";
3))$(     "e-1 -> d";
113))c    "113+2 -> 115 -> s";
1$)))     "d+3 -> g";
2$)       "d+1 -> e";
2$(       "s+1 -> r";
32c       "32 -> Space";
3)))$(    "E-1 -> D";
3)$))     "g+2 -> i";
1($)      "i+1 -> j";
1($)      "j+1 -> k";
3))$)     "r+1 -> s";
1($)      "s+1 -> t";
1$(       "s-1 -> r";
12$(((    "d-3 -> a";
33c       "33 -> !";

Marbelous , 83 byte * 10 = 830

Ho scelto R Kowalski, 1941che mi permette di usare:{It9A+6=53

++63
A66333696A5A696A6A69
A5633A..+3+6+3+9++
A56A+I
AA+6
=3
3653666665
+I+I+6+6+A++

Questa è un po 'più complessa della vecchia risposta (sotto) poiché molti marmi passano attraverso più dispositivi, tutto sommato alla maggior parte del marmo hanno solo alcune cose aggiunte prima di essere stampati. Poiché non avevo sottrazione o numeri bassi, i codici ascii inferiori dovevano essere formati aggiungendo unendo due biglie di alto valore, poiché ciò si traduce in un modulo aggiuntivo. (Ho usato =3come un deflettore poiché spinge ogni marmo non uguale a 3 a destra e sembra un gatto carino)

produzione:

Hello, R Kowalski!

vecchia risposta:

Marbelous , 113 * 17 = 1921

Marbelous va bene qui, poiché ogni volta che il marmo che cade dalla tavola viene stampato, a causa della sua natura 2D, ha bisogno di alcuni numeri + un po 'di aritmetica per non lasciare che il borad diventi troppo grande.

Ho scelto Philip D. Estridge, 1937chi cede u./26EiSj9:8*-+come set di caratteri disponibile. I personaggi effettivamente utilizzati sono.+-245689E

22
6865
4965686866282252686968696E2244666E65686422456E6E6E6964
--..+4+4+9+4-2-2....+4..+2-2..+9..-4+4..-2..+5+6+4

La scheda è piuttosto semplice, le prime 3 righe sono letterali, ogni gruppo di due ha un valore esadecimale, la quarta riga sono operazioni aritmetiche per formare i codici ascii che non potevano essere scritti esplicitamente a causa dei set di caratteri limitati.

produzione:

Hello, Philip Donald Estridge!

Puoi provarlo qui!

_{Ora cercherò un possibile candidato migliore, dal momento che sembra che il marbelous possa effettivamente essere competitivo qui.}

Brainfuck, 1846 * 12 = 22152

Solo per avere una lingua diversa da CJam. Richiede le specifiche originali Brainfuck con tipo di dati byte, che trabocca a 256.

Utilizza solo 2 caratteri: +per incrementare la cella corrente e .per generare la cella corrente.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++.+++++++++++++++++.++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

Produzione

Hello, John McCarthy!

Il merito va a Coredump per aver rivelato quanto segue nella sua risposta:

 "John McCarthy" 1927
 ("John McCarthy" "e+*;h~^|.0$5" 12)

"Ciao, Niklaus Emil Wirth!" (Befunge-98, 222 × 14 = 3108)

Da Wikipedia :

Niklaus Emil Wirth (nato il 15 febbraio 1934) è uno scienziato informatico svizzero, noto per aver progettato diversi linguaggi di programmazione, tra cui Pascal, e per aver aperto la strada a diversi argomenti classici nell'ingegneria del software. Nel 1984 ha vinto il Turing Award per aver sviluppato una sequenza di linguaggi informatici innovativi.

Con uno spostamento di 34, Niklaus Emil Wirth(18 caratteri, 14 unici) finisce come p,./$86Bg0,/By,57+.

Codice ( provalo qui ):

88888888+++++++50p50g8+,50g88885+++++00pg,g7+,g7+,g55++,888866+++++,8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888+++,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++,50g00p

Abbattersi:

88888888+++++++ # Put eight '8's on the stack and add them together (ASCII 64 = `@`)
50p             # Save this value in row 0, column 5 (where the 6th '8' was)
50g8+,          # Fetch the value we just saved, add 8 and print it (ASCII 72 = `H`)
50g88885+++++   # Fetch it again and add 37 (4×8+5) (ASCII 101 = `e`)
00p             # Save this value in row 0, column 0 (the very first character)
g,              # Fetch & print this value (stack is empty, so coordinates will be zero)
g7+,g7+,        # Fetch it again, add 7 (ASCII 108 = `l`) and print. Repeat.
g55++,          # Print `o`
888866+++++,    # Print `,` (4×8+2×6=44)
8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g  # Continue in a similar fashion,
88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888++  # using integer division (`/`) in
+,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++, # a few places
50g00p          # Fetch the `@` character and put it in cell (0,0)

L'ultima riga posiziona un carattere HALT ( @) all'inizio della riga. Quando il controllo torna a questo punto, il programma si arresterà. Questo non dovrebbe essere effettivamente necessario, perché il @carattere in (5,0) è ancora lì e non dovrebbe essere emesso nulla prima che venga raggiunto. Tuttavia, l'unico interprete Befunge online che eseguirà questa mostruosità non funzionerà correttamente senza di essa.

In realtà è possibile creare una soluzione funzionante con solo Niklaus Wirth(12 caratteri univoci p,./$86By,57+), ma il codice è molto, molto più lungo.

(Taggato come Befunge-98 perché Befunge-93 ha una larghezza di 80 caratteri.)

CJam, 323 byte * 10 = 3230

5((e5(((e2(((e2(((e2((e2c525e2e2(e2(((e2(e2((e2(((c525e5(e5(((e2(e2c2(($Be2(e2(((e2(e2e2((e2(e2e2(c2e2e2((e2e2(e2(((e2(e2c2(($((((((((((((B((((($(((((2e2(e2(e2e2((e2(((e2(e2e2((c2$2$((c2$2$525e2(((e2((e2((e2((e2e2(((e2((c2$2$22((((((($22(((((((((($22(((((($((((255((e2((e2(e2((e2(((e2((c22(((($Be2e2(e2(e2((e2(((e2(((e2(((c

Produzione:

Hello, C. A. R. Hoare!

CJam, 662 byte * 10 = 6620 8700

Non per vincere ma solo perché sembra possibile. Ha usato solo 2e(c.

2e2e2((e2e2(((e2(((e2(((e2((e2c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2e2e2((e2((e2e2(((e2(e2c2e2e2e2((e2((e2e2(((e2(e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2((e2e2((e2e2(e2(((e2(e2c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2(((e2(((e2((e2((e2((e2e2(((e2((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2e2((e2e2(((e2(((e2(((e2((e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2(((e2e2(e2(((e2(e2(((e2(((e2(((c2e2e2e2(((e2((e2(e2((e2(((e2((c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2(e2e2(e2(e2((e2(((e2(((e2(((c

Produzione:

Hello, C. A. R. Hoare!

Generatore

q{i
[7209 3113 41 41 41 9 1 0]
{
1$3^)4%@1$+@*4/\'(*\
}%W2tW%"e2"*
'c}%

La banale risposta 222(((((((((((c(generata da q{i222_@-'(*'c}%) ha 3420 byte.

CJam, 16 * 307 288 = 4912 4608

B(7*2+cB(B(*2(+cB(B*((cB(B*((cBB*7-(((c5 8*5(+c8 2*2*cBB*2/5+cBB*7-cBB*5-cBB*Bm5-(cBB*4-cBB*7-c8 2*2*cB7*(((cBB*7-(((cBB*Bm5-(cBB*B-c8 2*2*c8B*2+8-cBB*7-(((c7 2+B*(cBB*8 2*-cBB*B-c8 2*2*cB(7*2(+cBB*7-(((cBB*7-cB(B(*2(+cB(B*((cB(B*((c8 2*2*cB7*cBB*8 2*-cB(B*((cBB*B-cB(B(*2(+cBB*7-c5(8*1+c

Displays:

Hello, Arthur John Robin Gorell Milner!

Questa è la mia prima risposta usando CJam, quindi sicuramente questo può giocare a golf meglio (ogni suggerimento è il benvenuto).

Ecco un codice di utilità che ho usato. Da quando ho calcolato il set di caratteri per alcuni altri nomi, questo può essere utile per qualcuno che conosce meglio CJam (o forse per un'altra lingua).

• Trova il set di caratteri, insieme al numero di personaggi unici

(defun character-set (name year)
  (let* ((uniques (remove-duplicates name))
         (size (length uniques))
         (buffer (make-array size 
                             :element-type 'character
                             :fill-pointer 0)))
    (loop for c across uniques
          do (vector-push
              (code-char
               (+ #x20 (mod (- (+ (char-code c) year) #x20) 95)))
              buffer)
          finally (return (values buffer size)))))

• Definisci un elenco di figure ben note

(defparameter *masters*  
  '("Grace Murray Hopper" 1906
    "Augusta Ada King, Countess of Lovelace" 1815
    "Augusta Ada Byron" 1815
    "Ada Lovelace" 1815
    "John von Neumann" 1903
    "Neumann Janos Lajos" 1903
    "Charles Babbage" 1791
    "John McCarthy" 1927
    "Wilhelm Ackermann" 1896
    "George Boole" 1815
    "Kurt Godel" 1906
    "Andrei Nikolaievitch Kolmogorov" 1903
    "Bertrand Arthur William Russell, 3rd Earl Russell" 1872
    "Arthur John Robin Gorell Milner" 1934))

• Calcola i set di caratteri stampabili consentiti, ordina per dimensione del set

(sort (loop for (n y) on *masters* by #'cddr
            collect (cons n (multiple-value-list (character-set n y))))
      #'< :key #'caddr)

=>
(("George Boole" "Q|q*Lyvo" 8) 
 ("Ada Lovelace" "Kn*Vy!vkmo" 10)
 ("Kurt Godel" "Q{xz&Mujkr" 10) 
 ("John von Neumann" "Mkyr#Qhxpdq" 11)
 ("Charles Babbage" "5Zd^eq4TSYW" 11)
 ("Grace Murray Hopper" "MiS{g &Nuvkx" 12)
 ("Neumann Janos Lajos" "QhxpMq#Odmrv" 12)
 ("John McCarthy" "e+*;h~^|.0$5" 12)
 ("Augusta Ada Byron" "q }~Knk*L$|yx" 13)
 ("Wilhelm Ackermann" "Sedh{=_gani]j" 13)
 ("Arthur John Robin Gorell Milner" "c78l+t%i2Bo,/1(5" 16)
 ("Andrei Nikolaievitch Kolmogorov" "DqgQndhlwfk#Nopjury" 19)
 ("Augusta Ada King, Countess of Lovelace" "KnUsq6M x~}p*Vy!vkmo" 20)
 ("Bertrand Arthur William Russell, 3rd Earl Russell" "&R%XL;MQovH)EVc6YWIP" 20))

Brainf_ck - 723 * 12 = 8676

Ho fatto una ricerca per indicizzazione dall'Elenco di scienziati informatici di Wikipedia e ho raccolto gli anni della nascita e i nomi più lunghi di tutte le persone elencate lì. Ho scritto un programma per esaminare tutti questi e trovare qualsiasi cosa potrei fare in un linguaggio comune. Purtroppo, sono stato in grado di trovare tutti i nomi che potrebbero sostenere echo;, alert(), console.log()(posso sperare), printomain .

Volevo principalmente condividere i miei dati di ricerca per indicizzazione grezzi nel caso in cui qualcuno volesse cercare in modo simile altre lingue (nota: potrebbe essere impreciso e incompleto): dati di scansione .

EDIT : Nuova ricerca per indicizzazione con circa 40 nuovi nomi da Elenco delle persone informatiche e Elenco dei pionieri dell'informatica .

MODIFICARE : ripulito manualmente l'elenco.

Ho scoperto che Jean David Ichbiah (1940), capo designer di Ada, fornisce +-.(la più breve delle tre persone per farlo). Ho generato questo codice BF per lui.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++.----.+++++++++++++.------------------------------------------------------------------------------.++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++++++++++++++++.-------------.-----.--------------------------------------------------------------------.+++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++.+++++.------.+++++++.--------.+++++++.-----------------------------------------------------------------------.

Alexander Keewatin Dewdney ha fornito i caratteri BF più utilizzabili ( +.<>), ma è arrivato leggermente al di sopra della mia risposta. Nessuno che ho trovato fornito .[].

Rubino 1.8 - 250 × 18 = 4500

p''<<24+48<<2+99<<9+99<<9+99<<22+89<<44<<4+28<<24/4+59<<22+88<<2+95<<22+94<<22+89<<9+99<<24/4+99<<24/4+99<<4+28<<24/4+59<<9+99<<2+99<<22+98<<2+99<<2+99<<24+94<<24/4+99<<99<<5+99<<4+28<<84/4+54<<2+95<<22+92<<2+95<<22+94<<84/4+94<<22+95<<98<<2+95<<4+29

Personaggi disponibili:

'()+./24589:;<>Efp

Produzione:

"Hello, Anatolii Alexeevich Karatsuba!"

Anatolii Karatsuba , nato nel 1937, è molto noto per i suoi contributi nel campo della teoria dei numeri analitici (un campo che mi piace personalmente), incluso l' algoritmo di Karatsuba , un metodo per la rapida moltiplicazione di operandi di precisione arbitrari.

Questo è il primo e unico nome che ho provato.

GolfScript (125 * 14 = 1750)

9)99.9-&^99)).9^..)))..)~99-&.99&.99)^999)9/.(((-9-..9(/-.((9^99((.9-9-^.).9-^).)).~--999~9/.9^.((.9^99(.(.9.~-^.))..9-^))](-

Demo online

Douglas Engelbart (1925 - 2013) è forse il più famoso per la "Mother of All Demos" . Il suo nome e l'anno di nascita danno caratteri !&(),-./9]^z{~, di cui utilizza questa soluzione&()-./9]^~

La struttura di base del codice è build list of numbers](-che mette molti numeri in un array con la stringa vuota che inizia nello stack, quindi estrae quella stringa e la usa con la promozione del tipo di -trasformare l'array di numeri in una stringa.

Dato che non c'è accesso agli elementi sotto la parte superiore dello stack, ho scritto un programma C # per trovare brevi frammenti che prendono un dato intero nella parte superiore dello stack e aggiungono il numero intero successivo richiesto. Ciò ha creato un piccolo problema, quando lo snippet per 69( E) è terminato con -e lo snippet per 110( n) è iniziato con 9: è costato un carattere utilizzare uno snippet più lungo 110.

CaneCode , 458 410 * 16 = 7328 6560

11111111111111111111111111111111111111111111111111111111111111111111111184111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111118111111188111841111111111111111111111111111111111111111111182222222222228331184222222222222228118111111118483322222841811111111822222828483322284111182222222222222811111111111111822222222222222811111111182222228222222281111111111118418

BF corrispondente:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++..+++.>++++++++++++++++++++++++++++++++++++++++++++.------------.<<++.>--------------.++.++++++++.>.<<-----.>+.++++++++.-----.-.>.<<---.>++++.-------------.++++++++++++++.--------------.+++++++++.------.-------.++++++++++++.>+.

Uscite:

Hello, Jack Elton Bresenham!

CaneCode è solo una sostituzione diretta del simbolo di Brainfuck, dove 12348corrispondono +-><.rispettivamente. Ho trascorso circa 2 ore a cercare un nome breve che mi ha dato+-. normale Brainfuck, senza successo.

Jack Elton Bresenham , inventore dell'algoritmo di linea di Bresenham e nato nel 1937, dà i seguenti personaggi:

o')1Ej2:54g8+9.3

Sfortunatamente, mentre 5( [) è disponibile, la mancanza di 6( ]) significa che il codice doveva ancora aumentare l'area di 100 ish (per i caratteri minuscoli) in modo lento.

> <> (Pesce) , 163 * 15 = 2445

47*5+:56+7*+:42)+:4+55*66*:++66+6*o:4+::o7+:oo25*+o56+:4*o42*4*o6*7+o:7+7+7+o:o:25*7++o42*:4*o45+*o:45++o:o:6+:5+o6+o:o:25*7++o24*4*o25*7*4+o:o:2+o:27*+o42)+ooooo;

Uscite:

Hello, Ivar Hjalmar Jacobson!

Ivar Hjalmar Jacobson , nato nel 1939, è stato trovato grazie ai dati di scansione di BMac . Fornisce i caratteri

)*+24567:;>Gopq

> <>, come Befunge, è un linguaggio basato su stack 2D. I comandi utili> <> sono:

• *+24567per l'aritmetica (nota che 47spinge a 4e a 7in pila, non 47)
• )per maggiore di (utile per ottenere 1)
• : per duplicare la parte superiore della pila
• o per l'output
• ; per la conclusione del programma

pfa anche bene alla riflessione, ma non sono riuscito a pensare a un buon uso per questo. >è un altro comando> <>, che dirige il flusso del programma verso destra, ma poiché il programma viene già eseguito in quella direzione non è stato necessario.