NOMBRES - Curiosités, théorie et usages

 

Accueil                           DicoNombre            Rubriques           Nouveautés      Édition du: 08/12/2016

Orientation générale        DicoMot Math          Atlas                   Références                     M'écrire

Barre de recherche          DicoCulture              Index alphabétique                               

     

Informatique

 

Débutants

Programmation

Programmation

 

Glossaire

Algorithme

 

INDEX

 

Programmation

 

Algorithmes

 

Multimédia

 

<<< Liste

Chiffres

Procédure >>>

Extraction des chiffres et retournement

Extraction des chiffres d'un nombre périodique

 

Sommaire de cette page

>>> Extraction des chiffres

>>> Tri des chiffres

>>> Somme des chiffres

>>> Retournement de la liste

>>> Bilan

 

 

 

 

 

 

Extraire les chiffres d'un nombre

Procédure pas à pas

  

Plusieurs possibilités:

Pas à pas

 

Extraction des unités, puis des dizaines, etc.

 

 

Programmation la plus simple possible. à voir comme exercice de programmation.

 

>>>

Algébrique

 

Extraction directe par évaluation d'une expression algébrique (une formule).

 

Programmation avec instructions avancées de sommation.

 

>>>

Instruction dédiée

 

Extraction par conversion  en base 10.

 

 

Programmation avec instructions prévues pour (dédiées).

 

>>>

 

Remarque

Avec toutes les connaissances que nous avons, nous allons extraire les chiffres, un à un, d'un nombre. Il s'agit d'un exercice de programmation.

Car, avec Maple, et sans doute avec la plupart des logiciels mathématiques, on obtient immédiatement les chiffres d'un nombre en faisant une conversion à base 10.

 

Voir Développements

Voir Redondance pour comparaison avec les chiffres 

 

 

 

Extraction des chiffres

 

*      Nous avons vu comment avec les instructions iquo et irem nous pouvons calculer le quotient et le reste d'une division.

 

*      Au lieu de sortir les  chiffres les uns après les autres, nous pouvons constituer une liste.

 

 

 

 

 

*      Encore un effort!
Du fait du caractère répétitif du calcul, nous pouvons mettre en œuvre une boucle.

 

 

 

*      Ce serait tout de même mieux si nous n'avions pas à nous inquiéter de la quantité des chiffres.

*      Nous faisons appel à l'instruction de répétition "tant que" (while) jusqu'à ce que le quotient devienne égal à zéro.

 

> n:=12345: irem(n,10);

 n:= iquo(n,10):irem(n,10);

  (etc)

 

>     C:=[]:

 n:=12345:
   C:=[op(C),irem(n,10)];

 n:= iquo(n,10):

   C:=[op(C),irem(n,10)];

  (etc)

 

>      C:=[]:

 n:=12345:

 for i from 1 to 5 do

    C:=[op(C),irem(n,10)];

    n:= iquo(n,10):

 od:

    C;

 

> C:=[]:

 n:=12345789654:

 while n>0 do

    C:=[op(C),irem(n,10)];

    n:= iquo(n,10):

 od:

 C;

 

 

 

Tri des chiffres

 

*      Disposant des chiffres d'un nombre, il est possible de tester ou calculer toutes sortes de choses.

*      Ici, nous donnons l'exemple du tri des chiffres par ordre croissant: instruction sort.

*      Notez que le programme retourne tous les chiffres, même s'ils sont en double.

 

 

> C:=[]:

 n:=854976213845:

 while n>0 do

    C:=[op(C),irem(n,10)];

    n:= iquo(n,10):

 od:

 

 

 sort(C);

 

 

Transformer la liste [ ] en un ensemble { } élimine les doublons >>>

 

 

Somme des chiffres

 

*      Ici, nous donnons un autre exemple avec le calcul de la somme des chiffres.

*      L'instruction nops nous retourne la quantité de chiffres.

*      La somme est initialisée à zéro et elle est incrémenté d'un nouveau chiffre à chaque passage dans la boucle(chaque itération).

 

 

> # Extraction des chiffres

     C:=[]:

  n:=123456789:

  while n>0 do

    C:=[op(C),irem(n,10)];

    n:= iquo(n,10):

  od:

 # calcul de la somme des chiffres

   S:=0:

 for n from 1 to nops(C) do

   S:= S + C[n]:

 od:

   S;

 

 

 

Retournement de la liste

 

*      Pour disposer des chiffres dans le bon ordre, de gauche à droite, il faut retourner la liste.
On va créer une nouvelle liste R.

*      S'il y a q chiffres dans le nombre, alors, le chiffre de R est égal au chiffre symétrique de C:

        Ri = Cq – i + 1

 

*      Note: il est utile de prendre la précaution de démarrer le programme par restart qui remet tout à zéro.

> restart:

 C:=[]:

 n:=8549762:

 while n>0 do

    C:=[op(C),irem(n,10)];

    n:= iquo(n,10):

 od:

 

 q:=nops(C):
 R:=[]:

 for i from 1 to q do

   R:=[op(R), C[q-i+1]]

 od:

 

  R;

 

 

 

 

Chiffres des carrés

 

*      On se propose de calculer les carrés des nombres de 10 à 20 et d'en extraire les chiffres.

*      Il s'agit du même programme.
que précédemment mis dans une boucle, et avec n calculé à chaque passage en boucle comme le carré de N.

 

> restart:

for N from 10 to 20 do

    n:= N*N:

  C:=[]:

  while n>0 do

    C:=[op(C),irem(n,10)]:

    n:= iquo(n,10):

  od:

 

  q:=nops(C):R:=[]:

  for i from 1 to q do

     R:=[op(R),C[q-i+1]]

  od:

  lprint(N,R):

od:

 

10, [1, 0, 0]

11, [1, 2, 1]

12, [1, 4, 4]

13, [1, 6, 9]

14, [1, 9, 6]

15, [2, 2, 5]

16, [2, 5, 6]

17, [2, 8, 9]

18, [3, 2, 4]

19, [3, 6, 1]

20, [4, 0, 0]

 

 

 

*      Recherche des carrés des nombres jusqu'à 100 qui se terminent par 44

 

> restart:

for N from 3 to 100 do

  n:= N*N:

  C:=[]:

  while n>0 do

    C:=[op(C),irem(n,10)]:

    n:= iquo(n,10):

  od:

 

  q:=nops(C):R:=[]:

  for i from 1 to q do

     R:=[op(R),C[q-i+1]]

  od:

 

if C[1]=4 and C[2]=4 then

  lprint(N,R):

fi:

 

od:

 

12, [1, 4, 4]

38, [1, 4, 4, 4]

62, [3, 8, 4, 4]

88, [7, 7, 4, 4]

 

 

*      Recherche des carrés des nombres jusqu'à 1 000 qui se terminent par 444.

 

 

*      Nous allons aussi reconstituer les nombres à partir de leurs chiffres. Pour cela, il faut:

*  transformer la liste R en séquence (op(R));

*  puis demander la concaténation (cat) de cette liste; et

*  le résultat sera placé en r.



Note: la concaténation ne s'applique seulement qu'aux séquences, et non aux listes.

> restart:

for N from 3 to 1000 do

  n:= N*N:

  C:=[]:

  while n>0 do

    C:=[op(C),irem(n,10)]:

    n:= iquo(n,10):

  od:

 

  q:=nops(C):R:=[]:

  for i from 1 to q do

     R:=[op(R),C[q-i+1]]

  od:

 

if C[1]=4 and C[2]=4 and C[3]=4 then

 

  r:= cat(op(R)):

  print(r);

fi:

 

od:

 

 

 

Astuce:

Une instruction suivie de ";" indique que le résultat doit être imprimé. Avec ":", le calcul est muet.

L'instruction print joue le même rôle que le ";": elle restitue les fractions et les formules.

L'instruction lprint imprime le même résultat mais en linéaire.

 

Exemple:

> ConstantePi:= 3,14159:Phi:=(sqrt(5)+1)/2:

 print(ConstantePi,Phi):

 lprint(ConstantePi,Phi):

  3, 14159, 1/2*5^(1/2)+1/2

 

 

Ce que nous avons appris

 

 

*    Nous savons désormais extraire les chiffres d'un nombre quelconque

*    Nous savons en faire la somme, chercher des nombres sur la propriété de leurs chiffres.

 

 

 

 

 

Suite

*    Extraction des chiffres – la formule magique

*    Chiffres – Extraction des chiffres d'un nombre périodique

*    Procédures (Maple)

Voir

*    Chiffres

*    Menu en en-tête

*    ProgrammationIndex

*    Unités des nombres

Aussi

*    Programmation – En savoir un peu plus

Cette page

http://villemin.gerard.free.fr/aInforma/08Chiffr.htm