Que dicas gerais você tem para jogar golfe em Forth (e seus clones)? Estou procurando idéias que possam ser aplicadas para codificar problemas de golfe em geral que sejam pelo menos um pouco específicos para a Forth (por exemplo, "remover comentários" não é uma resposta).

Evite loops explícitos a todo custo

Em seguida, há duas construções de loop, x y do... loope menos conhecidas [begin]... [until] x yonde xe ysão valores para limite e índice, ou condições a serem observados, respectivamente.

Estes são muito lentos, muito prolixo (haha) e, em geral, bastante inchados, portanto, use-os apenas se necessário.

Em vez disso, como uma linguagem funcional adequada (que Forth é, na verdade), deve-se preferir a recursividade ao invés de loops explícitos, porque ela tende a ser mais curta e faz um melhor uso da linguagem.

Deixe o lixo

Os programas não precisam ser seguros para a pilha.

Em vez disso, eles podem deixar lixo extra na pilha se você economizar bytes. Em quarto lugar, o "valor de retorno" está deixando algo no topo da pilha. Provavelmente, não importa que lixo você tenha abaixo dele na pilha, a menos que você esteja usando recursão e profundidade da pilha.

Em seguida, há muitas palavras interessantes, muitas das quais são úteis para criar os tipos de algoritmos encontrados no PPCG.

Um exemplo ruim, mas ilustrativo, são as palavras para increment ( 1+) e decrement ( 1-). Eles economizam um byte durante a gravação 1 +para incrementar a parte superior da pilha.

Além disso, aqui está uma lista útil de muitas (provavelmente nem todas) palavras encontradas em distribuições modernas como gforth.

Assista a pilha

Ao escrever seu código, preste atenção ao que acontece na pilha em cada comando. Eu costumo desenhar como eu vou, assim:

6       6
7       7 6
* DUP   42 42

Como você vai como este, você pode achar que é mais fácil de reconhecer quando você pode fazer uso de operações de pilha como ROT, -ROT, 2DUP, 2OVER, etc ...

Tente usar várias palavras de célula dupla

Isso inclui palavras aritméticas de célula dupla , bit a bit , comparação de números e manipulação de pilha . Literais inteiros de célula dupla também contam.

• Anexar um período em um literal inteiro (por exemplo 1.) fornece um literal de célula dupla. Para números pequenos, isso significa pressionar um zero extra ao custo de apenas um byte.
• m+= 0 d+~ = under+(não exatamente, pois pode ocorrer um estouro).
• d2*e d2/pode ser usado para extrair / pressionar um bit de uma palavra.
• a b c d d= = a c = b d = and
• a b c d d<> = a c <> b d <> or
• Palavras que copiam dois números de uma vez, por exemplo 2dup, 2over, 2tucktem uma boa chance de conquistar variáveis locais.

(específico da gforth) Utilize a pilha de ponto flutuante separada

gforth tem uma pilha separada para números de ponto flutuante. Mesmo se você estiver lidando apenas com números inteiros, transferir algum trabalho e armazenamento para a pilha FP pode resultar em um código mais curto no geral, evitando a manipulação explícita da pilha ou usando operações específicas do FP não disponíveis na pilha principal. Retornar à pilha FP também é uma opção perfeitamente válida (exceto quando a tarefa é retornar um booleano).

• As operações relacionadas com a FP (manipulação aritmética, pilha) geralmente custam mais um byte de cada um (o fprefixo, como em f+, fdupetc). Os literais de números FP também custam mais um byte (postfix e, como em 1e), mas alguns números podem amarrar ou até salvar um byte (por exemplo, em 1e3vez de 1000).
• Algumas operações estão faltando na pilha FP, provavelmente a mais dolorosa 1+e 1-.
• As operações exclusivas da pilha FP incluem f**(potência), falog(potência de 10) fsqrte várias operações relacionadas a trigonometria, exp e log.
• Você pode mover números entre as pilhas principal e FP via s>f(simples para flutuar), f>s(flutuar para simples), d>f(dobrar para flutuar), f>d(flutuar para dobrar). Às vezes, as variações "duplas" podem ser usadas para produzir ou consumir um zero extra.