Dicas para jogar golfe em Befunge

Que dicas gerais você tem para jogar golfe em Befunge? Estou procurando idéias que possam ser aplicadas aos problemas de código de golfe em geral que sejam pelo menos um pouco específicos para o Befunge (por exemplo, "remover comentários" não é uma resposta). Poste uma dica por resposta.

Ao usar um loop de várias linhas, tente usar o máximo possível:

>1234....v
^        <

vs

>1234v
^....<

Precisa soltar um valor após uma condicional (por exemplo, porque o outro caminho depende do valor, mas este não)? Em vez de usar >$or $<, adote o fato de que você conhece o valor verdadeiro da variável e, em _vez disso, use para alterar a direção e a pilha pop.

Exemplo

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

é transformado em

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

Não esqueça que 0está sempre na pilha. Por exemplo, isso significa que, com uma pilha vazia, gé equivalente a 00ge pé equivalente a 000p.

Se você precisar enviar um número maior que 15, use 'para buscar o valor ASCII do próximo caractere:

'*

pressionar 42 em vez de:

4a*2+

Em vez de usar |, exigindo outra linha (geralmente com muitos espaços extras), tente usar j. Por exemplo:

01-`j@more code here

pararia se o número no topo da pilha fosse negativo e continuaria em frente caso contrário. Se você precisar de vários caracteres, use n*jonde nestá o número de caracteres necessários quando o valor passado jé 0. Exemplo:

01-`4*j01-*more code

o que negaria um número negativo.

No Befunge-93, se a primeira coisa que você está empurrando para a pilha é uma seqüência de caracteres, muitas vezes você pode deixar cair a citação de abertura. Por exemplo, isto:

"!iH",,,@

poderia ser simplificado para isso:

!iH",,,@

Experimente online!

O que está acontecendo é que o intérprete primeiro tenta executar os caracteres na sequência não citada. O !executa um não inofensivo , e as instruções ie Hnão são válidas, por isso são ignoradas (embora em algumas implementações você possa receber um aviso).

Quando o "é encontrado, é considerado o início da sequência, mas como não há uma citação de fechamento, ele percorre todo o campo de jogo até que "seja encontrado uma segunda vez. O que acaba sendo empurrado para a pilha é o seguinte:

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

Já que nos preocupamos apenas com os últimos personagens, nada disso importa. Então, após a citação, finalmente executamos os três ,comandos, escrevendo a mensagem e o @comando que sai.

Observe que isso normalmente não funciona no Befunge-98, pois uma instrução não reconhecida fará com que o intérprete reflita em vez de ignorá-lo.

No Befunge-93, muitas vezes pode ser vantajoso achatar um loop em uma única linha, com a seção de código do loop sendo executada em ambas as direções.

Por exemplo, considere o código abaixo, que gera a letra aoito vezes:

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

Isso pode ser nivelado em uma única linha, intercalando a sequência do loop com as instruções da ponte ( #):

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

Experimente online!

Se você estiver apenas olhando para os caracteres que não são de espaço em branco, poderá ter a impressão de que isso é mais longo que o original. Porém, depois de levar em conta o avanço de linha e o preenchimento adicional necessário na versão de duas linhas, você acaba economizando quatro bytes.

Nesse caso específico, o código pode ser compactado ainda mais observando que essa sequência :#:pode ser simplesmente substituída por :.

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

Experimente online!

De fato, sempre que você repetir a mesma instrução em ambos os lados de um #comando, você pode simplificá-la para apenas uma instrução; portanto, isso é algo que você sempre deve procurar ao nivelar um loop.

Para entender como isso funciona, pode ajudar a escrever a sequência do loop duas vezes, uma vez com todos os caracteres após a #remoção (ou seja, o que acontece ao executar da esquerda para a direita) e uma vez com os caracteres que precedem a #remoção (ou seja, executando da direita para a esquerda )

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

Agora você pode ver claramente como isso corresponde à versão original do código em duas linhas.

Saída pelo código de saída, onde este é um formulário de saída permitido. Se o desafio solicitar que você imprima um número, você pode salvar um byte encerrando o programa em qvez de.@

No Befunge-93, o comando de entrada de caracteres ( ~) geralmente pode ser usado como um atalho para -1, pois esse é o valor que ele retorna no EOF.

Como exemplo, o código abaixo produzirá -1:

~.@

Experimente online!

Isso não é recomendado no código de produção, pois quando executado em um ambiente interativo, o programa pausa e espera pela entrada do usuário. E, obviamente, se o usuário inserisse algo, o resultado não seria mais -1.

Dito isso, a regra no PPCG é que um programa pode assumir um fluxo de entrada vazio , e é assim que ele normalmente seria executado no TIO .

Observe também que você não está necessariamente impedido de usar esse truque apenas porque seu programa precisa ler algo do fluxo de entrada. Você só precisa certificar-se de processar suas entradas antecipadamente, após o qual todos os usos futuros de ~devem retornar -1.

Use a direção do IP ao lidar com _ou |, em vez de usar um caractere extra para !.

Exemplo real ( deste post ):

#v~
,>:!#@_

Pode ser alterado para

#v~
:<,_@#

Não esqueça que 0knão executa a próxima instrução. Isso significa que, em vez de fazer:

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

Você pode salvar um personagem fazendo

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

Não se esqueça do koperador. Em vez de "!dlroW olleH",,,,,,,,,,,,@, faça "!dlroW olleH"bk,@. Note-se que kfaz a operação na célula que está no modo 9k,teria de impressão não 9 vezes, mas 10; 9 vezes com o ke uma vez com ,.

Ao empurrar pequenos números para a pilha, você provavelmente pode descobrir com facilidade o suficiente 45*para pegar 20e 67*pegar 42. No entanto, quando se trata de números maiores, você realmente precisa de um programa que possa calcular a representação mais eficiente para você.

A opção mais fácil para isso é a interface online de Mike Schwörer para o BefunRep . Você simplesmente digita um número e ele gera uma representação equivalente do Befunge. Nem sempre é o ideal, mas é próximo o suficiente e é quase certo que seja melhor do que qualquer coisa que você possa criar manualmente.

O sistema online é limitado a números no intervalo de 0 a 16777215; portanto, se você precisar de algo maior que isso, baixe o utilitário BefunRep independente e execute os cálculos você mesmo.

Se você estiver programando no Befunge-98, outra opção a considerar é o Fungify . Em geral, não é tão ideal quanto o BefunRep, mas para alguns dos números mais baixos, onde dígitos hexadecimais e caracteres de aspas simples são mais eficazes, às vezes pode produzir melhores resultados.