Quali consigli generali hai per giocare a golf in linguaggi di programmazione bidimensionali? Sto cercando suggerimenti che possono essere applicati a problemi di code-golf e sono specifici per i linguaggi di programmazione 2D, ma non specifici per nessuna lingua (risposte come "rimuovi commenti" e "usa l' Moperazione" non sono risposte).

Si prega di inviare un suggerimento per risposta.

Evitare spazi vuoti orizzontali

Spesso, il codice lascia grandi spazi vuoti di spazi bianchi sul lato sinistro del programma, in questo modo.

abc
  d
  e

Ciò aggiunge 4 byte, quando ciò potrebbe essere evitato allineando a sinistra.

cde
b
a

Se è necessario utilizzare ampi spazi vuoti, provare a renderli verticali anziché orizzontali.

########
#      #
#      #
#      #

vs

####
#
#
#
#
#
#
####

Usa una dimensione quando possibile

In genere, i programmi più semplici possono essere scritti su una sola riga. Ad esempio, il classico programma cat potrebbe essere:

>iv
^o<

Ma si potrebbe abusare del comportamento di avvolgimento e rendere questo:

io

Oppure, in lingue senza tale comportamento di avvolgimento:

> ?oi<

(Supponendo ?che non compaia.) Nel caso di un linguaggio non avvolgente, un ciclo esplicito è spesso migliore.

Con comandi di salto

In linguaggi 2D con comandi di salto e salto condizionato, un programma potrebbe apparire così:

abc >de?v;
    ^hgf<

Questo potrebbe anche essere:

abc de?!;hgf04&

(se !è un trampolino ed &è saltare in posizione)

Anche i ritorni a capo sono byte

Meno 2D puoi farlo, meglio è. Un ritorno a capo è un altro no-op. Senza ignorare i suggerimenti solo da @ATaco e @ ASCII, prova a mantenere la dimensione Y il più piccola possibile.

Questo

###
####
########

è meglio di

###
###
###
##
#
#
#
#

SECCO (non ripetere te stesso)

Mentre astrarre con funzioni è di solito più lungo in Code Golf, può davvero aiutare per i linguaggi 2D. Prova a rielaborare il codice in modo che possa riutilizzare lo stesso frammento, inserendolo / uscendo con due diversi rami di esecuzione.

Percorsi interleave

Di solito in un linguaggio 2D c'è un IP che si muove secondo i comandi di direzione. Poiché gli spazi sono sprecati byte, è quasi sempre più efficiente riorganizzare il programma in modo che si avvicini il più spesso possibile a sinistra, risparmiando la necessità di spazi di imbottitura non necessari.

Usa gli specchi

A volte gli specchi possono essere utilizzati in due percorsi contemporaneamente (ogni percorso rimbalza su un lato dello specchio). Ciò potrebbe non essere d'aiuto, ma può consentire di riorganizzare il programma o, se si hanno molti cambiamenti di direzione, è possibile sostituirli con meno mirror.

Memorizza i modi di dire

Ecco alcuni "modi di dire" che fanno certe cose, a seconda della natura della lingua.

Codice pseudo-lineare

Se è mai richiesta la generazione di codice dinamico, può essere utile utilizzare il modello di codice pseudo-lineare:

v
\"line 1"
\"line 2"
.
.
\"line N"

Supponendo \ev significando ciò che fanno di solito.

Ciclo infinito

In quasi tutti i linguaggi 2D, ><è un ciclo infinito, infrangibile. Se, per qualche motivo, è necessario farlo, questo è il modo migliore, nonostante quanto bello possa sembrare:

>v
^<

In effetti, se rendi il tuo codice un 1-liner , potresti semplicemente usare ^o v, come tale:

i?vo;

Questo v invierà l'IP a se stesso, avvolgendosi. Potresti essere ancora in grado di utilizzare questo approccio in qualsiasi caso in cui un comando direzionale punta a una serie di operazioni (relative).

Quine framework

Di solito, le lingue con un framework string / quote possono avere un quine come questo:

<quote><generate "><output stack><terminate>

Per> <>, questo sarebbe simile a:

":1-r>o<#

Tranne questo si esce con un errore come terminazione. Probabilmente è il più breve > <> quine o, almeno, il più corto che ho trovato.