Suggerimenti per il golf a Befunge

Quali consigli generali hai per giocare a golf in Befunge? Sto cercando idee che possano essere applicate ai problemi del codice golf in generale che siano almeno in qualche modo specifiche per Befunge (ad esempio "rimuovere i commenti" non è una risposta). Si prega di inviare un suggerimento per risposta.

Quando si utilizza un loop multilinea, provare a utilizzarne il più possibile:

>1234....v
^        <

vs

>1234v
^....<

Devi eliminare un valore dopo un condizionale (ad es. Perché l'altro percorso dipende dal valore, ma questo non lo fa)? Invece di usare >$o $<, sii avvantaggiato dal fatto che conosci il valore di verità della variabile e usi _invece sia per cambiare direzione che pop stack.

Esempio

'* : v           >$ .. @          Prints number in binary followed by the original
                                  decimal number.
     > :2%\2/ :!#^_ \.

viene trasformato in

'* : v           _  .. @          Since we know that the topmost value on the stack
                                  will be 0, we combine `>$` into `_`.
     > :2%\2/ :!#^_ \.

Non dimenticare che 0è sempre in pila. Ad esempio, ciò significa che, con uno stack vuoto, gè equivalente 00ged pè equivalente a 000p.

Se devi spingere un numero maggiore di 15, usa 'per recuperare il valore ASCII del carattere successivo:

'*

spingere 42 anziché:

4a*2+

Invece di usare |, richiedendo un'altra linea (spesso con molti spazi extra), prova ad usare j. Per esempio:

01-`j@more code here

si fermerebbe se il numero in cima alla pila fosse negativo e continuerebbe altrimenti. Se sono necessari più caratteri, utilizzare n*jdov'è nil numero di caratteri necessari quando il valore passato jè 0. Esempio:

01-`4*j01-*more code

che negherebbe un numero negativo.

In Befunge-93, se la prima cosa che stai spingendo in pila è una stringa, puoi spesso cavartela lasciando cadere la citazione di apertura. Ad esempio questo:

"!iH",,,@

potrebbe essere semplificato a questo:

!iH",,,@

Provalo online!

Quello che sta succedendo è che l'interprete tenta innanzitutto di eseguire i caratteri nella stringa non quotata. Le !esegue un innocuo non , e la ie Hnon sono istruzioni valide, quindi sono ignorati (anche se su alcune implementazioni è possibile ottenere un avvertimento).

Quando "viene rilevato, viene considerato l'inizio della stringa, ma poiché non è presente alcuna virgoletta di chiusura, si avvolge completamente attorno al campo di gioco fino a quando non "viene rilevato una seconda volta. Ciò che viene inserito nello stack è quindi questo:

,,,@  ···72 spaces···  !iH

Dal momento che ci preoccupiamo solo degli ultimi personaggi, nessuna di queste cose è importante. Quindi dopo la citazione, possiamo finalmente eseguire i tre ,comandi, scrivere il messaggio e il @comando che esce.

Si noti che questo in genere non funziona in Befunge-98, poiché un'istruzione non riconosciuta farà riflettere l'interprete invece di ignorarlo.

In Befunge-93, può spesso essere vantaggioso appiattire un loop in una singola riga, con la sezione loop del codice eseguita in entrambe le direzioni.

Ad esempio, considera il codice seguente, che emette la lettera aotto volte:

"a"9>1-:#v_@
    ^\,:\<

Questo può essere appiattito in un'unica riga intervallando la sequenza del loop con le istruzioni del bridge ( #):

"a"9>1#\-#,:#:>#\_@

Provalo online!

Se stai solo guardando i caratteri non bianchi, potresti avere l'impressione che questo sia più lungo dell'originale. Ma una volta che si tiene conto dell'alimentazione di linea e dell'imbottitura aggiuntiva richiesta nella versione a due righe, si finisce per salvare quattro byte.

In questo caso particolare, il codice può essere compresso ulteriormente notando che quella sequenza :#:può essere semplicemente sostituita con :.

"a"9>1#\-#,:>#\_@

Provalo online!

In effetti, ogni volta che si ripete la stessa istruzione su entrambi i lati di un #comando, è possibile semplificare questa in una sola istruzione, quindi è qualcosa che si dovrebbe sempre fare attenzione quando si appiattisce un ciclo.

Per capire come funziona, può essere utile scrivere due volte la sequenza di loop, una volta con tutti i caratteri che seguono il #rimosso (cioè cosa succede quando si esegue da sinistra a destra) e una volta con i caratteri che precedono il #rimosso (cioè eseguendo da destra a sinistra ).

"a"9>1#\-#,:>#\_@
    >1  -  :>  _      ; executing left to right
    >  \  ,:  \_      ; executing right to left

Ora puoi vedere chiaramente come questo corrisponde alla versione originale a due righe del codice.

Output per codice di uscita, dove si tratta di un modulo di output consentito. Se la sfida richiede di stampare un numero, è possibile salvare un byte chiudendo il programma con qinvece di.@

In Befunge-93, il comando di immissione caratteri ( ~) può spesso essere usato come scorciatoia per -1, poiché questo è il valore che restituisce su EOF.

Ad esempio, il codice seguente mostrerà -1:

~.@

Provalo online!

Questo non è raccomandato nel codice di produzione, poiché quando viene eseguito in un ambiente interattivo, il programma si interrompe e attende l'input dell'utente. E ovviamente se l'utente dovesse inserire qualcosa, il risultato non sarebbe più -1.

Detto questo, la regola su PPCG è che un programma può assumere un flusso di input vuoto , ed è così che verrebbe normalmente eseguito su TIO .

Si noti inoltre che non è necessariamente precluso l'utilizzo di questo trucco solo perché il programma deve leggere qualcosa dal flusso di input. Devi solo assicurarti di elaborare i tuoi input in anticipo, dopodiché tutti gli usi futuri di ~dovrebbero restituire -1.

Usa la direzione dell'IP quando hai a che fare con _o |, invece di usare un carattere in più per !.

Esempio reale (da questo post ):

#v~
,>:!#@_

Può essere cambiato in

#v~
:<,_@#

Non dimenticare che 0knon esegue l'istruzione successiva. Ciò significa che invece di fare:

;some boolean test;!jv;code if false;
       ;code if true;<

Puoi salvare un personaggio facendo

;some boolean test;kv;code if false;
      ;code if true;<

Non dimenticare l' koperatore. Invece di "!dlroW olleH",,,,,,,,,,,,@, fallo "!dlroW olleH"bk,@. Si noti che kfa l'operazione sulla cella che è in così 9k,sarebbe stampa non 9 volte, ma 10; 9 volte con il k, e una volta con ,.

Quando si spingono piccoli numeri in pila, probabilmente si può capire abbastanza facilmente che 45*ti porterà 20e 67*ti prenderà 42. Quando si tratta di numeri più grandi, tuttavia, è davvero necessario un programma in grado di calcolare la rappresentazione più efficiente per te.

L'opzione più semplice per questo è l' interfaccia online di Mike Schwörer per BefunRep . Digiti semplicemente un numero e ne uscirà una rappresentazione Befunge equivalente. Non è sempre il più ottimale, ma è abbastanza vicino, ed è quasi certo di essere migliore di qualsiasi cosa tu possa inventare a mano.

Il sistema online è limitato ai numeri nell'intervallo da 0 a 16777215, quindi se hai bisogno di qualcosa di più grande di quello, ti consigliamo di scaricare l' utilità BefunRep autonoma ed eseguire i calcoli da solo.

Se stai programmando in Befunge-98, un'altra opzione da considerare è Fungify . In generale non è quasi ottimale come BefunRep, ma per alcuni dei numeri più bassi, dove le cifre esadecimali e i caratteri a virgoletta singola sono più efficaci, a volte può produrre risultati migliori.