The 9 Billion Names of God è un racconto di Arthur C. Clarke. Parla di un gruppo di monaci tibetani il cui ordine è dedicato a scrivere tutti i possibili nomi di Dio, scritti nel loro proprio alfabeto. In sostanza, sono dedicati a scrivere ogni possibile permutazione del loro alfabeto, limitato da alcune regole. Nella storia, il monastero assume alcuni ingegneri per scrivere un programma per fare tutto il lavoro per loro. Il tuo obiettivo è scrivere quel programma.

Regole:

• L'alfabeto del monaco usa 13 caratteri (secondo le mie stime). Puoi usare ABCDEFGHIJKLMo qualche altro set di 13 caratteri.

• La lunghezza minima di un nome possibile è 1 carattere. La lunghezza massima è di 9 caratteri.

• Nessun personaggio può ripetere più di 3 volte in successione. AAABAè un nome valido, ma AAAABnon lo è.

• Il tuo programma dovrebbe stampare (su un file) ogni possibile nome in sequenza da Aa MMMLMMMLM, separato da qualsiasi carattere non presente nell'alfabeto (newline, punti e virgola, qualunque cosa).

• Questo è code-golf e puoi usare qualsiasi lingua. Vince la soluzione più breve entro il 1 giugno 2014.

Modifica: i nomi dovrebbero iniziare con Ae terminare MMMLMMMLM, procedendo in sequenza attraverso tutti i miliardi di nomi. Ma la sequenza particolare dipende da te. Puoi stampare prima tutti i nomi di 1 lettera, quindi tutti i nomi di 2 lettere, ecc. Oppure puoi stampare tutti i nomi che iniziano con A, quindi tutti quelli che iniziano con B, o qualche altro motivo. Ma un essere umano dovrebbe essere in grado di leggere il file e confermare che sono tutti lì e nell'ordine logico che scegli, supponendo che abbiano il tempo.

Ruby, 46

?A.upto(?M*9){|s|s[/(.)\1{3}|[N-Z]/]||puts(s)}

La mia soluzione originale e simile era più lunga e sbagliata (produceva numeri base13, che non sono tutti dovuti a zero iniziali), ma la lascerò qui perché ha comunque ottenuto voti.

1.upto(13**9){|i|(s=i.to_s 13)[/(.)\1{3}/]||puts(s)}

C 140 177 235

Buon vecchio stile procedurale, nessuna fantasia.
Conta (senza scrivere) 11.459.252.883 nomi in 8 minuti.
Prossima modifica con il runtime e la dimensione del file dei nomi. Guarda il cielo ...
Durata 57 minuti, dimensione file 126.051.781.713 (9 caratteri + crlf per riga). Per favore dimmi l'indirizzo e-mail dei monaci, in modo che io possa inviare loro il file zippato, per il controllo manuale ...

Modifica Golf un po 'di più, rielaborato l'assegno per lettere ripetute.
Non è ancora il più breve, ma almeno questo termina e genera l'output richiesto.
Durata 51 min, dimensione file 113.637.155.697 (non ci sono spazi vuoti iniziali questa volta)

Una nota a margine: ovviamente il file di output è molto comprimibile, tuttavia ho dovuto uccidere 7zip, dopo aver lavorato 36 ore era al 70%. Strano.

char n[]="@@@@@@@@@@";p=9,q,r;main(){while(p)if(++n[p]>77)n[p--]=65;else for(r=q=p=9;r&7;)(r+=r+(n[q]!=n[q-1])),n[--q]<65&&puts(n+q+1,r=0);}

Ungolfed

char n[]="@@@@@@@@@@";
p=9,q,r;
main()
{
    while (p)
    {
        if (++n[p] > 77)
        {
            n[p--] = 65; // when max reached, set to min and move pointer to left
        }
        else 
        {
            for (r=q=p=9; r & 7 ;) // r must start as any odd number
            {
                r += r+(n[q]!=n[q-1])); // a bitmap: 1 means a difference, 000 means 4 letters equal
                n[--q] < 65 && puts(n+q+1,r=0);
            }
        }
    }
}

Golfscript, 58 47 caratteri

"A"13
9?,{13base{65+}%n+}%{`{\4*/,}+78,1/%1-!},

Grazie a Peter Taylor, mi viene risparmiato dal seppuku di non battere la soluzione di Ruby! Esegui il codice fino a 10 da solo , e qui è la prova che salta i numeri di quattro righe .

Utilità della riga di comando di Bash + Linux, 43 byte

jot -w%x $[16**9]|egrep -v "[0ef]|(.)\1{3}"

Questo utilizza una tecnica simile alla mia risposta di seguito, ma conta solo nella base 16 e rimuove tutti i "nomi" contenenti 0, eo fanche quelli con più di 3 stesse cifre consecutive.

Converti in alfabeto del monaco come segue:

jot -w%x $[16**9]|egrep -v "[0ef]|(.)\1{3}" | tr 1-9a-d A-M

Bash + coreutils (dc ed egrep), 46 byte

Modifica: versione corretta

dc<<<Edo9^[p1-d0\<m]dsmx|egrep -v "0|(.)\1{3}"

Questo richiederà un po 'di tempo per funzionare ma penso che sia corretto.

dcconta verso il basso da 14 ^ 9 a 1 e genera in base 14. egrep filtra i numeri con più di 3 cifre consecutive consecutive. Filtriamo anche tutti i nomi con cifre "0", in modo da ottenere il set corretto di lettere nei nomi.

La domanda specifica che può essere usato qualsiasi alfabeto, quindi sto usando [1-9] [AD]. Ma per i test, questo può essere trasformato in [AM] usando tr:

dc<<<Edo9^[p1-d0\<m]dsmx|egrep -v "0|(.)\1{3}" | tr 1-9A-D A-M

Questo produce la sequenza:

MMMLMMMLM MMMLMMMLL MMMLMMMLK ... AC AB AA M L K ... C B A

Nota questo dccomando richiede il ricorsione della coda per funzionare. Funziona su DC versione 1.3.95 (Ubuntu 12.04) ma non 1.3 (OSX Mavericks).

APL (59)

↑Z/⍨{~∨/,↑⍷∘⍵¨4/¨⎕A[⍳13]}¨Z←⊃,/{↓⍉⎕A[1+(⍵/13)⊤¯1⌽⍳13*⍵]}¨⍳9

Scritto nel suo stesso alfabeto :) È un po 'lungo. Ci vuole anche molto tempo per eseguirlo 9, provalo con un numero inferiore per testarlo se lo desideri.

Spiegazione:

• {... }¨⍳9: per ogni numero ⍵da 1 a 9:
  • ⍳13*⍵: ottieni tutti i numeri da 1 a 13^⍵
  • ¯1⌽: Ruotare la lista verso sinistra di 1 (in modo da avere 13^⍵, 1, 2, ..., 13^⍵-1, che si trasforma in 0, 1, 2 ...modulo 13^⍵).
  • (⍵/13)⊤: codifica ogni numero nella base 13 usando le ⍵cifre
  • ⎕A[1+... ]: aggiungi uno (le matrici sono 1 indicizzate) e cerca in ⎕A(l'alfabeto)
  • ↓⍉: trasforma la matrice in un vettore di vettori lungo le colonne.
• Z←⊃,/: unisci ogni vettore interno di vettori, dandoci un elenco di nomi possibili (ma non soddisfa ancora le regole).
• {... }¨: per ogni nome, verifica se soddisfa la regola dei 4 caratteri ripetuti:
  • 4/¨⎕A[⍳13]: per ogni carattere, genera una stringa di 4 di quel carattere
  • ⍷∘⍵¨: per ogni stringa, verifica se è presente in ⍵
  • ∨/,↑: accetta la logica o di tutti questi test,
  • ~: e capovolgilo, quindi 1significa che soddisfa le regole e 0significa che non lo fa.
• Z/⍨: seleziona tra Ztutti gli elementi che incontrano i ruderi
• ↑: visualizza ognuno su una riga separata

Perl, 70 68 66 50 caratteri

$"=",";map/(.)\1{3}/||say,glob$i.="{@a}"for@a=A..M

Uso:

$ perl -E 'code' > output_file

La cosa bella è che le stampe sono bufferate, quindi ottieni prima tutte le soluzioni a 1 carattere, seguite da parole a 2 caratteri e così via.

Perl - 35 byte

#!perl -l
/(.)\1{3}|[N-Z]/||print for A..1x9

Contando lo shebang come un byte.

Questa è una traduzione libera della risposta dell'istocratico .

A..1x9è un po 'strano; questa è una scorciatoia per 'A'..'111111111'. L'accumulatore non raggiungerà mai effettivamente il valore del terminale (contiene solo lettere maiuscole), ma terminerà comunque una volta che avrà una lunghezza superiore a 9 caratteri. Questo può essere testato, ad esempio, usando 1x4invece.

Pyg (Waaay troppo a lungo, per una lingua fatta per il golf)

sussurri : 101 ...

Pe(*ItCh(((J(x)for x in ItPr("ABCDEFGHIJKLM",repeat=j)if not An((i*3 in x)for i in x))for j in R(14))))

Anche se questo è vicino a come lo farei in Python:

from itertools import *
for i in range(14):
    for j in ("".join(k) for k in product("ABCDEFGHIJKLM",repeat=i) if not any((i*3 in k) for i in k)):
        print j

Meno ovviamente la complicazione a lungo termine;)

Pyth , 34 caratteri

Kf<T"n"GJKFbJI>lb9Bb~Jm+bdfXVb*Y3K

Spiegazione:

Kf<T"n"G        K = list of letters in the alphabet before n.
JK              J = copy of K
FbJ             For b in J:
I>lb9B          If length of b > 9: break
b               print(b)
~J              J+=
~Jm+bd          J+=map(lambda d:b+d,
       XVb*Y3   index of Y*3 in reversed(b)
      fXVb*Y3K  filter for non-zero for Y in K on function index of Y*3 in reversed(b)
~Jm+bdfXVb*Y3K  J+=map(lambda d:b+d, filter(lambda Y:index of Y*3 in reversed(b), K))

Python 2 - 212 byte

from itertools import chain,product as p
a='ABCDEFGHIJKLM'
q={c*4 for c in a}
c=0
for n in chain(*(p(*([a]*l)) for l in range(1,10))):
 n=''.join(n)
 if not any(u in n for u in q):print n
 c+=1
 if c==10**9:break

Japt , 21 byte

Ep9 osE kè/0|(.)\1{3}

Provalo online! (il collegamento calcola solo fino a 14**4.)

Come funziona

Ep9 osE kè/0|(.)\1{3}/

Ep9  14**9
osE  Range from 0 to n (exclusive), mapped through base-14 conversion
kè   Remove elements that match at least once...
/0|(.)\1{3}/  the regex that matches a zero or four times same char.

Presuppone un'implementazione ECMAScript 2017 standard come livello JS (e memoria sufficiente per archiviare l'array), in cui un Arrayoggetto può avere la massima 2**53-1lunghezza.