-- Logical_Number --
with Text_Io;
with Ada.Characters.Handling;
use Ada.Characters.Handling;
procedure Logical_Number is
   
   -- Return the string value of any positive.
   function Image_Number (Number : in Positive) return String is
      
      Img : String := Positive'Image(Number);
   begin
 
      return Img;
   end Image_Number;          
   
   -- Return positive value of decimal digit value.
   function Value_Char (Char : in Character) return Positive is
      
   begin
      
      if not Is_Decimal_Digit(Char) then
     raise Constraint_Error;
      end if;
      return Positive'Value(Char & "" );
   end Value_Char;
   
   -- Return True if the number is progressive.
   function Is_Progressive (Number : in Positive) return Boolean is
 
      Char_Index : Positive := 2;
   begin     
      
      for Char_Pos in 3..Image_Number(Number)'Last loop
     if not (((Value_Char(Image_Number(Number)(Char_Pos)) - Value_Char(Image_Number(Number)(Char_Index)))) >= 0)  then
        return False;
     end if;
     Char_Index := Char_Pos;
      end loop;
      return True;
   end Is_Progressive;
   
   -- Return true if the number is depressive.
   function Is_Depressive (Number : in Positive) return Boolean is
 
      Char_Index : Positive := 2;
   begin     
      
      for Char_Pos in 3..Image_Number(Number)'Last loop
     if not (((Value_Char(Image_Number(Number)(Char_Pos)) - Value_Char(Image_Number(Number)(Char_Index)))) <= 0) then
        return False;
     end if;
     Char_Index := Char_Pos;
      end loop;
      return True;
   end Is_Depressive;
   
   
   
   -- Testing values.
   Progressive_Number : Positive := 123456789;
   Depressive_Number  : Positive := 987654321;
   Other_Number      : Positive := 573194628;           
begin
   if Is_Progressive(Progressive_Number) then
      Text_Io.Put_Line("Progressive_Number is progressive number." );
   end if;
   
   if Is_Depressive(Depressive_Number) then
      Text_Io.Put_Line("Depressive_Number is depressive number." );
   end if;
      
   if Is_Progressive(Other_Number) then
      Text_Io.Put_Line("Other_Number is progressive number." );
   elsif Is_Depressive(Other_Number) then
      Text_Io.Put_Line("Other_Number is depressive number." );
   else
      Text_Io.Put_Line("Other_Number is not logical number." );
   end if;
end Logical_Number;

let a1 = [1;2;2;3;4;5;6;6;7;8;9];;
let a2 = [9;5;2;2;];;
let a3 = [1;4;9;3;7;3;2];;
 
let rec is_progressive l = match l with
           | [] -> true
           | [x]-> true
           | [x;y]-> x<=y
           | (h1::h2::t) -> (h1<=h2) && is_progressive (h2::t);;
           
 
let rec is_degressive l = match l with
           | [] -> true
           | [x]-> true
           | [x;y]-> x>=y
           | (h1::h2::t) -> (h1>=h2) && is_degressive (h2::t);;
 
is_progressive a1;;
is_progressive a2;;
is_progressive a3;;
 
is_degressive a1;;
is_degressive a2;;
is_degressive a3;;
 
 
type progressivity = Progressive|Degressive|Both|None;;
 
let return_progressivity n = 
   let prog = is_progressive n and degr = is_degressive n in
     if (prog && degr) then Both else
     if prog then Progressive else
     if degr then Degressive else
     None;;
 
return_progressivity a1;;
return_progressivity a2;;
return_progressivity a3;;
return_progressivity [0;0;0;0;0;0;0;0];;
 
return_progressivity ['a';'c';'f';'f';'g';'h'];;
 
return_progressivity [true;true;false;false];;
return_progressivity [true;false;true];;
return_progressivity [false;true];;

let explode s =
  let rec exp i l =
    if i < 0 then l else exp (i - 1) (s.[i] :: l) in
  exp (String.length s - 1) [];;

let number_progressivity n = return_progressivity(explode(string_of_int n));;
 
number_progressivity 13423423;;
number_progressivity 87774;;

-- Logical String --
-- Entrez un entier et appuyez sur Entree.
with Text_Io;
procedure Logical_String is
   Number : String := Text_Io.Get_Line;
   Pro : Boolean := false;
   Dep : Boolean := False;
begin
   for I in 1..Number'Last-1 loop
      if (Character'Pos(Number(I)) - Character'Pos(Number(I+1))) < 0 then          
     if Dep then
        Text_Io.Put_Line("le nombre " & Number & "est incertain." );        
        return;
     else
        Pro := True;
     end if;
      elsif (Character'Pos(Number(I)) - Character'Pos(Number(I+1))) > 0 then     
     if Pro then                     
        Text_Io.Put_Line("le nombre " & Number & "est incertain." );        
        return;
     else
        Dep := True;
     end if;
      end if;      
   end loop;   
   if Pro then
      Text_Io.Put_Line("le nombre " & Number & " est croissant." );
   elsif Dep then
      Text_Io.Put_Line("le nombre " & Number & " est decroissant." );
   end if;
   Text_Io.Put("Appuyez sur Entree" );
   Text_Io.Skip_Line;      
end Logical_String;

use v5.14;
use bigint;
use List::Util qw(reduce);
 
sub checknum {
  $_ = shift;
  if (/^\d*$/) {
    no bigint;
    my @v = (0, 0, 0);
    reduce { $v[($a<=>$b)+1] = 1; $b } (/\d/g);  # l'essentiel du travail est condensé en cette ligne
    given (4*$v[0]+2*$v[2]+$v[1]) {
      when(0) {print "Entree vide\n";}
      when(1) {print "Suite de chiffres constante\n";}
      when(2) {print "Suite de chiffres strictement decroissante\n";}
      when(3) {print "Suite de chiffres decroissante\n";}
      when(4) {print "Suite de chiffres strictement croissante\n";}
      when(5) {print "Suite de chiffres croissante\n";}
      default {print "Suite de chiffres ni croissante ni decroissante\n";}
    }
  }
  else {
    print "Entree invalide\n";
  }
}
 
# Test avec un grand nombre et un grand nombre en texte
checknum(333444444444444444455556666777788899);
print "\n";
checknum("998887777666655554444444444444444333" );