Comme j'ai vu plus de <> soumissions flottant récemment, j'ai pensé que ce serait une bonne idée d'avoir une page de conseils.

Veuillez vous en tenir à une astuce par article, sauf s'ils sont étroitement liés.

Interprète officiel de Python

Interprète en ligne (quelques bugs présents, mais bon dans la plupart des cas)

Vérification contre 0

L'utilisation ?!au lieu de 0=?sauvegarde généralement un octet.

Cependant, juste une norme ?peut parfois être meilleure si vous pouvez vous permettre un peu de restructuration

?!vA
  B

contre

?vB
 A

Vérification de l'EOF

Lorsque EOF est atteint,> <> pousse un -1 sur la pile, ce qui peut être vérifié de deux manières:

:0(?
:1+?

Aux fins de vérification de l'EOF, ces deux sont des négations, donc celle qui est la plus avantageuse dépend de la structure de votre programme.

Sautez pour contourner le démarrage de nouvelles lignes

Commencer une nouvelle ligne signifie parfois perdre beaucoup d'espace blanc de tête sur la ligne suivante. Dans une telle situation, le saut peut être utile.

Par exemple,

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

peut être fait pour tenir sur une seule ligne comme ceci:

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

Pour un exemple pratique, voici le programme Hello World sur une seule ligne:

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

Utiliser le module pour simplifier la saisie

Cela pourrait être trop simple d'une astuce, donc si c'est le cas, je vais juste le remplacer ou le supprimer.

Supposons que vous souhaitiez saisir deux caractères, "a" et "b" et renvoyer respectivement 1 et 2. Vous utiliseriez probablement des conditions pour cela, car cela a le plus de sens, et j'utiliserai une forme plus condensée pour cet exemple spécifique.

i:"a")+1+n

Cela vérifie si l'entrée est supérieure à "a" et ajoute 1. Puisque "a" renverra 0 et "b" 1, cela donnera 1 et 2. Cela fait assez bien le travail, mais dans le cas de notre entrées, nous pourrions aller encore plus loin.

i:3%n

Dans le module 3, 97, qui est l'équivalent numérique de "a", devient 1, et 98, qui est "b", devient 2. Pour deux nombres différents, il est garanti un mod qui donne des résultats uniques pour les deux. Pour plus de deux, il existe un mod qui donne des résultats uniques, mais je n'ai pas la prouesse mathématique de trouver le plus petit de manière simple (par exemple, si vous avez l'ensemble {100,101,102,103}, le mod 104 donnerait des résultats uniques pour chaque valeur en elle mais pas d'une manière très utile). Cependant, dans la plupart des cas, l'entrée étant limitée à quelques caractères alphabétiques, vous pouvez souvent trouver un mod qui fonctionne.

Pour trouver le plus petit module qui donne des résultats uniques pour deux nombres, a et b, procédez comme suit. Prenez la valeur absolue de la différence de a et b ( |a - b|) et trouvez le plus petit nombre, n, qui ne le divise pas. par exemple pour 97 et 98, |98 - 97| = 1et donc 2 serait le plus petit mod (mais pour notre programme de test, cela donne 1 pour 97 et 0 pour 98, donc le mod 3 est meilleur).

Utiliser des sauts comme conditionnel

Parfois, vous finirez par écrire des programmes dans> <> qui vous obligeront à faire différentes choses lors de la réception de différentes entrées. Habituellement, vous utiliseriez des conditionnelles ( ?) et des changeurs de direction pour analyser cela. Dans certains cas, cela fonctionne bien (surtout quand il y a moins de types d'entrée à gérer), mais parfois vous vous retrouvez avec quelque chose qui ressemble à ceci. (Ignorez le fait que ce code peut être réduit en utilisant d'autres astuces, c'est juste pour la démonstration)

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

Bien que ce soit bien, il a des espaces (que je n'aime jamais personnellement) et il a beaucoup de répétitions ( =?vet .00n). Au lieu de cela, vous pouvez utiliser un saut et différentes lignes comme conditions. Voici un exemple:

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

Cela réduit de 10 octets. Voici ce qui se passe:

i: Nous dupliquons l'entrée une fois afin de pouvoir l'évaluer deux fois

"a")$"b")+Cela pourrait être son propre type de conseil, mais ce que je fais ici, c'est de vérifier si l'entrée est supérieure au caractère "a", puis si elle est supérieure au caractère "b" et d'ajouter le résultat. Pour "a", cela donnera 0, pour "b", 1 et pour "c", 2.

1+0$.C'est là que la magie opère; nous prenons le résultat de cette simplification précédente et ajoutons 1 (donnant 1 pour "a", 2 pour "b", 3 pour "c"), puis poussons 0 et permutons les valeurs. Lorsque nous atteindrons le saut, cela se déplacera sur la ligne correspondant à la valeur que nous avons assignée à ces caractères (par exemple la ligne 1 pour "a"). NB La ligne 0 est le haut du programme.

Écriture de code pouvant s'exécuter de deux manières

Les trampolines ( !) sont très pratiques lorsque vous souhaitez que votre code soit exécuté vers l'avant et vers l'arrière (ou vers le haut et vers le bas). Ces scénarios sont quelque peu improbables, mais pour le palindrome ou des défis similaires, cette astuce pourrait être utile.

Voici un exemple: je veux exécuter du code une fois, puis parcourir la pile en rejetant les valeurs jusqu'à ce que j'atteigne 0, puis descendre. Le pointeur entre dans cette boucle depuis le >. Vous pouvez utiliser un saut pour y parvenir, par exemple

?!v80.>ao (disons que je veux d'abord imprimer une nouvelle ligne)

mais si le code que nous voulons exécuter une fois (le code après le >) fait que la ligne dépasse 16 caractères, nous ne pouvons plus utiliser le saut en trois caractères. Cependant, c'est un exemple où il est trivial de courir en avant et en arrière ...

?!v!?<>ao>

En avançant, nous imprimons un retour à la ligne et puis frappons ?!vqui rejette la valeur si ce n'est pas 0, puis à cause du trampoline nous sautons le suivant ?et revenons en arrière. La même chose se produit et la boucle continue jusqu'à ce que nous atteignions un 0.

C'est un exemple étrangement spécifique, mais il existe certaines (peut-être pas beaucoup) d'applications.