Bonjour,
 
Je suis occupé à écrire un algorithme. Dans celui-ci, je demande à l'utilisateur d'insérer un code. Une fois le code inséré, comment connaître le nombre de chiffres dont il est composé sans devoir le demander à l'utilisateur ?  
 
Merci pour votre aide !  

En faisant une division par la base, si c'est un entier.
Si c'est un alphanumérique, c'est c'est pas la même technique ou pas.

Oui, le code est un entier. Comment on fait une division par la base ?

Avec beaucoup d'amour.
 
Tiens avec Ada, ça donne ceci :

with Text_Io; use Text_Io;
procedure Main is
   
   
   function Length_Of(Code : in Natural) return Positive is
      
      Length : natural := 1;
      
   begin
      if Code / 10 > 0 then
         return length + Length_Of(Code /10);
      else
         return Length;
      end if;
   end Length_Of;
   
   
begin     
   loop
      Text_Io.Put("Entrez le code : " );
      declare
         Line : constant String := Text_Io.Get_Line;
         Code : Natural := 0;
      begin
         Code := Natural'Value(Line);
         Text_Io.Put_Line("Length_Of" & Natural'Image(Code) & " : " & Positive'Image(Length_Of(Code)));
         exit;
      exception
         when Constraint_Error =>
            Text_Io.Put_Line("Erreur de saisie" );
      end;
   end loop;
end Main;

Merci beaucoup, mais en faite j'ai jamais utilisé Ada donc j'ai un peu du mal à suivre ton développement...

Une version 'fonctionnelle' utilisant la tail-récursion.
Je suppose la base positive non nulle (sinon cela n'a pas de sens).
 
nombre_chiffre_base(nombre, base)
  retourner nombre_chiffre_base_récursif(abs(nombre), base, 0)
 
nombre_chiffre_base_récursif(nombre, base, i)
   si nombre < base retourner i+1
   retourner nombre_chiffre_base_récursif(div(nombre, base), base, i+1)
 
ou abs est la valeur absolue et div la division entière.
 
A+,

div c'est le quotient ?

 
Strictement supérieure à 1, sinon cela n'a pas de sens !
 
Sinon, le nombre de chiffres d'un nombre (N >= 1) en base n (> 1) est égal à 1+E(logn(N)) où E est la partie entière et logn le logarithme en base N ( par définition, logn(x) = log(x)/log(n)). Cela peut s'étendre aux nombres (>= 1) et bases réelles ( > 1) en ne considérant que la partie entière de l'écriture du nombre.
 
Par ailleurs, dans le cas qui vous intéresse, ne serait-il pas plus simple de compter le nombre de caractères saisis (si saisie sous forme de texte) ou le nombre d'appuis sur les boutons (si saisie sous forme de clavier affiché à l'écran) ?
 

euh si, la base 1 a un sens, mais on ne peut pas y exprimer le zéro et les nombres négatifs. 1 y vaut 1, 2 11, 3 111 etc. Le principe des petits bâtons alignés les uns à côté des autres.  
Bon, je n'avais bien sur pas ça en tête dans l'algo de ma réponse précédente.
A+,

Avec le code de Gilou ça donne ceci, avec le miens également certainement.

D'ailleur, je voulais dire que j'ai modifier ton code Gilou.
 

with Text_Io; use Text_Io;
procedure Main is
 
   function Nombre_Chiffres_Base_Recursif(Chiffres : in Natural; Base : in Positive; Nombre : in Natural) return Positive is
   begin
 
      if Chiffres < Base then return Nombre+1; end if;
 
      return Nombre_Chiffres_Base_Recursif("/"(Chiffres, Base), Base, Nombre + 1);
   end Nombre_Chiffres_Base_Recursif;
 
   function Nombre_Chiffres_Base(Chiffres : in Natural; Base : in  Positive) return Positive is
   begin
 
      return Nombre_Chiffres_Base_Recursif(abs chiffres, Base, 0);
   end Nombre_Chiffres_Base;
 
 
begin
   loop
      Text_Io.Put("Entrez le code : " );
      declare
         Line : constant String := Text_Io.Get_Line;
         Code : Natural := 0;
         Base : constant Positive := 10;
      begin
         Code := Natural'Value(Line);
         Text_Io.Put_Line("Length_Of" & Natural'Image(Code) & " base : " & positive'image(base) & " :=" & Positive'Image(Nombre_Chiffres_Base(Code, base)));                                   
         exit;
      exception
         when Constraint_Error =>
            Text_Io.Put_Line("Erreur de saisie" );
      end;
   end loop;
end Main;

 
Comme tu peux le voir, on attend pas Nombre en paramètre de Nombre_Chiffres_Base, mais Chiffres.

Si les zéros devant sont significatifs, cela signifie donc qu'on se tape complètement de la base, et qu'en fait, on fait juste un comptage du nombre de caractères entrés. Et ça, ça se trouve avec les fonctions des librairies, la longueur d'une chaine exprimée en nombre de caractères, avec strlen en C par exemple.
A+,