¿Qué consejos generales tiene para jugar al golf en lenguajes de programación bidimensionales? Estoy buscando consejos que puedan aplicarse a problemas de código de golf y que sean específicos de los lenguajes de programación 2D, pero no específicos de ningún idioma (las respuestas como "eliminar comentarios" y "usar la Moperación" no son respuestas).

Por favor, publique un consejo por respuesta.

Evitar espacios horizontales

A menudo, el código dejará grandes espacios en blanco en el lado izquierdo del programa, así.

abc
  d
  e

Esto agrega 4 bytes, cuando esto podría evitarse alineando a la izquierda.

cde
b
a

Si necesita usar espacios grandes de espacios en blanco, intente hacerlos verticales, en lugar de horizontales.

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

vs

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

Use una dimensión cuando sea posible

Por lo general, los programas más simples se pueden escribir en una sola línea. Por ejemplo, el programa clásico del gato podría ser:

>iv
^o<

Pero uno podría abusar del comportamiento de envoltura y hacer esto:

io

O, en idiomas sin ese comportamiento de ajuste:

> ?oi<

(Suponiendo ?que no aparece). En el caso de un lenguaje sin envoltura, un bucle explícito es a menudo mejor.

Con comandos de salto

En lenguajes 2D con comandos de salto y salto condicional, un programa podría verse así:

abc >de?v;
    ^hgf<

Esto también podría ser:

abc de?!;hgf04&

(si !es un trampolín y &salta a la posición)

Las devoluciones de carro también son bytes

Cuanto menos 2D puedas hacer, mejor. Un retorno de carro es otro no-op. Sin ignorar los consejos de @ATaco y @ ASCII solamente, intente mantener la dimensión Y lo más pequeña posible.

Esta

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

es mejor que

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

SECO (no te repitas)

Si bien la abstracción con funciones suele ser más larga en Code Golf, realmente puede ayudar para los lenguajes 2D. Intente volver a trabajar su código para que pueda reutilizar el mismo fragmento, ingresándolo / saliendo con dos ramas diferentes de ejecución.

Caminos intercalados

Por lo general, en un lenguaje 2D hay una IP que se mueve según los comandos de dirección. Dado que los espacios son bytes desperdiciados, casi siempre es más eficiente reorganizar el programa para que se acerque a la izquierda con la mayor frecuencia posible, lo que ahorra la necesidad de espacios de relleno innecesarios.

Usa espejos

Los espejos a veces se pueden usar en dos rutas al mismo tiempo (cada ruta rebota en un lado del espejo). Puede parecer que esto no ayuda, pero puede permitirle reorganizar su programa, o si tiene mucho si los cambios de dirección pueden reemplazarse con menos espejos.

Memoriza modismos

Aquí hay algunos "modismos" que hacen ciertas cosas, dependiendo de la naturaleza del idioma.

Código pseudo-lineal

Si alguna vez se requiere la generación dinámica de código, puede ser útil usar el modelo de código pseudo-lineal:

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

Asumiendo \y vsignificando lo que suelen hacer.

Bucle infinito

En casi todos los lenguajes 2D, ><es un bucle infinito e irrompible. Si, por alguna razón, necesita hacer esto, esta es la mejor manera, a pesar de lo agradable que pueda parecer:

>v
^<

De hecho, si convierte su código en un trazador de líneas , puede usar ^o v, como tal:

i?vo;

Esto venviará la IP a sí mismo, envolviendo. Es posible que aún pueda utilizar este enfoque en cualquier caso en el que un comando direccional apunte a una serie de operaciones no relativas (relativas).

Marco Quine

Por lo general, los idiomas con un marco de cadena / cita pueden tener una frase como esta:

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

Para> <>, esto se vería así:

":1-r>o<#

Excepto que este sale con un error como terminación. Es probablemente la quine más corta > <> o, al menos, la más corta que he encontrado.