ajout du tp11 d'algo

Algo/tp/tp11/testtp11.c

@@ -0,0 +1,70 @@
+#include "tp11.h"
+
+void testExercice1()
+{
+    int n = 4;
+    int result = nbSegments(n);
+    printf("Il y a %d segments\n", result);
+}
+
+void testExercice2Nb()
+{
+    int tab[10] = {0, 2, 3, 4, 5, 8, 2, 25, 0, 2}, tab2[10] = {1, 2, 3, 4, 5, 8, 2, 25, 0, 2};
+    int n = 10, result, val = 2;
+    result = sommeNentierT(tab, n);
+    printf("La somme des entiers est %d\n", result);
+    printf("====================================\n");
+    result = minValT(tab, n);
+    printf("La valeur minimale est %d\n", result);
+    printf("====================================\n");
+    result = nombreOccurencesT(tab, n, val);
+    printf("Le nombre d'occurences de %d est %d\n", val, result);
+    printf("====================================\n");
+    result = rechercheValT(tab, n, val);
+    if(result == 0)
+        printf("La valeur %d n'est pas dans le tableau\n", val);
+    else
+        printf("La valeur %d est dans le tableau\n", val);
+    printf("====================================\n");
+    result = recherchePlusProcheXT(tab, n, val);
+    printf("La valeur %d est la plus proche de %d, dans le tableau\n", result, val);
+    printf("====================================\n");
+    result = rechercheValMaxT(tab, n);
+    printf("La valeur maximale est %d\n", result);
+    printf("====================================\n");
+    result = compare2T(tab, tab2, n);
+    printf("Les tableaux sont %s\n", result ? "identiques" : "different");
+    printf("====================================\n");
+}
+
+
+void testExercice2Chaine()
+{
+    char tab1[10]="bonjour", tab2[10]="aurevoir";
+    int n = 10, result;
+    char result2[10];
+    result = longueurChaine(tab1);
+    printf("La longueur de la chaine est %d\n", result);
+    printf("====================================\n");
+    result = copieChaine(tab1, tab2);
+    printf("La chaine copiee est %s\n", tab2);
+    printf("====================================\n");
+    result = concateneChaine(tab1, tab2, result2);
+    printf("La chaine concatenee est %s\n", result2);
+    printf("====================================\n");
+    result = compareChaine(tab1, tab2);
+    printf("Les chaines sont %s\n", result ? "identiques" : "different");
+    printf("====================================\n");
+    result = mirroirChaine(tab1, result2);
+    printf("La chaine mirroir est %s\n", result2);
+    printf("====================================\n");
+}
+
+
+int main(void)
+{
+    //testExercice1();
+    //testExercice2Nb();
+    testExercice2Chaine();
+    return 1;
+}

Algo/tp/tp11/tp11.c

@@ -0,0 +1,121 @@
+#include "tp11.h"
+
+/*  Exercice 1  */
+int nbSegments(int n)
+{
+    if (n == 1)
+        return 0;
+    return (n-1) + nbSegments(n - 1);
+}
+
+/*  Exercice 2  */
+
+int sommeNentierT(int tab[], int n)
+{
+    if (n == 1)
+        return tab[0];
+    return tab[0] + sommeNentierT(tab+1, n-1);
+}
+
+int minValT(int tab[], int n)
+{
+    int min;
+    if (n == 1)
+        return tab[0];
+    min = minValT(tab+1, n-1);
+    if (tab[0] < min)
+        return tab[0];
+    return min;
+}
+
+int nombreOccurencesT(int tab[], int n, int val)
+{
+    if (n == 1)
+        return tab[0] == val;
+    return (tab[0] == val) + nombreOccurencesT(tab+1, n-1, val);
+}
+
+int rechercheValT(int tab[], int n, int val)
+{
+    if (n == 0)
+        return 0;
+    if(val == tab[n])
+        return 1;
+    return rechercheValT(tab, n-1, val);
+}
+
+int recherchePlusProcheXT(int tab[], int n, int x)
+{
+    int min;
+    if (n == 1)
+        return tab[0];
+    min = recherchePlusProcheXT(tab+1, n-1, x);
+    if (abs(tab[0] - x) < abs(min - x))
+        return tab[0];
+    return min;
+}
+
+int rechercheValMaxT(int tab[], int n)
+{
+    int max;
+    if (n == 1)
+        return tab[0];
+    max = rechercheValMaxT(tab+1, n-1);
+    if (tab[0] > max)
+        return tab[0];
+    return max;
+}
+
+int compare2T(int tab1[], int tab2[], int n) //a revoir
+{
+    if (n == 1)
+        return tab1[0] == tab2[0];
+    if (tab1[0] != tab2[0])
+        return 0;
+    return compare2T(tab1+1, tab2+1, n-1);
+}
+
+int longueurChaine(char chaine[])
+{
+    if (chaine[0] == '\0')
+        return 0;
+    return 1 + longueurChaine(chaine+1);
+}
+
+int copieChaine(char chaine1[], char chaine2[])
+{
+    if (chaine1[0] == '\0')
+        return 0;
+    chaine2[0] = chaine1[0];
+    return 1 + copieChaine(chaine1+1, chaine2+1);
+}
+
+int concateneChaine(char chaine1[], char chaine2[], char chaine3[])
+{
+    if (chaine1[0] == '\0')
+        return copieChaine(chaine2, chaine3);
+    chaine3[0] = chaine1[0];
+    return 1 + concateneChaine(chaine1+1, chaine2, chaine3+1);
+}
+
+int compareChaine(char chaine1[], char chaine2[])
+{
+    if (chaine1[0] == '\0' && chaine2[0] == '\0')
+        return 1;
+    if (chaine1[0] == chaine2[0])
+        return compareChaine(chaine1+1, chaine2+1);
+    return 0;
+}
+
+int mirroirChaine(char chaine1[], char chaine2[])
+{
+    if (chaine1[0] == '\0')
+        return 0;
+    chaine2[longueurChaine(chaine1)-1] = chaine1[0];
+    return 1 + mirroirChaine(chaine1+1, chaine2);
+}
+
+/*  Exercice 3  */
+
+/*  Pour vider n, il faut vider n-2, on remet les n-2 en vide les n-2 de ce n        */
+/*  Pour remplir n, il faut remplir n-2, on remplis n-1 vider n-2 et on remplie n-1      */

Algo/tp/tp11/tp11.h

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int nbSegments(int n);
+int sommeNentierT(int tab[], int n);
+int minValT(int tab[], int n);
+int nombreOccurencesT(int tab[], int n, int val);
+int rechercheValT(int tab[], int n, int val);
+int recherchePlusProcheXT(int tab[], int n, int x);
+int rechercheValMaxT(int tab[], int n);
+int compare2T(int tab1[], int tab2[], int n);
+int longueurChaine(char chaine[]);
+int copieChaine(char chaine1[], char chaine2[]);
+int concateneChaine(char chaine1[], char chaine2[], char chaine3[]);
+int compareChaine(char chaine1[], char chaine2[]);
+int mirroirChaine(char chaine1[], char chaine2[]);
+