Como he estado viendo más > <> envíos flotando últimamente, pensé que sería una buena idea tener una página de consejos.

Apéguese a un consejo por publicación, a menos que estén estrechamente relacionados.

Intérprete oficial de Python

Intérprete en línea (algunos errores están presentes, pero son buenos para la mayoría de los casos)

Comprobación contra 0

Usar en ?!lugar de 0=?generalmente guarda un byte.

Sin embargo, solo un estándar a ?veces puede ser mejor si puede permitirse un poco de reestructuración

?!vA
  B

versus

?vB
 A

Comprobación de EOF

Cuando se alcanza EOF,> <> empuja un -1 en la pila, que puede verificarse de dos maneras:

:0(?
:1+?

A los efectos de verificar EOF, estos dos son negaciones, por lo que cuál es más beneficioso depende de la estructura de su programa.

Salte para evitar nuevas líneas

Comenzar una nueva línea a veces significa desperdiciar mucho espacio en blanco en la siguiente línea. En tal situación, saltar puede ser útil.

Por ejemplo,

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

se puede hacer que se ajuste a una línea de esta manera:

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

Para un ejemplo práctico, aquí está el programa Hello World en una línea:

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

Usando el módulo para simplificar la entrada

Esto puede ser un consejo demasiado simple, así que si lo es, lo reemplazaré o lo eliminaré.

Digamos que desea ingresar dos caracteres, "a" y "b" y devolver 1 y 2 para cada uno, respectivamente. Probablemente usarías condicionales para esto, ya que tiene más sentido, y usaré una forma más condensada para este ejemplo específico.

i:"a")+1+n

Esto verifica si la entrada es mayor que "a" y agrega 1. Como "a" devolverá 0 y "b" 1, esto dará 1 y 2. Esto hace el trabajo bastante bien, pero en el caso de nuestro entradas, podríamos ir aún más lejos.

i:3%n

En el mod 3, 97, que es el equivalente numérico de "a", se convierte en 1, y 98, que es "b", se convierte en 2. Para dos números diferentes, se garantiza un mod que proporciona resultados únicos para ambos. Para más de dos, hay un mod que da resultados únicos, pero no tengo la habilidad matemática para encontrar el más pequeño de una manera simple (por ejemplo, si tiene el conjunto {100,101,102,103}, el mod 104 daría resultados únicos para cada valor en él, pero no de una manera muy útil). Sin embargo, en la mayoría de los casos, con la entrada restringida a un par de caracteres alfabéticos, a menudo puede encontrar un mod que funcione.

Para encontrar el módulo más pequeño que produce resultados únicos para dos números, a, y, b, haga lo siguiente. Tome el valor absoluto de la diferencia de a y b ( |a - b|) y encuentre el número más pequeño, n, que no lo divide. por ejemplo, para 97 y 98, |98 - 97| = 1y entonces 2 sería el mod más pequeño (pero para nuestro programa de prueba, esto da 1 para 97 y 0 para 98, por lo que el mod 3 es mejor).

Usar saltos como condicional

Algunas veces terminarás escribiendo programas en> <> que requieren que hagas cosas diferentes al recibir diferentes entradas. Por lo general, usarías condicionales ( ?) y cambiadores de dirección para analizar esto. En algunos casos, eso funciona bien (especialmente cuando hay menos tipos de entrada para manejar), pero a veces terminas con algo así. (Ignore el hecho de que este código puede reducirse usando otros trucos, es solo para demostración)

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

Si bien esto está bien, tiene algo de espacio en blanco (que personalmente nunca me gusta ver) y tiene mucha repetición ( =?vy .00n). En lugar de eso, podrías usar un salto y diferentes líneas como condicionales. Aquí hay un ejemplo:

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

Esto ahorra 10 bytes. Esto es lo que está sucediendo:

i: Duplicamos la entrada una vez para poder evaluarla dos veces

"a")$"b")+Este podría ser su propio tipo de consejo, pero lo que estoy haciendo aquí es verificar si la entrada es mayor que el carácter "a" y luego si es mayor que el carácter "b" y agregar el resultado. Para "a", esto producirá 0, para "b", 1 y para "c", 2.

1+0$.Aquí es donde sucede la magia; tomamos el resultado de esta simplificación previa y agregamos 1 (dando 1 para "a", 2 para "b", 3 para "c"), luego presionamos 0 e intercambiamos los valores. Cuando alcanzamos el salto, se moverá a la línea correspondiente al valor que hemos asignado a esos caracteres (por ejemplo, la línea 1 para "a"). NB La línea 0 es la parte superior del programa.

Escribir código que puede ejecutarse de dos maneras

Los trampolines ( !) son muy útiles cuando desea que su código se ejecute hacia adelante y hacia atrás (o hacia arriba y hacia abajo). Estos escenarios son algo improbables, pero para el palíndromo o desafíos similares, este consejo podría ser útil.

Aquí hay un ejemplo: quiero ejecutar algún código una vez, luego recorrer los valores de descarte de la pila hasta llegar a 0 y luego bajar. El puntero entra en este bucle desde >. Podrías usar un salto para lograr esto, por ejemplo

?!v80.>ao (digamos que quiero imprimir una nueva línea primero)

pero si el código que queremos ejecutar una vez (el código más allá del >) hace que la línea tenga más de 16 caracteres, ya no podemos usar el salto en tres caracteres. Sin embargo, este es un ejemplo en el que es trivial correr hacia adelante y hacia atrás ...

?!v!?<>ao>

Yendo hacia adelante, imprimimos una nueva línea y luego presionamos ?!vque descarta el valor si no es 0, luego, debido al trampolín, saltamos el siguiente ?y retrocedemos. Lo mismo sucede y el ciclo continúa hasta que llegamos a 0.

Este es un ejemplo extrañamente específico, pero hay algunas (quizás no muchas) aplicaciones.