Que dicas gerais você tem para jogar golfe em linguagens de programação bidimensionais? Estou procurando dicas que possam ser aplicadas a problemas de código-golfe e sejam específicas para linguagens de programação 2D, mas não específicas para nenhuma linguagem (respostas como "remover comentários" e "usar a Moperação" não são respostas).

Poste uma dica por resposta.

Evite espaços horizontais

Freqüentemente, o código deixará grandes lacunas de espaço em branco no lado esquerdo do programa, assim.

abc
  d
  e

Isso adiciona 4 bytes, quando isso pode ser evitado pelo alinhamento à esquerda.

cde
b
a

Se você precisar usar grandes lacunas de espaço em branco, tente torná-las verticais, em vez de horizontais.

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

vs

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

Use uma dimensão quando possível

Normalmente, programas mais simples podem ser gravados em uma única linha. Por exemplo, o programa clássico para gatos pode ser:

>iv
^o<

Mas pode-se abusar do comportamento de quebra e fazer o seguinte:

io

Ou, em idiomas sem esse comportamento de agrupamento:

> ?oi<

(Supondo ?que não apareça.) No caso de uma linguagem sem quebra automática, um loop explícito geralmente é melhor.

Com comandos de salto

Em linguagens 2D com comandos de salto e salto condicional, um programa pode se parecer com o seguinte:

abc >de?v;
    ^hgf<

Também pode ser:

abc de?!;hgf04&

(se !for um trampolim e &pular para a posição)

Os retornos de carro também são bytes

Quanto menos 2D você conseguir, melhor. Um retorno de carro é outro não-op. Sem ignorar as dicas do @ATaco e apenas do @ ASCII, tente manter a dimensão Y o menor possível.

este

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

é melhor que

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

SECA (não se repita)

Embora a abstração de funções seja geralmente mais longa no Code Golf, ela pode realmente ajudar nas linguagens 2D. Tente refazer seu código para que ele possa reutilizar o mesmo trecho, inserindo / saindo com dois ramos diferentes de execução.

Intercalar caminhos

Geralmente, em uma linguagem 2D, há um IP que se move de acordo com os comandos de direção. Como os espaços são bytes desperdiçados, é quase sempre mais eficiente reorganizar o programa para que ele se aproxime à esquerda o mais rápido possível, economizando a necessidade de espaços de preenchimento desnecessários.

Use espelhos

Às vezes, os espelhos podem ser usados ​​em dois caminhos ao mesmo tempo (cada caminho é refletido em um lado do espelho). Isso pode não parecer útil, mas pode permitir que você reorganize seu programa ou, se houver muito, caso as mudanças de direção possam ser substituídas por menos espelhos.

Memorizar expressões idiomáticas

Aqui estão alguns "idiomas" que fazem certas coisas, dependendo da natureza do idioma.

Código pseudo-linear

Se alguma vez a geração de código dinâmico for necessária, pode ser útil usar o modelo de código pseudo-linear:

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

Supondo \e vfalando sério o que eles costumam fazer.

Loop infinito

Em quase todas as linguagens 2D, ><existe um loop infinito e inquebrável. Se, por algum motivo, você precisar fazer isso, esta é a melhor maneira, apesar de parecer bom:

>v
^<

De fato, se você transformar seu código em um liner , poderá usar ^ou v, como tal:

i?vo;

Isso venviará o IP para si mesmo, contornando. Você ainda poderá usar essa abordagem em qualquer instância em que um comando direcional aponte para uma série de no-ops (relativas).

Estrutura Quine

Normalmente, os idiomas com uma estrutura de string / quote podem ter uma solução como esta:

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

Para> <>, seria semelhante a:

":1-r>o<#

Exceto que este sai com um erro como encerramento. Provavelmente é a menor > <> quine , ou, pelo menos, a mais curta que eu encontrei.