# 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 :

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 :

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

8 - 3 :

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 :

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

//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);
    }
}