Ajout des TP

BUT1/CONTROLE/CM1/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "linux-gcc-x64",
+      "includePath": [
+        "${workspaceFolder}/**"
+      ],
+      "compilerPath": "/usr/bin/gcc",
+      "cStandard": "${default}",
+      "cppStandard": "${default}",
+      "intelliSenseMode": "linux-gcc-x64",
+      "compilerArgs": [
+        ""
+      ]
+    }
+  ],
+  "version": 4
+}

BUT1/CONTROLE/CM1/.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "cppdbg",
+      "request": "launch",
+      "args": [],
+      "stopAtEntry": false,
+      "externalConsole": false,
+      "cwd": "/export/home/an23/stiti/Desktop/DEV/CM1",
+      "program": "/export/home/an23/stiti/Desktop/DEV/CM1/build/Debug/outDebug",
+      "MIMode": "gdb",
+      "miDebuggerPath": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
+    }
+  ]
+}

BUT1/CONTROLE/CM1/.vscode/settings.json

@@ -0,0 +1,37 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wconversion",
+    "-Wnull-dereference",
+    "-Wsign-conversion"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false
+}

BUT1/CONTROLE/CM1/exo1.c

@@ -0,0 +1,10 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void){
+    printf("  {o,o}\n");  
+    printf("  (__(\\\n");/* On rajoute un "\" pour préciser que le \ d'avant ne sert pas à dire que le caractère d'après est spécial"*/
+    printf("  -\"-\"-  "); /*idem ici avec les guillemets*/
+
+    return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM1/exo2.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+ 
+int main(void) {
+  printf("%d\n", 58);
+  printf("%o\n", 47); /* IMPOSSIBLE A AFFICHER CAR LE 8 n'existe pas en base octal ... comme le 2 n'existe pas en base décimal donc 47 pour 57 à la limite*/
+  printf("%x\n", 0x58);
+  return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM1/exo3.c

@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+ 
+int main(void) {
+    double taille_utilisateur; /* taille en cm /// Justification nom de vaiable = taille_utilisateur car c'est la taille taper par l'utilisateur*/
+    int i,pied=0,pouce=0;
+    printf("Entrez votre taille : ");
+    scanf("%lf",&taille_utilisateur); /* lf car c'est un double*/
+
+    /* S'occupe de retirer l'équivalent de 1 pied à la taille en cm et d'ajouter 1 à pied*/
+    for(i=0;taille_utilisateur>=0.3048;i++){
+        taille_utilisateur = taille_utilisateur - 0.3048;
+        pied++; 
+    }
+
+    /* S'occupe de retirer l'équivalent de 1 pouce à la taille en cm et d'ajouter 1 à pouce*/
+    for(i=0;taille_utilisateur>=0.0256;i++){
+        taille_utilisateur = taille_utilisateur - 0.0256;
+        pouce++;
+    }
+
+
+    if(pied>0){
+        if(pied==1){
+            printf("%d pied et",pied);
+        }else{
+            printf("%d pieds",pied);
+        }
+    }
+
+    if(pied>0 && pouce>0){
+        printf(" et ");
+    }
+
+    if(pouce>0){  
+        if(pouce==1){
+            printf("%d pouce ",pouce);
+        }else{
+            printf("%d pouces ",pouce);
+        }
+    }
+
+  return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM1/exo4.c

@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(){
+    char lettre,alphabet;
+    printf("Entrez une minuscule : ");
+    scanf("%c", &lettre); /* ou lettre = getchar() mais cela reviens au même*/
+        alphabet = 'a';
+        /* Je n'ai trouver aucune solution pour utiliser une boucle for dans cette situation (Désoler...)*/
+        while(alphabet <= 'z'){
+            (alphabet != lettre) && printf("%c", alphabet);
+            (alphabet == lettre) && printf("[%c]", alphabet);
+            alphabet++;
+        }
+        printf("\n");
+
+    return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM1/exo5.c

@@ -0,0 +1,36 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main() {
+    int des[5];
+    int j,i;
+    int maxOccurrences = 0, occurrences;
+
+    for (i=0;i<5;i++) {
+        printf("Jet n°%d : ", i + 1);
+        scanf("%d",&des[i]);
+
+        /*Vérifier que la valeur donner est entre 1 et 6*/
+        if(des[i]<1 || des[i]>6) {
+            printf("Veuillez entrer un entier entre 1 et 6.\n");
+            i--;
+        }
+    }
+
+    /*Compter les occurrences de chaque nombre*/
+    for(i=1;i<=6;i++){
+        occurrences = 0;
+        for(j=0;j<5;j++){
+            if(des[j] == i){
+                occurrences++;
+            }
+        }
+        if(occurrences > maxOccurrences){
+            maxOccurrences = occurrences;
+        }
+    }
+
+    printf("Occurrences maximum : %d\n", maxOccurrences);
+
+    return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM3/exo1/exo1.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void modifierImage(char *nomFichier) {
+	int pixel, largeur, hauteur, intensiteMax;
+	char commentaire[256],enTete[3];
+    FILE *fichier = fopen(nomFichier, "r+");
+
+    if (fichier == NULL) {
+        fprintf(stderr,"Impossible d'ouvrir le fichier !");
+        return;
+    }
+
+    /* Lire l'en-tête */
+    fscanf(fichier, "%2s", enTete);
+
+    if (enTete[0] != 'P' || enTete[1] != '2') {
+        printf("Le fichier n'est pas au format PPM ASCII.\n");
+        fclose(fichier);
+        return;
+    }
+
+    /* Ignorer les commentaires s'il y en a*/
+    while (fgetc(fichier) == '#') {
+        fgets(commentaire, sizeof(commentaire), fichier);
+    }
+
+    /* Lire les dimensions et l'intensité maximale*/
+    fscanf(fichier, "%d %d %d", &largeur, &hauteur, &intensiteMax);
+
+    /* Modifier les pixels du message en blanc*/
+    fseek(fichier, ftell(fichier), SEEK_SET);  /* Revenir au début des données d'image*/
+
+    while ((pixel = fgetc(fichier)) != EOF) {
+        /* Modifier uniquement les pixels correspondant au message (intensité 3)*/
+        if (pixel == 3) {
+            fseek(fichier, -1, SEEK_CUR);
+            fprintf(fichier, "5 ");
+        }
+    }
+
+    fclose(fichier);
+}
+
+int main(void) {
+    char nomFichier[] = "image.pgm";
+    modifierImage(nomFichier);
+    printf("Modification terminée avec succès.\n");
+
+    return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM3/exo2/exo2.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Fonction récursive pour trouver le maximum entre deux entiers*/
+int maxRecursif(int a, int b) {
+    return (a > b) ? a : b;
+}
+
+/* Fonction récursive pour trouver le maximum dans un tableau d'entiers*/
+int maxTableauRecursif(int tableau[], int taille) {
+    if (taille == 1) {
+        return tableau[0];
+    }
+
+    return maxRecursif(tableau[taille - 1], maxTableauRecursif(tableau, taille - 1));
+}
+
+int main(int argc, char* argv[]) {
+    int i,max;
+    int* entiers;
+    if (argc < 2) {
+        perror("Usage: ./a.out <entier1> <entier2> <entierN>\n");
+        return EXIT_FAILURE;
+    }
+
+    /* Allouer de la mémoire pour stocker les entiers fournis en ligne de commande*/
+    entiers = (int*)malloc((argc - 1) * sizeof(int));
+
+    if (entiers == NULL) {
+        perror("Erreur d'allocation mémoire");
+        return EXIT_FAILURE;
+    }
+
+    /* Convertir les arguments en entiers et les stocker dans le tableau*/
+    for (i = 1; i < argc; i++) {
+        entiers[i - 1] = atoi(argv[i]);
+    }
+
+    /* Trouver et afficher le plus grand entier récursivement*/
+    max = maxTableauRecursif(entiers, argc - 1);
+    printf("%d\n", max);
+
+    /* Libérer la mémoire allouée pour le tableau*/
+    free(entiers);
+
+    return EXIT_SUCCESS;
+}

BUT1/CONTROLE/CM3/exo3/exo3.c

@@ -0,0 +1,98 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Structure pour un nœud dans la liste chaînée*/
+typedef struct Noeud {
+    int digit;
+    struct Noeud* suivant;
+} Noeud;
+
+/* Fonction pour convertir une représentation décimale en liste chaînée*/
+Noeud* convertirListeChainee(char* nombre) {
+    Noeud* liste = NULL;
+    int i;
+    int length = strlen(nombre);
+
+    for (i = length - 1; i >= 0; i--) {
+        Noeud* nouveauNoeud = (Noeud*)malloc(sizeof(Noeud));
+        nouveauNoeud->digit = nombre[i] - '0';
+        nouveauNoeud->suivant = liste;
+        liste = nouveauNoeud;
+    }
+
+    return liste;
+}
+
+/* Fonction pour afficher une liste chaînée*/
+void AfficherListe(Noeud* liste) {
+    while (liste != NULL) {
+        printf("%d", liste->digit);
+        liste = liste->suivant;
+    }
+    printf("\n");
+}
+
+/* Fonction pour additionner deux listes chaînées*/
+Noeud* ajouterAListe(Noeud* num1, Noeud* num2) {
+    Noeud* resultat = NULL;
+    Noeud* actuel = NULL;
+    Noeud* nouveauNoeud = NULL;
+    int retenue = 0;
+    int somme;
+
+    while (num1 != NULL || num2 != NULL || retenue != 0) {
+        somme = retenue;
+
+        if (num1 != NULL) {
+            somme += num1->digit;
+            num1 = num1->suivant;
+        }
+
+        if (num2 != NULL) {
+            somme += num2->digit;
+            num2 = num2->suivant;
+        }
+
+        nouveauNoeud = (Noeud*)malloc(sizeof(Noeud));
+        nouveauNoeud->digit = somme % 10;
+        nouveauNoeud->suivant = NULL;
+
+        retenue = somme / 10;
+
+        if (resultat == NULL) {
+            resultat = nouveauNoeud;
+            actuel = resultat;
+        } else {
+            actuel->suivant = nouveauNoeud;
+            actuel = nouveauNoeud;
+        }
+    }
+
+    return resultat;
+}
+
+int main(int argc, char* argv[]) {
+	Noeud* num1 = NULL;
+	Noeud* num2 = NULL;
+	Noeud* somme = NULL;
+	char* nombre1;
+	char* nombre2;
+	 if (argc != 3) {
+        perror("Usage: %s <nombre1> <nombre2>\n");
+        return EXIT_FAILURE;
+    }
+
+	nombre1 = argv[1];
+    nombre2 = argv[2];
+
+
+    num1 = convertirListeChainee(nombre1);
+    num2 = convertirListeChainee(nombre2);
+	somme = ajouterAListe(num1, num2);
+
+
+    AfficherListe(somme);
+
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Adresses/alphabet.c

@@ -0,0 +1,16 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+    char min, maj;
+    char *p = NULL;
+
+    for (min = 'a', maj = 'A'; maj <= 'Z'; min++, maj++)
+    {
+        p = (p == &min) ? &maj : &min;
+        putchar(*p);
+    }
+    putchar('\n');
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Adresses/cartographie.c

@@ -0,0 +1,58 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main(void)
+{
+
+  float fl = 0;
+  double dbl = 0;
+  long double ldbl = 0;
+  char caractere = 0;
+  short int shint = 0;
+  int entier = 0;
+  long long unsigned int llunsint = 0;
+
+  printf("La valeur du float vaut : %f\n", fl);
+  printf("L'adresse de la variable float est : %p\n", &fl);
+
+  printf("La valeur du double vaut : %lf\n", dbl);
+  printf("L'adresse de la variable double est : %p\n", &dbl);
+
+  printf("La valeur du long double vaut : %Lf\n", ldbl);
+  printf("L'adresse de la variable long double est : %p\n", &ldbl);
+
+  printf("La valeur du char vaut : %c\n", caractere);
+  printf("L'adresse de la variable char est : %p\n", &caractere);
+
+  printf("La valeur du short int vaut : %hd\n", shint);
+  printf("L'adresse de la variable short int est : %p\n", &shint);
+
+  printf("La valeur du int vaut : %d\n", entier);
+  printf("L'adresse de la variable int  est : %p\n", &entier);
+
+  printf("La valeur du long long unsigned int vaut : %llu\n", llunsint);
+  printf("L'adresse de la variable long long unsigned int  est : %p\n", &llunsint);
+
+  /*
+  140723563022365 char
+140723563022366 short int
+140723563022368 float
+140723563022372 int
+140723563022376 double
+140723563022384 long double
+
+
+0x7ffe34119615 char 8 bits
+0x7ffe34119616 short int 16 bits
+0x7ffe34119618 float 32 bits
+0x7ffe3411961c int 32 bits
+0x7ffe34119620 double 64 bits
+0x7ffe34119628 long long unsigned int 64 bits
+0x7ffe34119630 long double 64 bits
+
+// chaque variable est attribuée à un espace précis mais l'emplacement de la mémoire est choisi aléatoirement
+
+
+  */
+}

BUT1/DEV1.1/Adresses/conversion.c

@@ -0,0 +1,10 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main(void) {
+  long long int n = 4614256656552045848LL;
+  double* p = (double*) &n;
+  printf("π = %f\n", *p);
+  return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Adresses/etapes.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void) {
+  int a = 1, b = 2, c = 3;
+  int *p, *q;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*p);
+  p=&a;
+  q=&c;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  *p=(*q)++;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  p=q;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  q=&b;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  *p-=*q;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  ++*q;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  *p*=*q;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  a=++*q**p;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  p=&a;
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  *q=*p/(*q);
+  printf("%d,%d,%d,%d,%d\n",a,b,c,*p,*q);
+  return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Adresses/mortvivant.c

@@ -0,0 +1,25 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+ 
+int main(void) {
+  int* p;
+ 
+  if(time(NULL)%2) {
+    int x = 59;
+    p = &x;
+  } else {
+    int y = 31;
+    p = &y;
+  }
+  /* fragment inactif
+  printf("x=%d\n", x);
+  printf("y=%d\n", y);
+  */
+  
+  printf("%d\n", *p);
+  return EXIT_SUCCESS;
+}
+
+// j'ai compris le fonctionnement du programme : time(NULL) correspond à l'horloge et au temps actuel, la valeur change donc constamment.  Si la division renvoie un reste, on éxécute le if, si la division ne renvoie pas de reste, on éxécute le else.

BUT1/DEV1.1/Allocation_Dynamique/1.c

@@ -0,0 +1,33 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void){
+
+    /*avec allocation dynamique*/
+    int nombre_de_reels,i,j,b=0;
+    double *tab_reel = NULL;
+    printf("Combien de valeur souhaité vous ajouter à votre tableau ? : ");
+    scanf("%d",&nombre_de_reels);
+    tab_reel = (double*) malloc(nombre_de_reels*sizeof(double));
+    
+    for(i=0;i<nombre_de_reels;i++){
+        printf("Veuillez entrer la valeur n°%d :",i+1);
+        scanf("%lf",&tab_reel[i]);
+    }
+    for(i=0;i<nombre_de_reels;i++){
+        for(j=0;j<nombre_de_reels && b==0;j++){
+            if(tab_reel[i]==tab_reel[j] && i != j){
+                b=1;            
+            }
+            
+        }
+        if(b==0){
+            printf("%lf ",tab_reel[i]);
+        }
+        b=0;
+    }
+
+    /* Oublie pas les free ! On vise la perfection !*/
+    free(tab_reel);
+
+}

BUT1/DEV1.1/Allocation_Dynamique/2.c

@@ -0,0 +1,11 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+char inverse(const char* s){
+    
+    return EXIT_SUCCESS;
+}
+
+int main(void){
+
+}

BUT1/DEV1.1/Bibliotheque_Math/arctique.c

@@ -0,0 +1,22 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main (void)
+{
+  double R;
+  double fi;
+  double x;
+  double y;
+
+  printf("Entrez les coordonnées correspondant au rayon sur le plan :\n", R);
+  scanf("%lf" , &R); //R est le rayon
+  printf("Entrez les coordonnées correspondant à fi sur le plan :\n", fi);
+  scanf("%lf" , &fi); //fi est l'angle par rapport à l'axe des abssices
+  x=R*cos(fi); // on convertit les coordonnées polaires en cartésien ici
+  y=R*sin(fi);
+  
+  printf("Les coordonnées en x sont : %lf\n" , x);
+  printf("Les coordonnées en y sont : %lf\n" , y);
+  return EXIT_SUCCESS; //on peut mettre return 0; aussi il me semble
+}

BUT1/DEV1.1/Bibliotheque_Math/chiffres.c

@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main (void)
+{
+
+  double nombre=0;
+
+  printf("Entrez un réel :\n");
+  scanf("%lf", &nombre);
+  printf("Le nombre réel est : %lf\n" , nombre);
+  int x = (int) trunc(nombre);
+  int y = (int) trunc(nombre*10);
+  printf("Le  chiffre des unités est : %d\n" , x%10);
+  printf("Le chiffre des dixièmes  est : %d\n" , y%10);
+  return 0;
+}

BUT1/DEV1.1/Bibliotheque_Math/distance.c

@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main (void)
+{
+
+  double x1, x2, y1, y2, distance;
+
+  printf("Saisissez les coordonnées x du plan:\n");
+  scanf("%lf", &x1);
+  printf("Saisissez les coordonnées x du plan :\n");
+  scanf("%lf", &x2);
+  printf("Saisissez les coordonnées y du plan :\n");
+  scanf("%lf", &y1);
+  printf("Saisissez les coordonnées y du plan :\n");
+  scanf("%lf", &y2);
+
+  distance = sqrt((y1-x1)*(y1-x1) + (y2-x2)*(y2-x2));
+  printf("La Distance entre (%.2lf,%.2lf) et (%.2lf,%.2lf) = %f\n", x1, x2, y1, y2, distance);
+
+  return 0;
+}

BUT1/DEV1.1/Bibliotheque_Math/dureedevol.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include<math.h>
+int main(void) {
+  double vitesse_avion;
+  double vitesse_vent;
+  double distance;
+  double duree;
+  printf("vitesse de l'avion en km/h : ");
+  scanf("%lf",&vitesse_avion);
+  printf("vitesse du vent en km/h : ");
+  scanf("%lf",&vitesse_vent);
+  printf("distance du trajet en km : ");
+  scanf("%lf",&distance);
+  duree = distance / vitesse_avion;
+  printf("durée du vol en heures : ");
+  printf("%lf\n", duree);
+  return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles/bornes.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int valeurMax;
+    int valeurMin;
+    int valeurActuelle;
+
+    printf("Saisissez un entier supérieur ou égal à 0 :\n");
+    printf("Ou saisissez -1 pour arrêter le programme : ");
+    scanf("%d", &valeurActuelle);
+    valeurMax = valeurActuelle;
+    valeurMin = valeurActuelle;
+
+    if (valeurActuelle == -1)
+    {
+        printf("Vous n'avez saisi aucune valeur");
+        return EXIT_SUCCESS;
+    }
+    while (valeurActuelle != -1)
+    {
+        if (valeurActuelle < 0)
+        {
+            printf("Merci de saisir un entier supérieur ou égale à 0");
+            return EXIT_SUCCESS;
+        }
+        if (valeurActuelle > valeurMax)
+        {
+            valeurMax = valeurActuelle;
+        }
+        if (valeurActuelle < valeurMin)
+        {
+            valeurMin = valeurActuelle;
+        }
+        printf("Saisir valeur la suivante (-1 = stop) : \n");
+        scanf("%d", &valeurActuelle);
+    }
+    printf("Valeur minimale saisie : ");
+    printf("%d\n", valeurMin);
+    printf("Valeur maximale saisie : ");
+    printf("%d\n", valeurMax);
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles/division.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int numerateur = 0;
+    int denominateur = 0;
+    int quotient = 0;
+    printf("Saisissez un entier : ");
+    scanf("%d", &numerateur);
+    printf("Saisissez un entier strictement positif : ");
+    scanf("%d", &denominateur);
+    if (numerateur >= 0)
+    {
+        while (numerateur >= denominateur)
+        {
+            numerateur -= denominateur;
+            quotient += 1;
+        }
+    }
+    else
+    {
+        while (numerateur < 0)
+        {
+            numerateur += denominateur;
+            quotient -= 1;
+        }
+    }
+    printf("%d", quotient * denominateur + numerateur);
+    printf(" = ");
+    printf("%d", quotient);
+    printf(" x ");
+    printf("%d", denominateur);
+    printf(" + ");
+    printf("%d\n", numerateur);
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles/filtrage.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    double note_du_bac = 0;
+    do
+    {
+        printf("Saisissez une note de bac comprise entre 0 et 10 :  \n");
+        scanf("%lf", &note_du_bac);
+
+    } while (note_du_bac >= 10);
+
+    printf("Votre notre de bac est comprise entre 0 et 10.\n");
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles/s#U00e9quencedowhile.c

@@ -0,0 +1,30 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(void)
+{
+    int nombre1 = 0;
+    int nombre2 = 0;
+
+    printf("Saisissez un nombre entier :\n");
+    scanf("%d", &nombre1);
+
+    printf("Saisissez le second nombre :\n");
+    scanf(" %d", &nombre2);
+
+    if (nombre1 > nombre2)
+    {
+
+        printf("Erreur : le premier nombre est supérieur au second. \n");
+    }
+    else
+    {
+
+        nombre1 = nombre1 + 1;
+        do
+        {
+
+            printf("%d\n", nombre1);
+            nombre1 = nombre1 + 1;
+        } while (nombre1 < nombre2);
+    }
+}

BUT1/DEV1.1/Boucles/s#U00e9quencefor.c

@@ -0,0 +1,29 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(void)
+{
+    int nombre1 = 0;
+    int nombre2 = 0;
+
+    printf("Saisissez un nombre entier :\n");
+    scanf("%d", &nombre1);
+
+    printf("Saisissez le second nombre :\n");
+    scanf(" %d", &nombre2);
+
+    if (nombre1 > nombre2)
+    {
+
+        printf("Erreur : le premier nombre est supérieur au second. \n");
+    }
+    else
+    {
+
+        for (int i = nombre1; i < nombre2; i++)
+
+        {
+
+            printf("%d\n", i);
+        }
+    }
+}

BUT1/DEV1.1/Boucles/s#U00e9quencewhile.c

@@ -0,0 +1,30 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(void)
+{
+    int nombre1 = 0;
+    int nombre2 = 0;
+
+    printf("Saisissez un nombre entier :\n");
+    scanf("%d", &nombre1);
+
+    printf("Saisissez le second nombre :\n");
+    scanf(" %d", &nombre2);
+
+    if (nombre1 > nombre2)
+    {
+
+        printf("Erreur : le premier nombre est supérieur au second. \n");
+    }
+    else
+    {
+
+        while (nombre1 < nombre2-1)
+
+        {
+            nombre1++;
+            
+            printf("%d\n", nombre1);
+        }
+    }
+}

BUT1/DEV1.1/Boucles/table.c

@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(void)
+{
+
+    int nombre1 = 0;
+
+    printf("Saisissez un nombre entier \n");
+    scanf("%d", &nombre1);
+
+    for (int i = 1; i <= 10; i++)
+    {
+        printf("%d * %4d = %6d\n", nombre1, i, nombre1 * i);
+    }
+}

BUT1/DEV1.1/Boucles/tables.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int table;
+    printf("Choisissez la table de multiplication que vous voulez afficher :\n");
+    printf("Ou saisissez -1 pour stopper le programme : ");
+    scanf("%d", &table);
+    while (table != -1)
+    {
+        int i;
+        for (i = 0; i <= 10; i += 1)
+        {
+            printf("%d", i);
+            printf(" x ");
+            printf("%d", table);
+            printf(" = ");
+            printf("%d\n", i * table);
+        }
+        printf("Table à afficher (-1 = stop) : ");
+        scanf("%d", &table);
+    }
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_encore/figures.c

@@ -0,0 +1,47 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+void triangle(){
+    
+}
+int main(void) {
+    int hauteur_figure,ligne,colonne;
+    char choix_utilisateur;
+    while (choix_utilisateur!='q'){
+        printf("t) Triangle\n");
+        printf("c) Carré\n");
+        printf("q) Quitter\n");
+        printf("Votre choix ? ");
+        choix_utilisateur = getchar();
+        printf("\n");
+        if ((choix_utilisateur=='t')||(choix_utilisateur=='c')){
+            printf("Hauteur ? ");
+            scanf("%d", &hauteur_figure);
+            printf("\n");
+            for (ligne=1;ligne<=hauteur_figure;ligne+=1){
+                if (choix_utilisateur=='t'){
+                    int caractere;
+                    for (caractere=1;caractere<=ligne;caractere+=1){
+                        printf("*");
+                    }
+                    printf("\n");
+                }
+                if (choix_utilisateur=='c'){
+                    for (colonne=1;colonne<=hauteur_figure;colonne+=1){
+                        if ((colonne==1)||(ligne==1)||(colonne==hauteur_figure)||(ligne==hauteur_figure)){
+                            printf("*");
+                        }   else{
+                            printf(" ");
+                        }
+                    }
+                    printf("\n");
+                }
+            }
+            printf("_____________________\n");
+            choix_utilisateur = getchar();
+        }
+    }
+    printf("Au revoir...\n");
+        
+  return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_encore/figures2.c

@@ -0,0 +1,52 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+
+int main(void) {
+    /*X et Y c'est juste pour faire tourner les boucles => un compteur 
+    le h c'est hauteur
+    le c c'est pour faire tourner une boule infini*/
+    int x,y,h,c;
+    char choix;
+    printf("t) Triangle\nc) Carré\nq) Quitter\nVotre choix : ");
+    scanf("%c",&choix);
+    for(c=0;c!=-1;c++){
+        if(choix == 't'){
+            printf("hauteur ? ");
+            scanf("%d",&h);
+            for(x=0;x<h;x++){
+                for(y=0;y<x;y++){
+                    printf("*");
+                }
+                printf("\n");
+            }
+            printf("\n__________\n");
+        }
+        if(choix=='c'){
+            printf("hauteur ? ");
+            scanf("%d",&h);
+            for(x=0;x<h;x++){
+                printf("*");
+            }
+            for(x=2;x<h;x++){
+                printf("\n*");
+                for(y=0;y<(h-2);y++){
+                    printf(" ");
+                }
+                printf("*");
+            }
+            printf("\n");
+            for(x=0;x<h;x++){
+                printf("*");
+            }
+            printf("\n__________\n");
+        }
+        if(choix=='q'){
+            printf("au revoir...\n");
+            return EXIT_SUCCESS;
+        }
+        printf("t) Triangle\nc) Carré\nq) Quitter\nVotre choix : ");
+        scanf(" %c",&choix);
+    }
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_encore/sapin.c

@@ -0,0 +1,26 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void)
+{
+    int hauteur = 0;
+
+    printf("Hauteur ? ");
+    scanf("%d", &hauteur);
+
+    for (int i = 0; i < hauteur; i++)
+    {
+        int espace = hauteur - i;
+        printf("%*c", espace, '*');
+
+        if (i != 0)
+        {
+            for (int j = 0; j < i * 2; j++)
+            {
+                printf("*");
+            }
+        }
+
+        printf("\n");
+    }
+}

BUT1/DEV1.1/Boucles_suite/devinette.c

@@ -0,0 +1,43 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+int main(void)
+{
+
+  int generate_random(int min, int max){
+    return min + rand() / (RAND_MAX / (max - min + 1)+1);
+
+    void main(){
+      
+      srand(time(NULL));
+
+      int random_number = generate_random(0,100);
+      int num=0;
+
+      
+
+
+
+    for(int i = 0; i<5; i++){
+    printf("Devinez mon nombre entre  1 et 100 \n");
+    scanf("%d", &num);
+
+    if(random_number==num){
+
+      printf("Vous avez trouvez mon nombre, gagné !\n");
+      break;
+    }
+
+    else if(num>random_number){
+
+      printf("Le nombre est plus petit\n");
+    }
+    else
+      {
+	printf("Le nombre est plus grand\n");
+      }
+    }
+    printf("Le nombre était %d\n", random_number);
+    }
+  }
+}

BUT1/DEV1.1/Boucles_suite/facteurs.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int nombreSaisi;
+    int nombre = nombreSaisi;
+    int premier;
+    printf("Saisissez un entier naturel : ");
+    scanf("%d", &nombreSaisi);
+    printf("%d", nombreSaisi);
+    printf(" = ");
+    for (premier = 2; (premier <= nombreSaisi) || (nombreSaisi != 1); premier += 1)
+    {
+        int diviseur;
+        for (diviseur = 1; (premier % diviseur != 0) && (diviseur == 1); diviseur += 1)
+        {
+            if (premier - 1 == diviseur)
+            {
+                int occurence;
+                for (occurence = 0; nombreSaisi % premier == 0; occurence += 1)
+                {
+                    nombreSaisi = nombreSaisi / premier;
+                }
+                printf(" x ");
+                printf("%d", premier);
+                printf("^");
+                printf("%d", occurence);
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_suite/figures.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int nombreSaisi;
+    int carre1;
+    int carre2;
+    int carre3;
+    int carre4;
+    printf("Saisissez un entier naturel : ");
+    scanf("%d", &nombreSaisi);
+    for (carre1 = 0; carre1 * carre1 * 4 < nombreSaisi; carre1 += 1)
+    {
+    }
+    for (; carre1 * carre1 <= nombreSaisi; carre1 += 1)
+    {
+        for (carre2 = 0; carre1 * carre1 + carre2 * carre2 * 3 < nombreSaisi; carre2 += 1)
+        {
+        }
+        for (; carre1 * carre1 + carre2 * carre2 <= nombreSaisi; carre2 += 1)
+        {
+            for (carre3 = 0; carre1 * carre1 + carre2 * carre2 + carre3 * carre3 * 2 < nombreSaisi; carre3 += 1)
+            {
+            }
+            for (; carre1 * carre1 + carre2 * carre2 + carre3 * carre3 <= nombreSaisi; carre3 += 1)
+            {
+                for (carre4 = 0; carre1 * carre1 + carre2 * carre2 + carre3 * carre3 + carre4 * carre4 < nombreSaisi; carre4 += 1)
+                {
+                }
+                if (carre1 * carre1 + carre2 * carre2 + carre3 * carre3 + carre4 * carre4 == nombreSaisi)
+                {
+                    printf("%d", nombreSaisi);
+                    printf(" = ");
+                    printf("%d", carre1);
+                    printf("^2 + ");
+                    printf("%d", carre2);
+                    printf("^2 +");
+                    printf("%d", carre3);
+                    printf("^2 + ");
+                    printf("%d", carre4);
+                    printf("^2\n");
+                }
+            }
+        }
+    }
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_suite/primarite.c

@@ -0,0 +1,24 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+int main (void){
+
+  int entier_utilisateur=0;
+  int i=0;
+
+  printf("Saisissez un nombre entier : \n");
+  scanf("%d" , &entier_utilisateur);
+
+  for(i=entier_utilisateur-1;i>1;i-=1){
+
+    if(entier_utilisateur%i==0){
+      printf("Ce nombre n'est pas premier\n");
+    }
+  }
+    if(entier_utilisateur==1){
+      printf("Ce nombre n'est pas premier\n");
+    }
+    printf("Ce nombre est premier\n");
+    return EXIT_SUCCESS;
+      }
+  

BUT1/DEV1.1/Boucles_suite/progression.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int i;
+    int n0 = 0;
+    int n1 = 1;
+    int n;
+    printf("Saisissez un entier : ");
+    scanf("%d", &n);
+    for (i = 0; i < n; i += 1)
+    {
+        if (i % 2 == 0)
+        {
+            n0 = n0 + n1;
+        }
+        else
+        {
+            n1 = n0 + n1;
+        }
+    }
+    if (n % 2 == 0)
+    {
+        printf("%d\n", n0);
+    }
+    else
+    {
+        printf("%d\n", n1);
+    }
+
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/Boucles_suite/tables.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+    int taille;
+    int x;
+    printf("Saisissez la taille de la table de multiplication que vous souhaitez : ");
+    scanf("%d", &taille);
+    for (x = -2; x <= taille; x += 1)
+    {
+        int y;
+        printf("\n");
+        for (y = -2; y <= taille; y += 1)
+        {
+            if (x == -2)
+            {
+                if (y == -2)
+                {
+                    printf(" X ");
+                }
+                if (y == -1)
+                {
+                    printf(" | ");
+                }
+                if (y >= 0)
+                {
+                    printf("%3d", y);
+                }
+            }
+            if (x == -1)
+            {
+                if (y == -2)
+                {
+                    printf("---");
+                }
+                if (y == -1)
+                {
+                    printf("-+-");
+                }
+                if (y >= 0)
+                {
+                    printf("---");
+                }
+            }
+            if (x >= 0)
+            {
+                if (y == -2)
+                {
+                    printf("%3d", x);
+                }
+                if (y == -1)
+                {
+                    printf(" | ");
+                }
+                if (y >= 0)
+                {
+                    printf("%3d", x * y);
+                }
+            }
+        }
+    }
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/CM2 2022/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "linux-gcc-x64",
+      "includePath": [
+        "${workspaceFolder}/**"
+      ],
+      "compilerPath": "/usr/bin/gcc",
+      "cStandard": "${default}",
+      "cppStandard": "${default}",
+      "intelliSenseMode": "linux-gcc-x64",
+      "compilerArgs": [
+        ""
+      ]
+    }
+  ],
+  "version": 4
+}

BUT1/DEV1.1/CM2 2022/.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "cppdbg",
+      "request": "launch",
+      "args": [],
+      "stopAtEntry": false,
+      "externalConsole": false,
+      "cwd": "/export/home/an23/stiti/DEV/DEV1.1/CM2 2022",
+      "program": "/export/home/an23/stiti/DEV/DEV1.1/CM2 2022/build/Debug/outDebug",
+      "MIMode": "gdb",
+      "miDebuggerPath": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
+    }
+  ]
+}

BUT1/DEV1.1/CM2 2022/.vscode/settings.json

@@ -0,0 +1,37 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wconversion",
+    "-Wnull-dereference",
+    "-Wsign-conversion"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false
+}

BUT1/DEV1.1/CM2 2022/1/Makefile

@@ -0,0 +1,45 @@
+### VARIABLES ###
+ 
+CC = gcc
+CFLAGS = -ansi \
+         -pedantic
+EXE = repetition_dans_tableaux
+OFILES = main.o \
+         repetition.o
+ 
+### BUT PAR DEFAUT ###
+ 
+but : ${EXE}
+ 
+### REGLES ESSENTIELLES ###
+
+programme : repetition.o main.o
+	$(CC) $(CFLAGS) -o programme repetition.o main.o
+
+repetition.o : repetition.c repetition.h
+	$(CC) $(CFLAGS) -c repetition.c
+
+main.o : main.c repetition.h
+	$(CC) $(CFLAGS) -c main.c
+ 
+
+ 
+${EXE} : ${OFILES}
+	$(CC) $(CFLAGS) -o ${EXE} ${OFILES}
+ 
+### REGLES OPTIONNELLES ###
+ 
+clean :
+	-rm -f ${OFILES}
+ 
+mrproper : clean but
+ 
+### BUTS FACTICES ###
+ 
+.PHONY : but clean mrproper
+ 
+### FIN ###
+
+
+
+

BUT1/DEV1.1/CM2 2022/1/programme.c

@@ -0,0 +1,20 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "repetition.h"
+
+
+int main(int argc, char* argv[]){
+    int i;
+    long* tab;
+    tab = (long*) malloc(argc*sizeof(long));
+
+    for(i=1;i<argc;i++){
+        tab[i-1] = strtol(argv[i],NULL,10);
+    }
+    if(repetition(tab,argc-1)==0){
+        printf("Les valeurs sont différentes\n");
+    }else{
+        printf("Les valeurs sont identiques\n");
+    }
+    return EXIT_SUCCESS;
+}

BUT1/DEV1.1/CM2 2022/1/repetition.c

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int repetition(long tab[],int taille){
+    int i;
+    for(i=0;i<taille-1;i++){
+        if(tab[i]!=tab[i+1]){
+            return 0;
+        }
+    }
+    return 1;
+}

BUT1/DEV1.1/CM2 2022/1/repetition.h

@@ -0,0 +1,7 @@
+#ifndef REPETITION_H
+#define REPETITION_H
+
+int repetition(long tab[],int taille);
+
+#endif /* REPETITION_H */
+