---
# System prepended metadata

title: Exercices d'Algorithmie
tags: [Courses]

---

# Exercices d'Algorithmie

## 1 - Suivre un algo

    Soit A = 5
    A = A * 4
    A = A * 3
    A = A * 2
1 - Combien vaut A ?

    A = 3
    B = 4
    Temp = A
    A = B
    B = Temp
2 - Combien vaut A et B ?

    A = 0
    A = Cos(A)
    B = Sin(A)
    A = A + B
3 - Combien vaut A

    VARIABLE = 16
    VARIABLE = VARIABLE * 2
    B = VARIABLE % 2
    
4 - Combien vaut B ?
    
    A = 2
    B = 4
    si B < A
        B = B * A
    sinon
        A = B / A
5 - Combien valent A et B ?

    A = 2
    Tant que A<10
        A = A * 2
6 - Combien vaut A ?

    A = 0
    Pour I allant de 0 a 5 (inclus)
        A = A + I
7 - Combien vaut A ?

## 2 - Si/if
1 - Imaginez un algo qui permette d'obtenir le maximum entre trois valeurs réelles A, B et C.
2 - Imaginer un algo qui donnerait la valeur abolue d'un réel A.
## 3 - Boucles
1 - Imaginer un algo qui permette d'obtenir une valeur V à la puissance P (entier).
2 - Imaginer un algo qui permette d'obtenir le PGCD de deux entiers A et B.
3 - Imaginer un algo qui permette de calculer la factorielle d'un entier C.
## 4 - Fonctions
1 - Créer une fonction prenant en entrée 3 variables entiéres et qui retourne le résultat de l'addition de ces 3 variables. Utiliser cette fonction pour additionner 3, 45, 12 et afficher le resultat.
2 - Créer une fonction qui prenne en entrée les longueurs réels du petit et du grand coté d'un rectangle. Elle doit retourner l'aire (réel).
3 - Créer une fonction prenant en entrée un entier et retourne la factiorelle de cet entier.
4 - Créer une fonction prenant en entrée deux entiers. Elle doit afficher la valeur des deux entiers puis retourner le maximum.

## 5 - Tableaux
1 - Créer une fonction qui prenne en entrée un tableau d'entiers et retourne le maximum (le plus grand) des éléments du tableau.
2 - Créer une fonction qui prenne en entrée un tableau d'entiers et inverse les positions des élements du tableau (le premier élément devient le dernier, le second vant dernier etc.).
3 - Créer une fonction qui prenne en entrée un tableau de n'importe quelle taille et qui retourne le tableau trié dans l'ordre croissant.
4 - Ecrire une fonction Moyenne qui calcule la moyenne des valeurs contenue dans un tableau passé en entrée.
5 - Ecrire une fonction Contient qui prenne en entrée un tableau de réel et un réel A et qui retourne vrai si le tableau contient la valeur A, et faux autrement.
                
## 6 - Terminaison
1 - La fonction suivante respecte elle la terminaison ? Si non pour quelles valeurs ?

    Réel MaFonction(Entier X)
	Retourner A/X
    
2 - La fonction suivante respecte elle la terminaison ? Si non pour quelles valeurs ?

    Entier MaFonction(Entier X, Entier Y)
	Tant que X > 0
    	X+=Y
    Retourner X

3 - La fonction suivante respecte elle la terminaison ? Si non pour quelles valeurs ?

    Réel MaFonction(Entier X)
	Réel SORTIE = 0
	Pour I de 0 à X (exclu) avec un pas de 1
    	SORTIE += I / (1 - 3/X)
    Retourner SORTIE
    
## 7 - Complexité
1 - Donnez la compléxité de la fonction suivante.

    Entier[] MaFonction(Entier[] T)
        Entier COMPTEUR = 0
        Tant que COMPTEUR < nombre d'éléments de T
            COMPTEUR++
            T[COMPTEUR] = COMPTEUR
        Retourner T

2 - Donnez la compléxité de la fonction suivante.

    Entier MaFonction(Entier X)
        Entier COMPTEUR = 0
        Tant que COMPTEUR < 2*X
            COMPTEUR++
        Retourner COMPTEUR
3 - Donnez la compléxité de la fonction suivante.

    Void AffichageDeMatrice(Entier X)
        Entier I = 0
        Pour I Allant de 0 à X
            Pour J Allant de 0 à X
                Afficher I*X+J

## 8 - Récursivité
1 - Donner un algo récursif permettant d'effectuer la factorielle d'un entier.
2 - Donner un algo récursif trouvant la valeur d'un élément du triangle de Pascal déterminé par sa ligne et sa colonne.

## 9 - Code

1 - Ecrire en code une fonction qui prenne en entrée un tableau de n'importe quelle taille et qui retourne le tableau trié dans l'ordre croissant.

2 - Ecrire une fonction qui calcule et retourne un réel en entrée à la puissance d'un entier également en entrée.

3 - Ecrire en code une fonction qui retourne la factorielle d'un entier récursivement.

4 - Ecrire en code une fonction qui retourne la moyenne des valeurs d'un tableau en entrée.

## 10 - Structure de données

1 - Créer une classe liste qui contient une valeur réelle et une référence à une autre liste.

2 -Créer une fonction AddElement(réel élément), qui permet d'ajouter un élément à la suite de cet élément.

3 - Créer une fonction AddElementAtTheEnd(réel élément), qui permet d'ajouter un élément à la fin de la liste (même si on l'appelle sur le premier élément).

4 - Créer une fonction Get(entier id), qui permet de lire la valeur de l'élément à la position donnée en paramètre.

5 - Créer une fonction Remove(entier id), qui permet de supprimer l'élément à la position donnée en paramètre.

# Corrections

## 1 - Suivre un algo

1 - 1 :
>A = 120

1 - 2 :
>A = 4 et B = 3

1 - 3 :
>A = 1

1 - 4 :
>B = 0

1 - 5 :
>A = 2 et B = 4

1 - 6 :
>A = 16

1 - 7 :
>A = 15

## 2 - Si/if
2 - 1 :

    Réel A
    Réel B
    Réel C
    Réel MAX 
 
    si A>B ET A>C
        MAX = A
    sinon si B>C
        MAX = B
    sinon
        MAX = C
        
2 - 2 :

    Réel A
    si A<0
        A = -A
    
## 3 - Boucles
3 - 1 :

    Réel V
    Entier p
    Réel RESULTAT 

    RESULTAT = 1
    Pour I allant de 1 jusqu'a P (inclus) avec un pas de 1
        RESULTAT = RESULTAT * V
    Afficher RESULTAT

3 - 2 :
    
    Entier A
    Entier B
    Entier RESTE = 1

    Tant que RESTE > 0
        RESTE = A%B
        A = B
        B = RESTE
    Afficher A

3 - 3 :

    Réel RESULTAT = 1 

    Pour I allant de 1 jusqu'a C (inclus) avec un pas de 1
        RESULTAT = RESULTAT * I

## 4 - Fonctions
4 - 1 :

    Entier Addition(Entier A, Entier B, Entier C)
        Retourner A+B+C
    
    Entier Resultat = Addition(3, 45, 12)
    Afficher Resultat
    
4 - 2 :

    Réel Aire(Réel PetitCote, Réel GrandCote)
        Réel AireDuRectangle = PetitCote * GrandCote
        Retourner AireDuRectangle
        
4 - 3 :
    
    Entier Factorielle(Entier A)
        Entier Resultat = 0
        Pour I de A à 0 (exclus) avec un pas de -1
            Resultat = Resultat * I
        Retourner Resultat
        
4 - 4 :

    Entier Maximum(Entier A, Entier B)
        Afficher A
        Afficher B
        Si A>B
            Retourner A
        Sinon
            Retourner B
    

## 5 - Tableaux

4 - 1 :
    
    Entier MaxTableau(Entier[] T)
        Entier Max = -10000
        Pour I de 0 à nb élements de T (exclus)
            Si T[I]>Max
                Max = T[I]
        Retourner Max

4 - 2 :

    Entier[] InverseTableau(Entier[] T)
        Entier TCOUNT = nombre d'éléments de T
        Pour I de 0 à TCOUNT/2 (non inclu)
                Entier OTHERI = TCOUNT-1-I
                Entier TEMP = T[I]
                T[I] = T[OTHERI]
                T[OTHERI] = TEMP
        Retourne T
    
    T = [5]{3,5,1,4,2}
    InverseTableau(T)

4 - 3 :

    Réel[] TriCroissant1(Réel[] T)
        Entier TCOUNT = nombre d'éléments de T
        Pour J de 0 à TCOUT-1(non inclus)
            Pour I de 0 à TCOUNT-1 (non inclus)
                Si T[I] > T[I+1]
                    Réel TEMP = T[I]
                    T[I] = T[I+1]
                    T[I+1] = TEMP
        
        Retourner T
        
    Réel[] TriCroissant2(Réel[] T)
        Entier TCOUNT = nombre d'éléments de T
        Pour I de 0 à TCOUNT (non inclus)
            //Chercher si il y a une plus petite valeur dans les restantes
            Pour J de I+1 à TCOUNT (non inclus)
                Si T[I] > T[J]
                    //Inverse les valeurs
                    Réel TEMP = T[I]
                    T[I] = T[J]
                    T[J] = TEMP
        Retourner T
        
4 - 4 :
    
     Réel[] Moyenne(Réel[] T)
        Réel total = 0
        Pour I de 0 à nombre d'éléments de T(non inclus)
            total += T[I]
        
        Retourner total / nombre d'éléments de T
        
4 - 5 :

    Booléen Contient(Réel[] T, Réel A)
        Pour I de 0 à nombre d'éléments de T (non inclus) avec un pas de 1
            Si T[I]==A
                Retourner Vrai
        Retourner Faux
        
    
## 6 - Terminaison
5 - 1 :
>Non pour X = 0, car on ne peut pas diviser par 0.
    
5 - 2 : 
>Non pour X>0 et Y>=0, car la boucle ne fini jamais.

3 - La fonction suivante respecte elle la terminaison ? Si non pour quelles valeurs ?
>Non pour X = 3, car on aurait une division par 0.
    
## 7 - Complexité
6 - 1 :
>O(n)

6 - 2 :
>O(n)

6 - 3 :
>O(n²)

        
## 8 - Récursivité

7 - 1 :

    Entier Factorielle(Entier X)
        Si X = 1
            retourner 1
        Sinon
            retourner Factorielle(X-1) * X
7 - 2 :

    Entier Pascal(Entier X, Entier Y)
        //Quand j'arrive en (0,0), j'ai le 1 original.
        si X==0 ET Y==0
            retourner 1
        sinon si X<0 OU Y<0
            retourner 0
        sinon
            retourner Pascal(X-1, Y-1) + Pascal(X, Y-1)
            
## 9 - Code

8 - 1 :

```cs=
static float[] TriCroissant1(float[] t)
{
    int tCount = t.Length;

    //Pour J de 0; à TCOUNT-1(non inclus);avec un pas de 1
    for(int j = 0; j < tCount - 1; j++)
    {
        for(int i=0; i < tCount - 1; i++)
        {
            //Si T[I] > T[I+1]
            if (t[i]>t[i+1])
            {
                //Permutation
                float temp = t[i];
                t[i] = t[i + 1];
                t[i + 1] = temp;
            }
        }
    }

    return t;
}
```
8 - 2 :

```cs=
static float Puissance(float valeur, int exposant)
{
    float puissance = 1;
    for (int i = 0; i < exposant; i++)
    {
        puissance *= valeur;
    }
    return puissance;
}
```

8 - 3 :

```cs=
static int Factorielle(int x)
{
    //Condition d'arret
    if(x==1)
    {
        return 1;
    }
    //Récursivité
    else
    {
        Console.WriteLine("X vaut : "+x);
        return Factorielle(x - 1) * x;
    }
}
```

8 - 4 :

```cs=
static float Moyenne(float[] t)
{
    float moyenne = 0;
    for (int i = 0; i < t.Length; i++)
    {
        moyenne += t[i];
    }
    return moyenne / t.Length;
}
```

## 10 - Structures de données

```cs=
//9 - 1
class LinkedList
{
    public float value;
    public LinkedList nextCell = null;

    //9 - 2
    public void AddElement(float valueToAdd)
    {
        //Créer une nouvelle liste
        LinkedList newList = new LinkedList();

        //Donner la valeur à la nouvelle liste
        newList.value = valueToAdd;

        //Relier a nous même
        nextCell = newList;
    }

    //9 - 3
    public void AddAtTheEnd(float valueToAdd)
    {
        //La liste sur laquelle je travail actuelement.
        //Je démarre sur moi même
        LinkedList currentList = this;

        //Parcourir la liste tant qu'il y a quelque chose dans nextCell.
        while(currentList.nextCell != null)
        {
            //Je passe à la liste suivante, donc je travail sur la suivante.
            currentList = currentList.nextCell;
        }
        //Lorsque ce n'est plus le cas, on ajoute un élément à cette list (à la dernière).
        //On peut le faire grace a AddElement(). La question sur quelle liste l'appeler ?
        currentList.AddElement(valueToAdd);
    }
}
```