fonction aire_perimetre_carre(E cote:reel, S aire : reel):réel
{
        variable perimetre : réel

        aire <-- cote * cote
        perimetre <-- 4*cote
        
        retourne perimetre
}

fonction aire_perimetre_carre2(E cote:reel, S perimetre : reel):réel
{
        variable aire : réel

        aire <-- cote * cote
        perimetre <-- 4*cote
        
        retourne aire
}


fonction perimetre_carre(E cote:reel):réel
{
        variable perimetre : réel
        
        perimetre <-- 4*cote
        
        retourne perimetre
}

fonction aire_carre(E cote:reel):réel
{
        variable aire : réel

        aire <-- cote * cote
        
        retourne aire
}


Algorithme Utilisation
{
        variable c, a, p : réel
        
        Afficher("Veuillez saisir le coté ?")
        Saisir(c)
        
        p <-- aire_perimetre_carre(c,a)
        
        Afficher("L'aire du carré est ", a, " et son périmètre est ", p,".\n")
        
// Ce qui suit n'est pas bon
//       Afficher("L'aire du carré est ", a, " et son périmètre est ", aire_perimetre_carre(c,a),".\n")
// par contre ceici est bon
//        Afficher("Le perimetre du carré est ", aire_perimetre_carre(c,a), " et son aire est ", a,".\n")
}

Algorithme Utilisation2
{
        variable c, a, p : réel
        
        Afficher("Veuillez saisir le coté ?")
        Saisir(c)
        
        a <-- aire_perimetre_carre2(c,p)
        
        Afficher("L'aire du carré est ", a, " et son périmètre est ", p,".\n")
        
// Ce qui suit n'est pas bon
//       Afficher("Le périmetre du carré est ", p, " et son aire est ", aire_perimetre_carre2(c,p),".\n")
// par contre ceici est bon
//        Afficher("L'aire du carré est ", aire_perimetre_carre2(c,p), " et son perimètre est ", p,".\n")
}

Algorithme Utilisation_avec_deux_fonctions
{
        variable c : réel
        
        Afficher("Veuillez saisir le coté ?")
        Saisir(c)
        
        
        Afficher("L'aire du carré est ", aire_carre(c), " et son périmètre est ", perimetre_carre(c),".\n")
}



fonction EstImpaire(E n:entier):booleen
{
        variable impaire : booleen
        
        Si (n mod 2 = 1) alors
        {
                impaire <-- VRAI
        }
        sinon
        {
                impaire <-- FAUX
        }
        
        // autre solution 
        // impaire <-- (n mod 2 = 1)
        
        retourne impaire
}



Algorithme Utilisation
{
        variable N : entier
 
        Afficher("Veuillez saisir un nombre entier ?")
        Saisir(N)
        
        
        
        Si (EstImpaire(N)) alors
        {
                Afficher("Le nombre ", N, " est impaire.\n")
        }
        sinon
        {
                Afficher("Le nombre ", N, " est paire.\n")
        }
        
}



fonction Ajout10(E n:entier):entier
{
        variable nplus10:entier

        nplus10 <-- n + 10
        
        retourne nplus10
}

Algorithme Utilisation
{
        variable N: entier
        
        Afficher("Veuillez saisir un nombre entier ?")
        Saisir(N)

        Afficher("Le nombre vaut ", N, " avant l'appel à la fonction.\n")

        N <-- Ajout10(N)

        Afficher("Le nombre vaut ", N, " après l'appel à la fonction.\n")
        
}


procedure permutation(E/S X : entier, E/S Y : entier)
NE SE TRANSFORME PAS EN FONCTION !!!


procedure triCroissant(E/S A : entier, E/S B : entier, E/S C : entier)
MEME PUNITION !


La BELLE solution consiste à découper en deux fonctions
fonction quotient_div_euclidienne(E dividende : entier, E diviseur : entier): entier
{
        variable quotient : entier
        quotient <-- dividende div diviseur
        
        retourne quotient
}

fonction reste_div_euclidienne(E dividende : entier, E diviseur : entier): entier
{
        variable reste : entier
        reste <-- dividende mod diviseur
        
        retourne reste
}


Algorithme Utilisation
{
        variable A, B : entier
        
        Afficher("Veuillez saisir deux nombres entier : ")
        Saisir(A,B)

   

        Afficher("Le quortient de la division de ", A, " par", B, " est ", quotient_div_euclidienne(A,B), " et le reste est ", reste_div_euclidienne(A,B), ".\n")
        
}


fonction CalculNbjours(E mois : entier, E annee : entier) : entier
{
        variable nbjours : entier
        Selon (mois)
        {
                1,3,5,7,8,10,12 : nbjours <-- 31
                4,6,9,11 : nbjours <-- 30
                2: Si (annee mod 4 = 0) alors
                        nbjours <-- 29
                   sinon
                        nbjours <-- 28
        }
        
        retourne nbjours
}

Algorithme Utilisation
{
        variable m, a, : entier
        
        Afficher("Veuillez saisir le mois et l'année : ")
        Saisir(m,a)

        Afficher("le nombre de jours du mois ", m, "/", a, " est ",CalculNbJours(m,a), ".\n")
        
}