Quels conseils généraux avez-vous pour jouer au golf dans TI-BASIC pour les calculatrices de la série TI-83/84 +? Je cherche des idées qui peuvent être appliquées aux problèmes de code-golf et qui sont également au moins quelque peu spécifiques à TI-BASIC (par exemple, "supprimer les commentaires" n'est pas une réponse).

Veuillez poster un pourboire par réponse.

Votre calculatrice est assez intelligente pour déduire la fin des lignes pour vous, et vous pouvez donc omettre pas mal de caractères.

:Disp "HELLO WORLD    //is the same as...
:Disp "HELLO WORLD"

For(les boucles ont une syntaxe comme celle-ci - For(variable, start, end, increment), mais vous pouvez omettre l'incrément et il utilisera 1:

:For(A,1,5     //is the same as...
:For(A,1,5,1)

et vous pouvez omettre les parenthèses de fin (à la fin des lignes) sur toute la ligne:

:Output(1,1,A
:int(A
:round(A
etc.

_{Testé sur ma calculatrice TI-84 Silver Edition}

_{Si vous pensez que c'est plus d'une idée (déduire des fins) alors je vais les séparer}

Utilisation Ans

Si vous n'utiliserez qu'une expression dans la ligne suivante, ne la stockez pas dans une variable! La variable Ans spéciale est un jeton d'un octet qui stocke la valeur de la dernière expression évaluée. Ainsi:

Xsin(A)->R
Disp R+tanh(R

peut être

Xsin(A)
Disp Ans+tanh(Ans

économiser deux octets.

Utiliser une table de recherche codée en nombres à virgule flottante

Un conseil légèrement avancé:

Les petites tables de recherche sont utiles pour le golf de code: c'est très souvent que nous avons besoin d'une fonction qui mappe, par exemple, 0 à 1, 1 à 2, 2 à 1 et tout le reste à 0. Cependant, les tableaux TI-BASIC ne sont pas adaptés à cet effet: pour une chose, ils sont basés sur une, et pour une autre, une valeur ne peut pas être extraite jusqu'à ce que le tableau soit stocké dans Ans ou une variable de liste.

Dans ma réponse ici , je stocke une petite table de recherche dans une constante magique en base 11. Énumérez simplement les valeurs que vous souhaitez utiliser,

{0,-1,5,-1,-1,2,9,-1,8,6}

convertir en une forme utile

{1,0,6,0,0,3,10,0,9,7}

écrivez dans votre base souhaitée (base 11)

.106003A097

et convertir en base 10

-1+int(11fPart(11^Ans.0954191904

L'approche du tableau le plus court est de 8 octets de plus!

{1,0,6,0,0,3,10,0,9,7}-1:Ans(X+1

TI-BASIC ne stocke que les flottants à 14 chiffres décimaux, vous pouvez donc stocker jusqu'à 44 bits mais seulement 14 chiffres décimaux.

Cette technique peut souvent être encore améliorée en utilisant la recherche par force brute pour trouver une constante magique plutôt que le codage base-N. Je suis toujours en train de jouer la réponse ci-dessus, mais le golfeur lengendaire TI-BASIC Weregoose a utilisé cette méthode pour générer les différences entre les nombres coprimes avec 30 (c'est-à-dire une liste répétitive de 6, 4, 2, 4, 2, 4, 6, 2) sur le wiki / forum TI-BASIC Développeur avec cet extrait:

2+2iPart(3fPart(576e^(fPart(I/8

La constante magique 576 a été trouvée en utilisant Mathematica, mais si vous ne possédez pas de copie, utilisez un script dans votre langue préférée.

Mettez les variables d'équation des expressions répétées.

EX:

Remainder(randInt(1,9),1
Remainder(randInt(1,9),5
Remainder(randInt(1,9),10

Peut être:

"randInt(1,9→u
Remainder(u,1
Remainder(u,5
Remainder(u,10

Remarque: il est difficile de trouver une bonne utilisation pour cela, mais cela ne signifie pas que vous devez oublier les variables d'équation: P

Source: http://tibasicdev.wikidot.com/selfmodify

-c4ooo d'Omnimaga

Ignorer l'initialisation inutile des variables

Le consensus actuel est de permettre à tout le code d'être exécuté sur un nouvel interpréteur. Nous pouvons en profiter: toutes les variables réelles non initialisées commencent 0dans TI-BASIC et Xmincommencent comme valeur éventuellement utile -10. Donc, si vous avez besoin de prendre un total cumulé dans un programme qui ne prend pas d'entrée d'Ans, ou si vous avez vraiment besoin d'un -10octet de moins, cette astuce peut vous aider.

Génération de listes plus petites

Si vous avez besoin d'une liste {1,2,...,N}, où N est, disons, 42, la façon évidente de la créer est

seq(X,X,1,42. 

Cependant, un octet plus petit que cela est un hack soigné utilisant la commande binomcdf((distribution binomiale cumulative).

cumSum(binomcdf(41,0

Cela ne fonctionne que lorsque N est une constante, car les économies proviennent du remplacement de N-1 par sa valeur dans le code.

Il existe deux cas qui permettent un code encore plus court.

Si vous avez déjà une liste L1de dimension N:

cumSum(1 or L1

Si vous ne vous souciez pas de la commande:

randIntNoRep(1,N     ;random permutation of numbers from 1 to N

Éliminer les instructions de fin pour les blocs If à la fin d'un programme

Enregistre deux octets: un pour la fin et un pour le saut de ligne. Il vous permet également d'utiliser le Disp implicite sur la dernière ligne, économisant souvent un octet supplémentaire.

[code]
If A>5
Then
Output(1,1,Ans²+Ans+A
Disp 3ln(A
End
//end of program

Peut être:

[code]
If A>5
Then
Output(1,1,Ans²+Ans+A
3ln(A
//end of program

Connaissez vos idiomes

Voici quelques extraits que j'utilise couramment dans le golf de code:

• Convertir en valeur de vérité (0/1):, not(not(Ansou Ans and 1. Lequel utiliser dépend des parenthèses nécessaires.
• Ajouter un à une valeur de vérité: int(e^(Ans. Enregistre une parenthèse ouverte sur 1+(Ans. Très utile, car TI-BASIC a des tableaux à base unique.
• Carte {0,1}à {1,-1}: cos(πAns. Enregistre un octet de plus 1-2Ans.

• Fonction de signe d'un nombre: tanh(ᴇ9Ans
• Arrondi vers l'infini positif: -int(-Ans
• Nombre de chiffres dans un entier positif: 1+int(log(Ans
• Numéro complexe à lister {Re,Im}:imag(Ans{i,1

• Convertir une chaîne en liste: seq(inString("...",sub(Ans,X,1)),X,1,length(Ans(où... est la chaîne de recherche)
• Coupez le premier élément d'une liste: ΔList(cumSum(Ans
• Coupez le dernier élément d'une liste: ΔList(cumSum(Ans)-Ans
• Vérifiez si tous les éléments de la liste L1 sont uniques:SortA(L1:min(ΔList(L1
• Recherchez le nombre X dans une liste (retourne la première occurrence): 1+sum(not(cumSum(Ans=X
• Mode d'une liste lorsqu'il existe un seul mode et que la liste comporte au plus 10 éléments: (moche, mais court): median(Ans,10^(seq(sum(Ans=Ans(X)),X,1,dim(Ans

Si vous vous retrouvez à utiliser

0→G ;or any other variable
;other lines of code

Ensuite, vous pouvez utiliser (pour enregistrer un octet):

DelVar G;other lines of code

En effet, lorsque vous supprimez une variable ( G), elle devient sa valeur par défaut, dans ce cas 0,. Ensuite, vous pouvez mettre une autre ligne après l' DelVarinstruction, sans nouvelle ligne . Soyez prudent lorsque vous mettez des instructions de contrôle cruciales directement après unDelVar instruction.

(Testé sur TI-84)

Quelle liste de variables utiliser?

Lorsque vous utilisez des listes, évitez les listes L₁par défaut à travers L₆en faveur des listes nommées avec des noms à une lettre: à ᶫAtravers ᶫZ(où ᶫest le petit L).

L'un ou l'autre coûte deux octets à référencer (bien L₁qu'il s'agisse d'un seul jeton, il s'agit d'un jeton de deux octets), mais lorsque vous stockez des valeurs dans une liste, vous pouvez supprimer le ᶫsymbole et enregistrer un octet:

{1,2,3,4,5→ᶫA

peut être

{1,2,3,4,5→A

La calculatrice vérifie le type de données de l'expression pour décider où le résultat est stocké.

De même, Input Aou Prompt Astockera dansᶫA si l'utilisateur entre une liste au lieu d'un nombre.

Plusieurs autres commandes peuvent être utilisées sans ᶫ, bien que la plupart d'entre elles soient rarement utilisées en golf. Par exemple, Matr►list(permet ᶫde supprimer le dans ses troisième, quatrième et supérieur arguments.

La règle générale est que, si la commande prend un nom de variable de liste et non une expression de liste , et s'il n'y a pas de syntaxe alternative qui pourrait y placer un autre type de variable, alors la commande peut fonctionner avec la ᶫgauche désactivée.

Cela ne fonctionne pas avec la modification d'une seule entrée d'une liste: 1→ᶫA(3ne peut pas être changé en 1→A(3.

Bien sûr, la meilleure variable de liste à utiliser est toujours Ans.

Connaissez vos coûts d'affectation variables

Si vous utilisez un Btemps d'expression de -byte N, devez-vous l'affecter à une variable?

Anscoûte des 1+Noctets à utiliser (un pour le saut de ligne et un pour chaque fois qu'il est utilisé, alors utilisez Ans quand (B-1)*(N-1)>2. Il ne peut y en avoir qu'un Anspar ligne, alors essayez toutes les valeurs Ansqui pourraient être utiles.

Les variables réelles (par exemple X) coûtent des 3+Noctets, alors utilisez-les quand (B-1)*(N-1)>4.

Répertoriez les 3+2Noctets de coût des variables , alors utilisez-les quand (B-2)*(N-1)>5.

Les variables d'équation sont les moins utiles: elles ont besoin d' 4+2Noctets. Utilisez-les quand (B-2)*(N-1)>6.

Min. bytes in an expression to save
 N \ var. | Ans | Real | List | Eqn
------------------------------------
 2           4     5      8      9
 3           3     4      5      6
 4           2     3      4      5

Lorsqu'une fonction évalue une liste, stockez-la dans une liste plutôt qu'une variable d'équation comme u; cela économise un octet.

Gardez à l'esprit que la présence ou l'absence de parenthèses proches peut souvent rendre les expressions de stockage avantageuses si elles sont réorganisées.

Maintenant, je vais me contredire et dire que l'on devrait écrire du code sur une ligne autant que possible. Pourquoi? Habituellement, lorsqu'il y a une longue expression répétée sur une ligne, elle peut être simplifiée.

int (rand sur randInt (

X + int (Yrand est égal ou inférieur à octets que randInt (X, Y car randInt est un jeton de 2 octets. Quelques avantages potentiels:

X + peut être omis lorsque la limite inférieure est 0, économisant deux octets

X + est nécessaire avant randInt (de toute façon dans certaines situations, par exemple aléatoire à partir d'une fonction pas à pas comme {2,5,8,11}

X + int (Yrand (N peut être utilisé comme randInt (X, Y, N pour générer une liste de N nombres aléatoires

Initialisation de l'écran graphique

Pour utiliser des fonctions comme Ligne (facilement avec les coordonnées en pixels, il est nécessaire d'initialiser les axes de l'écran graphique en pixels carrés et de supprimer les axes:

AxesOff
84→Xmin
72→Ymax
ZInteger

Serrer

min(U,max(L,N

Où N est le nombre ou l'algorithme et U et L sont les bornes supérieure et inférieure

Est N dans la liste

max(N={X,Y,Z

Plus Liste des mathématiques

L1*L2→L3

instead of

for(A,1,dim(L1
L1(A)*L2(A→L3(A
End

This also works for things like this:
not(L1
L1 and L2

Sortie

Disp et Text (peuvent tous les deux être chaînés, donc Disp A, B affichera A puis B sur des lignes séparées et Text (28,40, A, B affichera A à côté de B sur une ligne)

Technologie de la boucle de mouvement optimale

Beaucoup de ces optimisations font partie de la technologie utilisée pour déplacer un personnage autour de l'écran dans le moins d'octets

http://tibasicdev.wikidot.com/movement

Listes de tailles de jetons

http://tibasicdev.wikidot.com/tokens

Pour aider à la notation