Dovresti scrivere un programma brainfuck (BF) lungo 100 byte.

Un carattere verrà rimosso da esso in ogni modo possibile con i 100 nuovi programmi (lunghi 99 byte) risultanti. Ad esempio per il programma ++.>.dei 5 sottoprogrammi sono +.>., +.>., ++>., ++..e ++.>.

Il tuo punteggio sarà il numero di output unici generati dai 100 programmi. Il punteggio più alto è migliore.

Dettagli

• I programmi verranno chiusi dopo aver emesso il primo carattere.
• I programmi non validi o non terminanti e i programmi che generano output vuoti non vengono conteggiati per il punteggio.
• Le celle BF sono avvolgenti a 8 bit. (255 + 1 = 0, 0-1 = 255)
• Il tuo programma non ha ricevuto input. Se si utilizza ,nel codice impostato è la cella corrente su 0.
• Non ci sono celle sul lato sinistro della posizione iniziale. Ad esempio, <.non è valido ma .<è valido poiché l'esecuzione è terminata alle .. Il nastro non ha limiti nell'altra direzione.
• I programmi con parentesi sbilanciate ( [e ]) non sono validi.
• Il programma originale può essere inferiore a 100 byte in quanto è facile estenderlo a 100 byte senza modificare il punteggio.
• Il tuo programma originale non deve essere un codice BF valido.

Puoi usare questo programma python3 (collegamento ideone) per determinare il punteggio della tua risposta. (Per programmi a esecuzione prolungata potrebbe essere necessario modificare la maxstepvariabile.)

Esempio

(Per semplicità questo programma è più breve di 100 byte.)

Solution: ++,+[-]+><.-,-.

Score: 3

Explanation:

Subprogram     => Output

+,+[-]+><.-,-. => 1
+,+[-]+><.-,-. => 1
+++[-]+><.-,-. => 1
++,[-]+><.-,-. => 1
++,+-]+><.-,-. => None
++,+[]+><.-,-. => None
++,+[-+><.-,-. => None
++,+[-]><.-,-. => 0
++,+[-]+<.-,-. => None
++,+[-]+>.-,-. => 0
++,+[-]+><-,-. => 255
++,+[-]+><.,-. => 1
++,+[-]+><.--. => 1
++,+[-]+><.-,. => 1
++,+[-]+><.-,- => 1

Unique outputs are [0, 1, 255]    
Score is 3 for ++,+[-]+><.-,-. (length = 15)

In caso di pareggio, il vincitore è quello con il codice più breve. (Il programma può essere inferiore a 100 byte, come indicato nella sezione Dettagli.) Se i codici hanno la stessa lunghezza, il vincitore è il poster precedente.

Puzzle bonus: senza la restrizione in grassetto puoi trovare un programma con punteggio 100?

Punteggio: 35 41 69 78 79 83

(Rimuovi la nuova riga.)

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

Provalo online!

Non sono sicuro esattamente perché funzioni ...

Punteggio: 79

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

Provalo online!

E 'stato supposto per sommare 2 * mem [i] * i e aggiungere il numero di cellule (+ const) in cui gli indirizzi vengono contati da destra verso sinistra. Il moltiplicatore 2 e il numero di celle può rendere la rimozione di + e> con parità diversa.

In effetti ha funzionato così nella versione a 69 punti. Ma l'ultima versione l'ha rotto e ha ottenuto qualcos'altro per coincidenza. Calcola la somma (mem [i] * i + i + 1) e la rimozione di + e> fa quasi lo stesso, fatta eccezione per la somma (i) che ha una differenza del numero di celle, che è anche il numero di output diverso per rimuovere + e>.

Per il bonus:

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

Punteggio: 37 43

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

EDIT: Ora il mio programma consente alcune parentesi quadre. Non vincerò alcun premio, ma è quello che ottengo facendo fare ad alcuni RNG ponderati il ​​lavoro impegnato per me.

Questo è stato generato da un programma che ho scritto in C.

Per ogni Ncarattere rimosso, ecco gli output:

N = 0 => 158
N = 1 => 158
N = 2 => 158
N = 3 => 187
N = 4 => 129
N = 5 => 100
N = 6 => 158
N = 7 => 13
N = 8 => 1
N = 9 => 211
N = 10 => 129
N = 11 => 1
N = 12 => 57
N = 13 => 255
N = 14 => Mismatched Braces
N = 15 => 59
N = 16 => 11
N = 17 => 11
N = 18 => 11
N = 19 => 117
N = 20 => 11
N = 21 => 117
N = 22 => 166
N = 23 => Mismatched Braces
N = 24 => 206
N = 25 => 206
N = 26 => 206
N = 27 => 147
N = 28 => 147
N = 29 => 158
N = 30 => 148
N = 31 => 188
N = 32 => 51
N = 33 => 17
N = 34 => 84
N = 35 => 84
N = 36 => 84
N = 37 => 158
N = 38 => 158
N = 39 => 94
N = 40 => 46
N = 41 => 94
N = 42 => 94
N = 43 => 94
N = 44 => 17
N = 45 => 196
N = 46 => Mismatched Braces
N = 47 => 149
N = 48 => No Termination
N = 49 => No Termination
N = 50 => Mismatched Braces
N = 51 => Mismatched Braces
N = 52 => 45
N = 53 => 77
N = 54 => 45
N = 55 => 77
N = 56 => 50
N = 57 => 209
N = 58 => 50
N = 59 => 251
N = 60 => 249
N = 61 => 99
N = 62 => 99
N = 63 => 117
N = 64 => 89
N = 65 => 207
N = 66 => 89
N = 67 => 115
N = 68 => 115
N = 69 => 115
N = 70 => 95
N = 71 => Mismatched Braces
N = 72 => Mismatched Braces
N = 73 => 104
N = 74 => Mismatched Braces
N = 75 => No Termination
N = 76 => No Termination
N = 77 => No Termination
N = 78 => No Termination
N = 79 => Left Overflow
N = 80 => 3
N = 81 => 2
N = 82 => No Termination
N = 83 => Mismatched Braces
N = 84 => No Termination
N = 85 => 133
N = 86 => 133
N = 87 => 0
N = 88 => Mismatched Braces
N = 89 => 158
N = 90 => 0
N = 91 => 4
N = 92 => Mismatched Braces
N = 93 => 0
N = 94 => 158
N = 95 => Mismatched Braces
N = 96 => 0
N = 97 => 157
N = 98 => 159
N = 99 => None

Ci sono un totale di 37 uscite uniche, che sono (in ordine numerico):

0, 1, 2, 3, 4, 11, 13, 17, 45, 46, 50, 51, 57, 59, 77, 84, 89, 94, 95, 99,
100, 104, 115, 117, 129, 133, 147, 148, 149, 157, 158, 159, 166, 187, 188, 
196, 206, 207, 209, 211, 249, 251, 255

Sono sicuro al 90% al 100% che questa soluzione non è ottimale , ma dimostrando che potrebbe essere estremamente difficile . Ci sono alcune cose che sono chiare. Non avere .simboli fino all'ultimo carattere sembra essere la strada da percorrere e le parentesi quadre ( []) sembrano piuttosto inutili . Ho pensato un po 'qui, che vorrei delineare:

Sia Lla lunghezza del codice in byte (nella sfida, 100) e nsia il numero di output univoci dei sottoprogrammi.

Per L=3, ci sono diverse soluzioni ottimali del modulo +-., dove n=2(in questo caso, le uscite sono 1 e 255 per +.e -., rispettivamente.) Questo mette il rapporto migliore per L = 3a n/L = 66.67%. Si noti che questo rapporto non può essere battuto per almeno L<10.

Perché L=10, le soluzioni sono abbastanza semplici da rinforzare. Ecco tutte le migliori soluzioni, a n = 6:

++>-->+<+. => 6
++>-->+<+. => 6
+++>->+<+. => 6
--->->+<+. => 6
++>---><+. => 6
+++>--><+. => 6
-->++>-<-. => 6
+++>+>-<-. => 6
--->+>-<-. => 6
-->+++><-. => 6
--->++><-. => 6

Che produce un rapporto di punteggio di n/L = 60%.

Come L->infinity, è chiaro che il rapporto deve avvicinarsi a 0, poiché ci sono solo 255 possibili uscite per un potenzialmente infinito L.

Tuttavia, il rapporto NON diminuisce in modo uniforme. Non è possibile costruire una soluzione per n=6, L=9, quindi il miglior rapporto possibile L=9è 5/9 = 55.56% < 60%.

Questo fa sorgere la domanda: quanto velocemente e in quale materia scende il rapporto? Perché L = 100, e in 10^9 checks/second, occorrerebbero diversi ordini di grandezza più lunghi della vita dell'universo per ottenere una soluzione ottimale. Esiste un modo elegante per farlo? Dubito fortemente che sia 37%per L = 100.

Il rapporto effettivamente aumenta, fino a L=100. Visualizza altre risposte per confermare.

Mi piacerebbe sentire le tue valutazioni di cui sopra. Dopotutto, potrei essere stato atrocemente sbagliato.