Como eu tenho visto mais > <> envios flutuando ultimamente, achei que seria uma boa ideia ter uma página de dicas.

Atenha-se a uma dica por postagem, a menos que estejam intimamente relacionadas.

Intérprete oficial do Python

Intérprete online (alguns bugs presentes, mas bons para a maioria dos casos)

Verificando contra 0

Usar em ?!vez de 0=?normalmente salva um byte.

No entanto, apenas um padrão ?às vezes pode ser melhor se você puder pagar um pouco de reestruturação

?!vA
  B

versus

?vB
 A

Verificando EOF

Quando EOF é atingido,> <> coloca -1 na pilha, que pode ser verificada de duas maneiras:

:0(?
:1+?

Para fins de verificação do EOF, essas duas são negações; portanto, qual delas é mais benéfica depende da estrutura do seu programa.

Ir para contornar o início de novas linhas

Iniciar uma nova linha às vezes significa desperdiçar muito espaço em branco na próxima linha. Em tal situação, pular pode ser útil.

Por exemplo,

[lots of code here]>[loop body]v
                   ^ ......... <

pode ser feito para caber em uma linha da seguinte maneira:

[lots of code here][loop body][jump]

Para um exemplo prático, aqui está o programa Hello World em uma linha:

"!dlroW ,olleH"l?!;oe0.

Usando o módulo para simplificar a entrada

Pode ser uma dica muito simples, então, se for, eu a substituirei ou a excluirei.

Digamos que você queira inserir dois caracteres, "a" e "b" e retornar 1 e 2 para cada um, respectivamente. Você provavelmente usaria condicionais para isso, uma vez que faz mais sentido, e usarei uma forma mais condensada para este exemplo específico.

i:"a")+1+n

Isso verifica se a entrada é maior que "a" e adiciona 1. Como "a" retornará 0 e "b" 1, isso fornecerá 1 e 2. Isso faz o trabalho muito bem, mas no caso do nosso insumos, poderíamos ir ainda mais longe.

i:3%n

No mod 3, 97, que é o equivalente numérico de "a", se torna 1 e 98, que é "b", se torna 2. Para dois números diferentes, é garantido um mod que fornece resultados únicos para ambos. Por mais de dois, existe um mod que fornece resultados únicos, mas não tenho a capacidade matemática de encontrar o menor de uma maneira simples (por exemplo, se você tiver o conjunto {100,101,102,103}, o mod 104 daria resultados exclusivos para cada valor, mas não de uma maneira muito útil). No entanto, na maioria dos casos, com a entrada sendo restrita a alguns caracteres alfabéticos, geralmente é possível encontrar um mod que funcione.

Para encontrar o menor módulo que produz resultados exclusivos para dois números, a e eb, faça o seguinte. Pegue o valor absoluto da diferença de aeb ( |a - b|) e encontre o menor número, n, que não o divide. por exemplo, para 97 e 98, |98 - 97| = 1e, portanto, 2 seria o menor mod (mas para o nosso programa de teste, isso fornece 1 para 97 e 0 para 98, portanto, o mod 3 é melhor).

Usando saltos como condicional

Algumas vezes você acaba escrevendo programas em> <> que exigem que você faça coisas diferentes ao receber entradas diferentes. Normalmente, você usaria condicionais ( ?) e trocadores de direção para analisar isso. Em alguns casos, isso funciona bem (especialmente quando há menos tipos de entrada para manipular), mas às vezes você acaba com algo parecido com isso. (Ignore o fato de que esse código pode ser reduzido usando outros truques, é apenas para demonstração)

i:"a"=?v:"b"=?v"c"=?v>
  .00n1< .00n2<.00n3<

Enquanto isso é bom, ele tem algum espaço em branco (que eu pessoalmente nunca gosto de ver) e tem muita repetição ( =?ve .00n). Em vez disso, você pode usar um salto e linhas diferentes como condicionais. Aqui está um exemplo:

i:"a")$"b")+1+0$.>
v1
v2
v3
<.00n

Isso remove 10 bytes. Aqui está o que está acontecendo:

i: Duplicamos a entrada uma vez para que possamos avaliá-la duas vezes

"a")$"b")+Esse pode ser o seu próprio tipo de dica, mas o que estou fazendo aqui é verificar se a entrada é maior que o caractere "a" e se é maior que o caractere "b" e adicionar o resultado. Para "a", isso produzirá 0, para "b", 1 e para "c", 2.

1+0$.É aqui que a mágica acontece; pegamos o resultado dessa simplificação anterior e adicionamos 1 (dando 1 para "a", 2 para "b", 3 para "c"), depois pressione 0 e troque os valores. Quando atingirmos o salto, isso será movido para a linha correspondente ao valor que atribuímos a esses caracteres (por exemplo, linha 1 para "a"). Nota: a linha 0 é a parte superior do programa.

Escrevendo código que pode ser executado de duas maneiras

Os trampolins ( !) são muito úteis quando você deseja que seu código seja executado para frente e para trás (ou para cima e para baixo). Esses cenários são um pouco improváveis, mas para palíndromo ou desafios semelhantes, essa dica pode ser útil.

Aqui está um exemplo: eu quero executar algum código uma vez, depois percorrer a pilha descartando valores até chegar a 0 e depois descer. O ponteiro entra nesse loop a partir do >. Você poderia usar um salto para fazer isso, por exemplo

?!v80.>ao (digamos que eu queira imprimir uma nova linha primeiro)

mas se o código que queremos executar uma vez (o código após o >) tiver mais de 16 caracteres na linha, não será mais possível usar o salto em três caracteres. No entanto, este é um exemplo em que é trivial correr para frente e para trás ...

?!v!?<>ao>

Avançando, imprimimos uma nova linha e, em seguida, pressionamos a ?!vtecla que descarta o valor se não for 0; depois, devido ao trampolim, pulamos a próxima ?e voltamos para trás. O mesmo acontece e o loop continua até atingirmos um 0.

Este é um exemplo estranhamente específico, mas existem alguns (talvez não muitos) aplicativos.