Fissione , 1328 989 887 797 byte
Questa risposta è un po 'irragionevolmente lunga (vorrei che avessimo regioni pieghevoli ) ... per favore, non dimenticare di scorrere oltre e mostrare alle altre risposte un po' d'amore!
Lavorare su questo codice è stato ciò che ha ispirato questa sfida. Volevo aggiungere una risposta in Fissione a EOEIS, che mi ha portato a questa sequenza. Tuttavia, in realtà l'apprendimento di Fission e l'attuazione di questo hanno richiesto alcune settimane lavorando su di esso. Nel frattempo, la sequenza era davvero cresciuta su di me, quindi ho deciso di postare una sfida separata (in più, comunque, non sarebbe stato particolarmente lontano su EOEIS).
Quindi vi presento la mostruosità:
R'0@+\
/ Y@</ /[@ Y]_L
[? % \ / \ J
\$@ [Z/;[{+++++++++L
UR+++++++++>/;
9\ ; 7A9
SQS {+L /$ \/\/\/\/\/ 5/ @ [~ &@[S\/ \ D /8/
~4X /A@[ %5 /; & K } [S//~KSA /
3 \ A$@S S\/ \/\/\/ \/>\ /S]@A / \ { +X
W7 X X /> \ +\ A\ / \ /6~@/ \/
/ ~A\; +;\ /@
ZX [K / {/ / @ @ } \ X @
\AS </ \V / }SZS S/
X ;;@\ /;X /> \ ; X X
; \@+ >/ }$S SZS\+; //\V
/ \\ /\; X X @ @ \~K{
\0X / /~/V\V / 0W//
\ Z [K \ //\
W /MJ $$\\ /\7\A /;7/\/ /
4}K~@\ &] @\ 3/\
/ \{ }$A/1 2 }Y~K <\
[{/\ ;@\@ / \@<+@^ 1;}++@S68
@\ <\ 2 ; \ /
$ ;}++ +++++++L
%@A{/
M \@+>/
~ @
SNR'0YK
\ A!/
Si aspetta che non ci sia newline finale nell'input, quindi potresti voler chiamarlo come echo -n 120 | ./Fission oeis256504.fis.
Il layout potrebbe probabilmente essere ancora più efficiente, quindi penso che ci sia ancora molto spazio per miglioramenti qui (ad esempio, questo contiene 911 581 461 374 spazi).
Prima di arrivare alla spiegazione, una nota sul test di questo: l' interprete ufficiale non funziona del tutto così com'è. a) Mirror.cppnon compilare su molti sistemi. Se riscontri questo problema, commenta semplicemente la riga offensiva: il componente interessato (un mirror casuale) non viene utilizzato in questo codice. b) Ci sono un paio di bug che possono portare a comportamenti indefiniti (e probabilmente lo faranno per un programma così complesso). È possibile applicare questa patch per risolverli. Una volta fatto ciò, dovresti essere in grado di compilare l'interprete con
g++ -g --std=c++11 *.cpp -o Fission
Curiosità: questo programma utilizza quasi tutti i componenti che Fission ha da offrire, ad eccezione di #(mirror casuale), :(half mirror) -o |(plain mirror) e "(modalità di stampa).
Cosa diavolo?
Attenzione: questo sarà piuttosto lungo ... Suppongo che tu sia sinceramente interessato a come funziona Fission e come si potrebbe programmare in esso. Perché se non lo sei, non sono sicuro di come potrei riassumere questo. (Il prossimo paragrafo fornisce una descrizione generale della lingua.)
La fissione è un linguaggio di programmazione bidimensionale, in cui sia il flusso di dati che di controllo sono rappresentati da atomi che si muovono attraverso una griglia. Se hai già visto o usato Marbelous in precedenza, il concetto dovrebbe essere vagamente familiare. Ogni atomo ha due proprietà intere: una massa non negativa e un'energia arbitraria. Se la massa diventa negativa, l'atomo viene rimosso dalla griglia. Nella maggior parte dei casi puoi considerare la massa come il "valore" dell'atomo e l'energia come una sorta di meta-proprietà che viene utilizzata da diversi componenti per determinare il flusso degli atomi (cioè la maggior parte dei tipi di interruttori dipende dal segno di l'energia). Indicherò gli atomi con (m,E), quando necessario. All'inizio del programma, la griglia inizia con un gruppo di(1,0)atomi da qualsiasi posizione sui quattro componenti UDLR(dove la lettera indica la direzione in cui si muove inizialmente l'atomo). La scheda viene quindi popolata con un intero gruppo di componenti che cambiano la massa e l'energia degli atomi, cambiano direzione o fanno altre cose più sofisticate. Per un elenco completo vedere la pagina di esolangs , ma introdurrò la maggior parte di essi in questa spiegazione. Un altro punto importante (che il programma utilizza più volte) è che la griglia è toroidale: un atomo che colpisce uno dei lati riappare dalla parte opposta, muovendosi nella stessa direzione.
Ho scritto il programma in diverse parti più piccole e le ho assemblate alla fine, quindi è così che passerò attraverso la spiegazione.
atoi
Questo componente può sembrare piuttosto poco interessante, ma è carino e semplice e mi permette di introdurre molti dei concetti importanti del flusso aritmetico e di controllo di Fission. Pertanto, analizzerò questa parte con un dettaglio abbastanza meticoloso, in modo da poter ridurre le altre parti all'introduzione di nuove meccaniche di Fissione e sottolineando i componenti di livello superiore di cui dovresti essere in grado di seguire te stesso il flusso di controllo dettagliato.
La fissione può leggere solo valori di byte da singoli caratteri, non interi numeri. Mentre questa è una pratica accettabile da queste parti, ho pensato che mentre ero lì, avrei potuto farlo bene e analizzare numeri interi reali su STDIN. Ecco il atoicodice:
;
R'0@+\
/ Y@</ /[@ Y]_L
[? % \ / \ J
\$@ [Z/;[{+++++++++L
UR+++++++++>/;
O
Due dei componenti più importanti in Fissione sono i reattori a fissione e fusione. I reattori a fissione sono uno dei V^<>(utilizza il codice sopra <e >). Un reattore a fissione può immagazzinare un atomo (inviandolo nel cuneo del personaggio), di default (2,0). Se un atomo colpisce l'apice del personaggio, due nuovi atomi verranno inviati ai lati. La loro massa viene determinata dividendo la massa in arrivo per la massa immagazzinata (cioè dimezzando di default) - l'atomo di sinistra ottiene questo valore e l'atomo di destra ottiene il resto della massa (cioè la massa viene conservata nella fissione) . Entrambi gli atomi in uscita avranno meno energia in entratal'energia immagazzinata. Ciò significa che possiamo usare i reattori a fissione per l'aritmetica, sia per la sottrazione che per la divisione. Se un reattore a fissione viene colpito dal sito, l'atomo viene semplicemente riflesso in diagonale e quindi si sposta nella direzione dell'apice del personaggio.
I reattori a fusione sono uno dei YA{}(utilizza il codice sopra Ye {). La loro funzione è simile: possono immagazzinare un atomo (impostazione predefinita (1,0)) e quando colpiti dall'apice due nuovi atomi verranno inviati ai lati. Tuttavia, in questo caso i due atomi saranno identici, mantenendo sempre l'energia in arrivo e moltiplicando la massa in arrivo per la massa immagazzinata. Cioè, per impostazione predefinita, il reattore a fusione duplica semplicemente qualsiasi atomo che colpisce il suo apice. Quando viene colpito dai lati, reattori a fusione sono un po 'più complicato: l'atomo è anchememorizzato (indipendentemente dall'altra memoria) fino a quando un atomo colpisce il lato opposto. Quando ciò accade, un nuovo atomo viene rilasciato nella direzione dell'apice la cui massa ed energia sono la somma dei due vecchi atomi. Se un nuovo atomo colpisce lo stesso lato prima che un atomo corrispondente raggiunga il lato opposto, il vecchio atomo verrà semplicemente sovrascritto. I reattori a fusione possono essere utilizzati per implementare l'addizione e la moltiplicazione.
Un altro componente semplice voglio ottenere fuori strada è [e ]che semplicemente imposta la direzione della atomo destra e sinistra, rispettivamente (indipendentemente dalla direzione in entrata). Gli equivalenti verticali sono M(giù) e W(su) ma non sono usati per il atoicodice. UDLRagiscono anche come WM][dopo aver rilasciato i loro atomi iniziali.
Comunque, diamo un'occhiata al codice lassù. Il programma inizia con 5 atomi:
- Il
Re Lin basso ottengono semplicemente il loro incremento di massa (con +) per diventare (10,0)e quindi immagazzinare rispettivamente in una fissione e in un reattore a fusione. Useremo questi reattori per analizzare l'ingresso in base 10.
- Il
Lnell'angolo superiore destro ottiene la sua massa decrementato (con _) per diventare (0,0)e viene memorizzato nel lato di un reattore a fusione Y. Questo per tenere traccia del numero che stiamo leggendo: aumenteremo e moltiplicheremo gradualmente mentre leggiamo i numeri.
- Il
Rnell'angolo in alto a sinistra ottiene il suo set massa al codice di carattere 0(48) con '0, quindi massa ed energia sono scambiati con @e infine massa incrementato una volta con +dare (1,48). Viene quindi reindirizzato con specchi diagonali \e /conservato in un reattore a fissione. Useremo la 48sottrazione per trasformare l'ingresso ASCII nei valori effettivi delle cifre. Abbiamo anche dovuto aumentare la massa 1per evitare la divisione di 0.
- Infine,
Unell'angolo in basso a sinistra è ciò che in realtà mette tutto in movimento e viene inizialmente utilizzato solo per il flusso di controllo.
Dopo essere stato reindirizzato a destra, l'atomo di controllo colpisce ?. Questo è il componente di input. Legge un personaggio e imposta la massa dell'atomo sul valore ASCII letto e l'energia su 0. Se invece colpiamo EOF, l'energia sarà impostata su 1.
L'atomo continua e poi colpisce %. Questo è un interruttore mirror. Per energia non positiva, questo si comporta come uno /specchio. Ma per l'energia positiva agisce come un \(e diminuisce anche l'energia di 1). Quindi, mentre stiamo leggendo i personaggi, l'atomo verrà riflesso verso l'alto e potremo elaborare il personaggio. Ma quando avremo finito con l'input, l'atomo verrà riflesso verso il basso e potremo applicare una logica diversa per recuperare il risultato. Cordiali saluti, il componente opposto è &.
Quindi per ora abbiamo un atomo che sale. Quello che vogliamo fare per ogni personaggio è leggere il suo valore in cifre, aggiungerlo al nostro totale corrente e quindi moltiplicare quel totale corrente per 10 per preparare la cifra successiva.
L'atomo personaggio colpisce prima un reattore a fusione (predefinito) Y. Questo divide l'atomo e usiamo la copia di sinistra come atomo di controllo per tornare indietro nel componente di input e leggere il carattere successivo. La copia corretta verrà elaborata. Considera il caso in cui abbiamo letto il personaggio 3. Lo sarà il nostro atomo (51,0). Scambiamo massa ed energia @, in modo tale da poter sfruttare la sottrazione del prossimo reattore a fissione. Il reattore sottrae 48l'energia (senza cambiare la massa), quindi invia due copie di (0,3)- l'energia ora corrisponde alla cifra che abbiamo letto. La copia in uscita viene semplicemente scartata con ;(un componente che distrugge tutti gli atomi in arrivo). Continueremo a lavorare con la copia discendente. Dovrai seguire il suo percorso attraverso/e \rispecchia un po '.
Il @poco prima che il reattore a fusione scambia nuovamente massa ed energia, in modo da aggiungere (3,0)al totale corrente il Y. Si noti che lo stesso totale corrente avrà quindi sempre 0energia.
Adesso Jè un salto. Ciò che fa è saltare qualsiasi atomo in arrivo in avanti con la sua energia. Se lo è 0, l'atomo continua a muoversi dritto. In questo caso 1salterà una cella, in caso contrario 2salterà due celle e così via. L'energia viene spesa nel salto, quindi l'atomo finisce sempre con energia 0. Poiché il totale parziale non ha energia, il salto viene ignorato per ora e l'atomo viene reindirizzato nel reattore a fusione {che moltiplica la sua massa per 10. La copia discendente viene scartata ;mentre la copia ascendente viene reimmessa nel Yreattore come nuovo totale parziale .
Quanto sopra continua a ripetersi (in un modo divertente pipeline in cui vengono elaborate nuove cifre prima di quelle precedenti) fino a quando non colpiamo EOF. Ora %invierà l'atomo verso il basso. L'idea è di trasformare questo atomo in (0,1)ora prima di colpire il reattore totale in funzione in modo che a) il totale non sia influenzato (massa zero) eb) otteniamo un'energia 1per saltare sopra [. Possiamo facilmente prenderci cura dell'energia con $, che aumenta l'energia.
Il problema è che ?non reimposta la massa quando si colpisce EOF, quindi la massa sarà ancora quella dell'ultimo personaggio letto e l'energia sarà 0(perché %diminuita di 1nuovo 0). Quindi vogliamo sbarazzarci di quella massa. Per fare ciò, scambiamo @nuovamente massa ed energia .
Ho bisogno di introdurre un componente di più prima di terminare questa sezione: Z. Questo è essenzialmente lo stesso di %o &. La differenza è che consente agli atomi di energia positiva di passare direttamente (mentre diminuisce l'energia) e devia gli atomi di energia non positiva di 90 gradi a sinistra. Possiamo usarlo per eliminare l'energia di un atomo facendola scorrere Zripetutamente, non appena l'energia sarà andata via, l'atomo verrà deviato e lascerà il circuito. Questo è questo modello:
/ \
[Z/
dove l'atomo si sposterà verso l'alto una volta che l'energia è zero. Userò questo schema in una forma o nell'altra più volte nelle altre parti del programma.
Quindi quando l'atomo lascia questo piccolo anello, sarà (1,0)e sostituito (0,1)da @prima di colpire il reattore a fusione per rilasciare il risultato finale dell'input. Tuttavia, il totale parziale sarà disattivato di un fattore 10, perché lo abbiamo già moltiplicato provvisoriamente per un'altra cifra.
Quindi ora con energia 1, questo atomo salterà [e salterà dentro /. Questo lo devia in un reattore a fissione che abbiamo preparato per dividere per 10 e correggere la nostra moltiplicazione estranea. Ancora una volta, scartiamo la metà con ;e manteniamo l'altro come output (qui rappresentato con il Oquale semplicemente stampare il personaggio corrispondente e distruggere l'atomo - nel programma completo continuiamo invece a usare l'atomo).
itoa
/ \
input -> [{/\ ;@
@\ <\
$ ;}++ +++++++L
%@A{/
M \@+>/
~ @
SNR'0YK
\ A!/
Naturalmente, dobbiamo anche riconvertire il risultato in una stringa e stamparlo. Ecco a cosa serve questa parte. Ciò presuppone che l'input non arrivi prima del segno di spunta 10 o giù di lì, ma nel programma completo viene facilmente fornito. Questo bit si trova in fondo al programma completo.
Questo codice introduce un nuovo componente Fission molto potente: lo stack K. Lo stack è inizialmente vuoto. Quando un atomo con energia non negativa colpisce la pila, l'atomo viene semplicemente spinto sulla pila. Quando un atomo con energia negativa colpisce la pila, la sua massa ed energia saranno sostituite dall'atomo nella parte superiore della pila (che viene così fatto scoppiare). Se lo stack è vuoto, la direzione dell'atomo viene invertita e la sua energia diventa positiva (cioè viene moltiplicata per -1).
Ok, torniamo al codice attuale. L'idea dello itoasnippet è di prendere ripetutamente l'input modulo 10 per trovare la cifra successiva dividendo l'input per 10 per la successiva iterazione. Ciò produrrà tutte le cifre in ordine inverso (dal meno significativo al più significativo). Per correggere l'ordine, spingiamo tutte le cifre in una pila e alla fine le estraiamo una per una per stamparle.
La metà superiore del codice esegue il calcolo delle cifre: Lcon i plus si ottiene un 10 che cloniamo e alimentiamo in una fissione e in un reattore a fusione in modo che possiamo dividere e moltiplicare per 10. Il loop inizia essenzialmente dopo il [nell'angolo in alto a sinistra . Il valore corrente viene diviso: una copia viene divisa per 10, quindi moltiplicata per 10 e memorizzata in un reattore a fissione, che viene quindi colpito dall'altra copia all'apice. Questo calcola i % 10come i - ((i/10) * 10). Si noti inoltre che Adivide il risultato intermedio dopo la divisione e prima della moltiplicazione, in modo che possiamo alimentare i / 10la successiva iterazione.
Si %interrompe il ciclo quando la variabile di iterazione raggiunge 0. Dato che si tratta più o meno di un ciclo do-while, questo codice funzionerebbe anche per la stampa 0(senza creare zero iniziali altrimenti). Una volta lasciato il ciclo vogliamo svuotare la pila e stampare le cifre. Sè l'opposto di Z, quindi è un interruttore che devia un atomo in arrivo con energia non positiva di 90 gradi a destra. Quindi l'atomo in realtà si sposta sul bordo dal Srettilineo al Kpop-up di una cifra (nota ~che assicura che l'atomo in arrivo abbia energia -1). Quella cifra viene incrementata di 48per ottenere il codice ASCII del carattere della cifra corrispondente. Il Adivide la cifra per stampare una copia con!e reinserire l'altra copia nel Yreattore per la cifra successiva. La copia stampata viene utilizzata come innesco successivo per la pila (si noti che anche gli specchi lo inviano attorno al bordo per colpire Mda sinistra).
Quando la pila è vuota, la Kvolontà rifletterà l'atomo e trasformerà la sua energia in +1modo che passi direttamente attraverso S. Nstampa una nuova riga (solo perché è pulita :)). E poi l'atomo va di R'0nuovo attraverso per finire nel lato del Y. Poiché non ci sono altri atomi in giro, questo non verrà mai rilasciato e il programma termina.
Calcolo del numero di fissione: il framework
Andiamo alla carne reale del programma. Il codice è sostanzialmente una porta della mia implementazione di riferimento di Mathematica:
fission[n_] := If[
(div =
SelectFirst[
Reverse@Divisors[2 n],
(OddQ@# == IntegerQ[n/#]
&& n/# > (# - 1)/2) &
]
) == 1,
1,
1 + Total[fission /@ (Range@div + n/div - (div + 1)/2)]
]
dove divè il numero di numeri interi nella partizione massima.
Le differenze principali sono che non possiamo gestire valori a mezzo numero intero in Fission, quindi sto facendo molte cose moltiplicate per due e che non c'è ricorsione in Fission. Per ovviare a questo, sto spingendo tutti gli interi in una partizione in una coda per essere elaborati in seguito. Per ogni numero che elaboriamo, incrementeremo un contatore di uno e una volta che la coda è vuota, rilasceremo il contatore e lo spediremo per la stampa. (Una coda, Qfunziona esattamente come K, solo nell'ordine FIFO.)
Ecco un framework per questo concetto:
+--- input goes in here
v
SQS ---> compute div from n D /8/
~4X | /~KSA /
3 +-----------> { +X
initial trigger ---> W 6~@/ \/
4
W ^ /
| 3
^ generate range |
| from n and div <-+----- S6
| -then-
+---- release new trigger
I nuovi componenti più importanti sono le cifre. Questi sono teletrasporto. Tutti i teletrasporto con la stessa cifra appartengono insieme. Quando un atomo colpisce un qualsiasi teletrasporto, verrà immediatamente spostato il teletrasporto successivo nello stesso gruppo, dove il successivo viene determinato nel solito ordine da sinistra a destra, dall'alto verso il basso. Questi non sono necessari, ma aiutano con il layout (e quindi il golf un po '). C'è anche quello Xche duplica semplicemente un atomo, inviando una copia direttamente davanti e l'altra all'indietro.
Ormai potresti riuscire a risolvere da solo la maggior parte del framework. L'angolo in alto a sinistra ha la coda di valori ancora da elaborare e rilascia uno nalla volta. Una copia di nviene teletrasportata in basso perché ne abbiamo bisogno durante il calcolo dell'intervallo, l'altra copia va nel blocco in alto che calcola div(questa è di gran lunga la sezione più grande del codice). Una volta divcalcolato, viene duplicato: una copia incrementa un contatore nell'angolo in alto a destra, in cui è memorizzato K. L'altra copia viene teletrasportata verso il basso. Se lo divfosse 1, lo deviamo immediatamente verso l'alto e lo usiamo come trigger per la successiva iterazione, senza accodare alcun nuovo valore. Altrimenti usiamo diven nella sezione in basso per generare il nuovo intervallo (ovvero un flusso di atomi con le masse corrispondenti che vengono successivamente inserite nella coda), quindi rilasciare un nuovo trigger dopo che l'intervallo è stato completato.
Una volta che la coda è vuota, il grilletto verrà riflesso, passando direttamente attraverso Se riapparendo nell'angolo in alto a destra, da cui rilascia il contatore (il risultato finale) A, che viene poi teletrasportato su itoavia 8.
Calcolo del numero di fissione: il corpo del loop
Quindi tutto ciò che rimane sono le due sezioni per calcolare dive generare l'intervallo. Il calcolo divè questa parte:
;
{+L /$ \/\/\/\/\/ 5/ @ [~ &@[S\/ \
/A@[ %5 /; & K } [S/
\ A$@S S\/ \/\/\/ \/>\ /S]@A / \
X X /> \ +\ A\ / \ /
/ ~A\; +;\ /@
ZX [K / {/ / @ @ } \ X @
\AS </ \V / }SZS S/
X ;;@\ /;X /> \ ; X X
\@+ >/ }$S SZS\+; //\V
/ \\ /\; X X @ @ \~K{
\0X / /~/V\V / 0W//
\ Z [K \ //\
\ /\7\A /;7/\/
Probabilmente hai visto abbastanza ora per risolverlo da solo con un po 'di pazienza. La suddivisione di alto livello è questa: le prime 12 colonne o giù di lì generano un flusso di divisori di 2n. Le prossime 10 colonne filtrano quelle che non soddisfano OddQ@# == IntegerQ[n/#]. Le successive 8 colonne filtrano quelle che non soddisfano n/# > (# - 1)/2). Alla fine spingiamo tutti i divisori validi su uno stack e, una volta terminato, svuotiamo l'intero stack in un reattore a fusione (sovrascrivendo tutti tranne l'ultimo / il più grande divisore) e quindi rilasciamo il risultato, seguito eliminando la sua energia (che non era -zero dal controllo della disuguaglianza).
Ci sono molti percorsi folli lì dentro che non fanno davvero nulla. Prevalentemente, la \/\/\/\/follia in alto (anche le 5s ne fanno parte) e un percorso intorno al fondo (che attraversa la 7s). Ho dovuto aggiungere questi per affrontare alcune brutte condizioni di gara. Fission potrebbe utilizzare un componente di ritardo ...
Il codice che genera il nuovo intervallo da ned divè questo:
/MJ $$\
4}K~@\ &] @\ 3/\
\{ }$A/1 2 }Y~K <\
\@ / \@<+@^ 1;}++@
2 ; \ /
Prima calcoliamo n/div - (div + 1)/2(entrambi i termini floored, che produce lo stesso risultato) e archiviamo per dopo. Quindi generiamo un intervallo da divgiù a 1e aggiungiamo il valore memorizzato a ciascuno di essi.
Ci sono due nuovi schemi comuni in entrambi, che dovrei menzionare: uno è SXo ZXcolpito dal basso (o versioni ruotate). Questo è un bel modo per duplicare un atomo se vuoi che una copia vada avanti (dal momento che il reindirizzamento delle uscite di un reattore a fusione a volte può essere ingombrante). Il So Zruota l'atomo nel Xe quindi ruota la copia specchiata nella direzione originale di propagazione.
L'altro modello è
[K
\A --> output
Se memorizziamo un valore qualsiasi, Kpossiamo recuperarlo ripetutamente colpendo Kcon energia negativa dall'alto. Il Aduplica il valore che ci interessa e invia ciò che copiare posteriore destra nello stack per la prossima volta ne abbiamo bisogno.
Beh, è stato un bel po '... ma se hai davvero superato questo, spero che tu abbia avuto l'idea che Fission i͝s̢̘̗̗ ͢i̟nç̮̩r̸̭̬̱͔e̟̹̟̜͟d̙i̠͙͎̖͓̯b̘̠͎̭̰̼l̶̪̙̮̥̮y̠̠͎̺͜ ͚̬̮f̟͞u̱̦̰͍n͍ ̜̠̙t̸̳̩̝o ̫͉̙͠p̯̱̭͙̜͙͞ŕ̮͓̜o̢̙̣̭g̩̼̣̝r̤͍͔̘̟ͅa̪̜͇m̳̭͔̤̞ͅ ͕̺͉̫̀ͅi͜n̳̯̗̳͇̹.̫̞̲̞̜̳