<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">% Time-stamp: &lt;2019-09-22 16:32:18 administrateur&gt;
% CrÃ©ation : 2019-08-26T12:37:33+0200

\section{Suites de \textsc{Kaprekar}}
\label{sec:suiteskaprekar}

Une suite de \textsc{Kaprekar} est dÃ©finie par la donnÃ©e d'un nombre
entier, p.~ex. \(125\), d'une base \TO je prendrai systÃ©matiquement et
uniquement~\(10\) comme base de l'Ã©criture des nombres entiers\TF et
d'un nombre~\(N\) de chiffres que j'appellerai la \emph{taille} du
nombre. On obtient un terme~\(u\sb{n+1}\) Ã&nbsp; partir du terme
prÃ©cÃ©dent~\(u\sb{n}\) en appliquant l'algorithme suivant:
\begin{enumerate}\label{algokap}
\item on Ã©crit \(u\sb{n}\) avec \(N\) chiffres dans la base choisie
  quitte Ã&nbsp; complÃ©ter avec des zÃ©ros; 
\item on range les \(N\) chiffres ainsi obtenus dans l'ordre
  dÃ©croissant pour obtenir \(v\sb{n}\); 
\item on range les \(N\) chiffres dans l'ordre croissant pour obtenir
  \(w\sb{n}\); 
\item enfin, \(u\sb{n+1} = v\sb{n} - w\sb{n}\).
\end{enumerate}

Une telle suite est Ã©videmment finie. La commande que nous allons
dÃ©tailler s'arrÃªte sur le dernier nombre dÃ©jÃ&nbsp; obtenu.

En voici deux exemples.

On obtient \og \Kaprekar{125}\fg avec |\Kaprekar{125}| qui, par
dÃ©faut, travaille avec \(N=4\), et \og \Kaprekar[6]{125}\fg pour
lequel on a pris \(N=6\).

L'objet qui va nous servir Ã&nbsp; crÃ©er ces suites est la \gls{sequence}
\TO dont le sigle est \texttt{seq} \TF que fournit l'extension
\Pkg{l3seq}.


\section{Le code}
\label{sec:kaprekarcode}

Je rappelle que tout le code est placÃ© entre \Macro{ExplSyntaxOn}
et \Macro{ExplSyntaxOff} pour les raisons dÃ©jÃ&nbsp; exposÃ©es.

La commande de document est \Macro{Kaprekar} dont voici le code.

\Fragment[Kaprekar, commande de
document]{73}{74}{./codes/kaprekar-def}

On y retrouve l'habituelle \Macro{NewDocumentCommand} mais un nouveau
descripteur d'argument, Ã&nbsp; savoir |O{4}|: le premier argument est
optionnel et sa valeur par dÃ©faut est~\(4\). Si on veut en fournir une
autre, on le placera entre crochet comme d'habitude.

La commande n'est, de fait et Ã&nbsp; part le truc de l'argument optionnel,
qu'un alias de \Macro{KAP_ecrire_tous_les_suivants+nn} que je vais
maintenant dÃ©tailler. Mais commenÃ§ons par la phase d'initialisation.

\subsection{Initialisation}
\label{sec:kaprinit}

\Fragment[Kaprekar, initialisation]{4}{6}{./codes/kaprekar-def}

Avec \Macro{seq_new+N} je crÃ©e deux \glspl{sequence}: \Macro{kaprun_seq}
et \Macro{kaprekar_seq}. La premiÃ¨re \gls{variable} a vocation Ã&nbsp;
recevoir la suite des chiffres du nombre traitÃ©. La seconde contiendra
la suite de \textsc{Kaprekar}.

Je crÃ©e ensuite un \gls{entier} \emph{local} en suivant le modÃ¨le
de l'extension \Pkg{int}.

\subsection{De l'entier Ã&nbsp; la suite et retour}
\label{sec:entiersuiteretour}

J'ai besoin de commandes internes \TO qui pourraient Ãªtre privÃ©es\TF
pour \emph{dÃ©couper} un entier en la suite de ses chiffres et pour
crÃ©er un entier Ã&nbsp; partir d'une suite de chiffres. Le fait de
travailler en base fixÃ©e \TO et en base~\(10\) qui plus est\TF
facilite largement le travail. LÃ&nbsp; encore, si le cÅ“ur vous en dit,
exercice!

\Fragment[Kaprekar, de l'entier Ã&nbsp; la
suite]{9}{15}{./codes/kaprekar-def}

Le premier argument de \Macro{KAP_int_to_seq+NN} est le nombre Ã&nbsp;
dÃ©couper, le second la suite qui contiendra ses chiffres. Dans les
deux cas, la commande attend une \gls{variable}.

Nous avons dÃ©jÃ&nbsp; rencontrÃ© la majoritÃ© des commandes utilisÃ©es dans la
dÃ©finition. Avec \Macro{seq_put_left+NV} je place en premiÃ¨re place
\TO Ã&nbsp; gauche \InEnglish{left}\TF la valeur contenue dans la
\gls{variable} \Macro{l_tmpb_int}. Le~|V| dans la signature assure que
la commande \Macro{l_tmpb_int} sera traitÃ©e de telle sorte que l'on
rÃ©cupÃ¨re bien son contenu.

Dans la boucle, on trouve \Macro{int_div_truncate+nn} qui permet de
rÃ©cupÃ©rer le quotient entier de~|#1| par~|#2|.

\medbreak

\Fragment[Kaprekar, de la suite Ã&nbsp;
l'entier]{17}{22}{./codes/kaprekar-def}

Cette commande transforme une suite de chiffres en un \gls{entier}. On
trouve, en~\Ligne{18},  la commande \Macro{seq_pop_right+NNT} qui
prend la valeur la plus Ã&nbsp; droite dans la suite passÃ©e en 1\ier
argument pour la placer dans la \gls{variable} donnÃ©e en 2\ieme
argument. Si cette opÃ©ration est possible \TO \CAD si la pile n'Ã©tait
pas vide\TF le 3\ieme argument est dÃ©veloppÃ©.

La suite, aprÃ¨s cette opÃ©ration, est amputÃ©e de sa derniÃ¨re
valeur. J'utilise ici la suite comme une pile \TO c'est le fameux
\textsc{lifo} pour \English{Last In First Out} \TF. \Expliii{} fournit
aussi des commandes qui permettent d'utiliser la suite comme une queue
\TO \textsc{fifo} pour \English{First In First Out}\TF.

Dans la boucle, j'utilise \Macro{seq_if_empty_p+N} qui prend la valeur
\VRAI{} si la \gls{sequence} est vide. Tant qu'elle n'est pas vide, je
multiplie par~\(10\) la valeur conservÃ©e dans la \gls{variable} donnÃ©e
en~|#2| et j'y ajoute la derniÃ¨re valeur extraite de la pile.

De fait, le chiffre le plus Ã&nbsp; droite est celui de \emph{poids} le plus
grand. 

\medbreak

\Fragment[Kaprekar, remplissage]{24}{26}{./codes/kaprekar-def}

Cette commande assure que la suite contient le bon nombre de chiffres
en ajoutant des zÃ©ros si nÃ©cessaire. La seule nouveautÃ© est
\Macro{seq_count+N} qui donne le nombre de valeurs contenues dans la
suite.

\medbreak

\Fragment[Kaprekar, tri]{28}{32}{./codes/kaprekar-def}

\Macro{seq_sort+Nn} trie la \gls{sequence} donnÃ©e \TO par son \og
nom\fg\TF en 1\ier argument Ã&nbsp; l'aide du code donnÃ©e en 2\ieme
argument. Ici, j'Ã©change |##1| et |##2| si le premier est strictement
supÃ©rieur au second, autrement dit, je trie les Ã©lÃ©ments de la suite du
plus petit au plus grand. Les commandes \Macro{sort_return_swapped+}
\TO retourner en Ã©changeant\TF et \Macro{sort_return_same+} \TO
retourner le mÃªme\TF assurent le tri.

\medbreak

\Fragment[Kaprekar, calcul du terme
suivant]{34}{44}{./codes/kaprekar-def} 

Le terme courant est donnÃ© par une \gls{variable} comme 2\ieme
argument, le 1\ier est la taille, le 3\ieme doit Ãªtre la
\gls{variable} qui recevra le terme suivant.

\Macro{kaprun_seq} prend en~\Ligne{35} les chiffres du terme courant
puis on remplit puis on range dans l'ordre croissant.

Avec \Macro{seq_set_eq:NN}, en~\Ligne{39}, on crÃ©e, localement et sans
contrÃ´le, \Macro{kaprdx_seq} comme copie de \Macro{kaprun_seq} puis,
en ligne suivante, on la range dans l'ordre dÃ©croissant.

Les trois derniÃ¨res lignes traduisent l'algorithme de \textsc{Kaprekar}
tel qu'exposÃ© en~\pageref{algokap}.

Il ne reste plus qu'Ã&nbsp; utiliser tout cela.

\subsection{Commande interne}

\Fragment[Kaprekar, commande interne]{46}{71}{./codes/kaprekar-def}

La commande \Macro{KAP_ecrire_tous_les_suivants+nn} prend la valeur
de~\(N\) \TO la \emph{taille}\TF en premier argument et le premier
terme de la suite comme 2\ieme argument.

Une fois de plus, tout se passe dans un groupe, ouvert en~\Ligne{47}
et fermÃ© en~\Ligne{71}.

J'utilise la \gls{variable} boolÃ©enne locale \Macro{l_tmpa_bool}
fournie par \Expliii{}. Je lui donne la valeur \VRAI{}
en~\Ligne{48}. Quand elle prendra la valeur \FAUX{} il sera temps de
sortir de la boucle \TO lignes~\(54\) Ã&nbsp;~\(57\)\TF qui remplit la
\gls{sequence} \Macro{kaprekar_seq}.

Avec \Macro{seq_clear+N}, en~\Ligne{49}, je vide la suite
\Macro{kaprekar_seq}.

En \Ligne{51} je place le 1\ier terme de la suite dans la
\gls{sequence} \Macro{kaprekar_seq}. Cette fois je remplis par la
droite avec \Macro{seq_put_right+NV} \TO j'utilise la suite comme une
\emph{queue}\TF.

C'est parce que j'ai besoin que cette valeur soit placÃ©e dans la
\gls{variable} \Macro{l_tmpc_int} que j'utilise
\Macro{seq_put_right+NV}. S'il suffisait de placer la valeur
directement dans la suite, on pourrait utiliser
\Macro{seq_put_right+Nn} avec le code
\vspace{-\baselineskip}
\begin{Verbatim}[frame=lines,framesep=0.75\baselineskip]
\seq_put_right:Nn \kaprekar_seq {#2}
\end{Verbatim}

Je place dans \Macro{l_tmpc_int} le terme suivant calculÃ© avec
\Macro{KAP_suivant+nNN} en~\Ligne{52} et si ce terme est dÃ©jÃ&nbsp; prÃ©sent
dans la suite \TO cas ou \(u\sb{1} = u\sb{0}\)\TF je donne Ã&nbsp;
\Macro{l_tmpa_bool} la valeur \FAUX. C'est \Macro{seq_if_in+NVT} qui
permet de vÃ©rifier que la valeur~|#2| est prÃ©sente dans la suite~|#1|
et de dÃ©velopper, si besoin le code placÃ© dans~|#3|.

Ã€ la fin de la \Ligne{57} la suite a Ã©tÃ© crÃ©Ã©e.

J'ai laissÃ©, commentÃ©e, la \Ligne{58} que j'ai utilisÃ©e Ã&nbsp; titre de
diagnostic: la commande \Macro{seq_show+N} permet d'Ã©crire le
contenu de la \gls{sequence} dans le fichier~|.log|.

Ã€ la ligne suivante, la commande \Macro{seq_use+Nnnn} permet d'Ã©crire
le contenu de la \gls{sequence}, donnÃ©e en 1\ier argument. Les trois
arguments suivants donnent, dans l'ordre, le sÃ©parateur du premier et
deuxiÃ¨me Ã©lÃ©ment quand il n'y a que deux Ã©lÃ©ments; ce qui prÃ©cÃ¨de
chaque Ã©lÃ©ment, sauf le dernier, quand il y plus de deux Ã©lÃ©ments;
enfin, ce qui sÃ©pare l'avant-dernier du dernier Ã©lÃ©ment. Comme je veux
que les nombres soient Ã©crits Ã&nbsp; l'aide de \Macro{np} je ne peux pas me
contenter de cette ligne d'oÃ¹ ce qui suit.

AprÃ¨s avoir placÃ© dans un compteur le nombre d'Ã©lÃ©ments de la suite,
j'utilise \Macro{seq_map_inline+Nn} pour appliquer Ã&nbsp; chaque Ã©lÃ©ment de
la suite passÃ©e en 1\ier argument le code contenu dans le 2\ieme
argument \TO \Ligne{62} Ã&nbsp;~\(70\)\TF.

Dans ce code, j'Ã©cris l'Ã©lÃ©ment en en donnant la valeur Ã&nbsp; \Macro{np}
en mode mathÃ©matique en ligne puis je dÃ©crÃ©mente le compteur Ã&nbsp; l'aide
de \Macro{int_decr+N}.

Avec \Macro{int_case+nnF}, je sÃ©lectionne le sÃ©parateur Ã&nbsp; placer: si
le compteur vaut~\(1\) j'Ã©cris \og |~et~|\fg, s'il vaut~\(0\), je n'Ã©cris
rien \TO \Ligne{67}\TF et, dans tous les autres cas \TO \Ligne{69}\TF,
j'Ã©cris \og |~;~|\fg.

% \subsection{\texorpdfstring{\Kaprekar[2]{12}}{kaprekar 2-12}}

% \Fragment[Kaprekar]{4}{45}{./codes/kaprekar-def}


%%% Local Variables:
%%% mode: latex
%%% TeX-master: "dun19expl3"
%%% End:
</pre></body></html>