Quels conseils généraux avez-vous pour jouer au golf en DC ?

dc est un utilitaire de calculatrice pour UNIX / Linux qui est antérieur au langage C. Je souhaite savoir comment raccourcir mes programmes DC (calculs?). Je cherche des idées qui peuvent être appliquées au code-golf général qui sont au moins un peu spécifiques au DC (par exemple, supprimer des commentaires n'est pas une réponse utile)

Veuillez poster un pourboire par réponse.

Instructions if-then-else

Supposons que nous voulons vérifier la condition a==b(laisser aet bêtre stockés dans leurs registres respectivement nommés).

[         # Everything is wrapped in one big macro
  [         # An inner macro for our *then* part
              # <-- Stuff to execute if a==b here
  2Q          # Then quit the inner and outer macro
]sE       # `E' is for Execution register ;)
la lb =E  # if a==b, execute E
          # if E is executed, it will quit the whole macro, so the rest is never reached:
          # <-- Stuff to execute if a!=b here
]x        # End macro; Execute

Soit (foo)un espace réservé, dans le but de condenser:

[[(then)2Q]sE(condition)E(else)]x

Je suis sûr que c'est la déclaration la plus compacte possible (également présentée ici ).

Vous pouvez enregistrer une entrée avec d

En utilisant d, qui duplique le ToS (haut de la pile), vous pouvez déplacer l'entrée pour une utilisation ultérieure, tout en étant capable de l'utiliser.

Tableaux

Bien qu'ils soient un casse-tête pour les débutants, dcpropose des tableaux. Ils fonctionnent comme ceci:

value index :a    # store `value' in array linked to top of stack `a', with index `index'
      index ;a    # push a[index] on (main) stack

Comme d'habitude, le premier élément a l'index 0. Les tableaux peuvent être utiles lorsque vous travaillez avec des séquences, comme dans la séquence SUDSI , en particulier en combinaison avec des compteurs. Les tableaux peuvent réduire la quantité de mélange de nombres que vous devez faire (et le nombre de compteurs et de comparaisons) si vous souhaitez sélectionner un élément particulier sans détruire votre environnement. Par exemple, si vous souhaitez déplacer une pile de nombres dans un tableau, vous pouvez écrire une fonction récursive qui utilise z(profondeur de pile) ou z 1-comme index, stocke l'élément et vérifie s'il z == 0doit se terminer lui-même.

[z 1- :a z 0 !=F]dsFx    # or I could just write such a function for you :)

Soyez conscient des points suivants:

• Les tableaux sont associés aux instances sur des piles nommées. Si vous poussez une nouvelle valeur sur une pile à laquelle un tableau est associé, ce tableau sera également "repoussé" et un "nouveau" tableau prendra sa place. L'ancien tableau ne sera utilisable que lorsque la valeur correspondante sur la pile nommée sera également utilisable (c'est-à-dire au-dessus de sa pile). C'est un concept compliqué qui serait mieux expliqué avec une bonne animation, qui me dépasse.
• Vous pouvez stocker des éléments dans un tableau nommé sans réellement pousser une valeur dans le registre nommé correspondant. Toutefois, si vous procédez ainsi, vous ne pouvez pas accéder à la pile / au registre portant ce nom pour le reste de la session. dcva planter.
• Si vous supprimez une valeur d'une pile nommée, toutes les valeurs du tableau correspondant seront perdues - pas d'avertissement, pas de protection, rien. Je viens de partir (ce qui peut aussi être utile).

0 à la nième puissance au lieu des conditions / macros

Parfois, vous pourriez avoir besoin de quelque chose comme conditionnel c ternaire:

A == B ? C : D;

Une bonne façon de gérer cela est décrite dans la réponse de @ Joe . Mais nous pouvons faire mieux:

0AB-^E*C+

où E est D - C.

Cela teste l'égalité en élevant 0 à la puissance de la différence des deux valeurs. Il en résulte 1 si égal et 0 sinon. Le reste met simplement le 1 ou 0 à l'échelle des valeurs C ou D. Cela fonctionne car dcdonne 0 ⁰ = 1 et 0 ⁿ = 0 pour n! = 1.

Parfois, il est nécessaire de jeter un numéro de la pile. Une façon de le faire est de simplement l'insérer dans une variable inutilisée, c'est-à-dire st. Cependant, dans certaines situations, vous pouvez l'afficher à quelques autres endroits, par exemple la base d'entrée lorsque vous n'avez plus d'entrée numérique ou le spécificateur de précision si vous n'avez plus d'opérations à faire là où la précision ferait une différence. Dans le premier cas, utilisez i. Dans ce dernier cas, utilisez k.

Calcul de la longueur: Z, Xetz

Zouvre le ToS et pousse le nombre de chiffres (décimal) s'il s'agit d'un nombre ou le nombre de caractères s'il s'agit d'une chaîne. Cela peut être utile pour détecter la longueur d'un résultat (pour la mise en mémoire tampon de la sortie) ou calculer la longueur d'une chaîne. Notez que pour les nombres, Zpousse la longueur combinée de la partie entière et de la partie fraction.

Xouvre le ToS et pousse le nombre de chiffres dans la partie fraction du nombre. Si le ToS était une chaîne, 0est poussé.

Pour trouver le nombre de chiffres dans la partie entière du nombre, on peut utiliser dZrX-. Si vous n'avez pas changé la précision de la valeur par défaut k==0, l'utilisation 1/Zest plus courte, mais supposez que vous devez conserver une précision non nulle particulière après l'opération: Kr0k1/Zrkc'est plutôt une horreur.

zpousse le nombre d'éléments sur la pile. Une de mes commandes préférées, elle ne fait apparaître aucune valeur! Il pourrait être utilisé pour générer une séquence de nombres ou incrémenter un compteur. L'utilisation zdrépétée (par exemple, au début d'une macro) pourrait permettre de tester un calcul sur chaque nombre naturel ou entier dans l'ordre croissant.

Les chiffres Aà Fpeuvent être utilisés en remplacement des numéros 10 à 15. Cependant, ils doivent toujours être traités efficacement comme des chiffres de base 10 (en supposant que la base d'entrée est 10) lorsqu'ils sont à des endroits différents. En d'autres termes, avec une base d'entrée 10 FFne représenterait pas 255, cela représenterait (15 * 10) + 15ou 165.

En fait cela fonctionne pour tous les chiffres 0à Fdans une base d'entrée 2à 16. Donc, si la base d'entrée est 5, ce 26Eserait soit (2 * 5^2) + (6 * 5) + 1494.

Notez que ce comportement est en vigueur pour les sources GNU non modifiées. Cependant, comme le souligne @SophiaLechner, les distributions basées sur RedHat semblent utiliser bc-1.06-dc_ibase.patch qui modifie ce comportement afin que les chiffres> = ibase soient traités comme ibase - 1, quelle que soit leur valeur réelle. Notez que le TIO dc ne semble pas avoir bc-1.06-dc_ibase.patch (même si son Fedora 28 ¯_ (ツ) _ / ¯).

Lors de l'initialisation d'une macro de fonction (que nous utiliserons F) que vous souhaitez exécuter immédiatement, utilisez quelque chose comme dsFxplutôt que sFlFx. La même chose fonctionne pour les variables: dsaplutôt que sala.

Si vous devez faire d'autres choses entre le stockage et le chargement (par exemple, sa[other stuff]la), considérez toujours si ce qui précède est viable: si vous laissez une valeur sur la pile avant les autres opérations, sera-t-elle de retour en haut à la fin de ces opérations?

Je viens de découvrir cela par accident. Une autre façon de générer un zéro: _.

_est un signal à cc que les chiffres suivants sont un nombre négatif. Exemple:

_3 # pushes -3

Mais que se passe-t-il si nous ne le suivons pas avec un numéro?

_ # pushes 0...sometimes

Cela fonctionne lorsque le caractère non vide suivant le trait de soulignement n'est pas un chiffre. Si un chiffre le suit, même après une nouvelle ligne, il est interprété comme un signe négatif.

c4 5_6  # -6,5,4
c4 5_ 6 # -6,5,4
c4 5_
6       # -6,5,4 # still a negative sign since the next thing it sees is a digit
c4 5_z  #  3,0,5,4 # if it's followed by a non-digit, it's a 0
c4 5_p6 #  6,0,5,4
c4 _*   #  0 # 4*0=0

Si le contenu de la pile entière doit être imprimé à la fin d'un programme, une boucle macro récursive peut être utilisée pour y parvenir. Cependant, il est beaucoup plus court d'utiliser simplement la fcommande.

dclit l'entrée une ligne à la fois. Si vous avez besoin de lire plusieurs éléments, le faire une ligne par ligne nécessite soit une ?lecture pour chaque ligne, soit une boucle de macro encombrante. Au lieu de cela, si tous les éléments d'entrée peuvent être placés sur une ligne séparée par des espaces, un seul? lira tous les éléments d'entrée, les poussant chacun sur la pile.

Par exemple, dans seq 10 | dc -e'?f', seqgénère des nombres entiers de 1 à 10, un par ligne. le ?lira juste le premier 1qui sera sorti lors du fvidage de la pile entière. Cependant, dans seq 10 | tr '\n' ' ' | dc -e'?f', les trentiers d'entrée sont séparés par un espace. Dans ce cas, le ?lira tous les entiers de la ligne en une seule fois et fles affichera tous.

Si un opérateur est restreint depuis la source, créez-en un nouveau avec a

Quelque chose qui m'a été utile à quelques reprises maintenant est d'éviter d'utiliser un opérateur spécifique en poussant la valeur ASCII de l'opérateur, en la aconvertissant en chaîne et en la sstockant dans un registre à exécuter plus tard en tant que macro sur. Par exemple, je dois faire la division, mais je suis soit interdit, soit j'essaie d'éviter d'utiliser le personnage /. Je peux, au lieu de cela 47asd, puis à l'avenir, lorsque je devrai diviser 16 par 4 16 4 ldx,.

• Cela ne fonctionnera que pour les opérateurs à un seul caractère (ne peut pas créer de chaîne) et ne fonctionnera pas pour les commandes comme scelle-ci qui doivent être postfixées par quelque chose.
• Cela ajoute pas mal d'octets, et ne convient donc que lorsque l'évitement du caractère spécifique est nécessaire ou offre en quelque sorte un bonus de score.

Éviter les espaces blancs

Éviter les espaces blancs pose de nombreux défis et est généralement facile à utiliser dc. En plus de chaînes, une fois très précis que les espaces devient nécessaire est en poussant plusieurs numéros dans une rangée: 1 2 3. Si cela doit être évité:

• Exécuter une macro vide entre: 1[]x2[]x3[]x.
• Si entre parenthèses sont sur la table, stocker un NOP d'une avance macro de temps: 35asnet exécuter ce entre: 1lnx2lnx3lnx.