cours_4.md

title: "Introduction aux algorithmes"
date: "2023-10-10"
string = tableau + char + magie noire
char c = 'A';
char c = 65;
char *str  = "HELLO !";
char str[] = "HELLO !";
char name[5];
name[0] = 'P';  // = 70;
name[1] = 'a';  // = 97;
name[2] = 'u';  // = 117;
name[3] = 'l';  // = 108;
name[4] = '\0'; // = 0;
char name[] = {'P', 'a', 'u', 'l', '\0'};
char name[5] = "Paul";
char name[] = "Paul";
char name[100] = "Paul is not 100 characters long.";
// longueur de la chaîne (sans le \0)
size_t strlen(char *str);
// copie jusqu'à un \0
char *strcpy(char *dest, const char *src);
 // copie len char
char *strncpy(char *dest, const char *src, size_t len);
// compare len chars
int strncmp(char *str1, char *str2, size_t len);
// compare jusqu'à un \0
int strcmp(char *str1, char *str2);
int main() { // pseudo C
    tri(mot1);
    tri(mot2);
    if egalite(mot1, mot2) {
        // anagrammes
    } else {
        // pas anagrammes
    }
}
while (first_index < last_index {
    if (mot[first_index] != mot [last_index]) {
        return false;
    }
    first_index += 1;
    last_index -= 1;
}
return true;
mot_tmp = revert(mot);
return mot == mot_tmp;
#include <stdio.h>
#include <stdbool.h>
#define SIZE 51
int main() {
   bool tab[SIZE];
   for (int i=0;i<SIZE;i++) {
      tab[i] = true;
   }
   for (int i = 2; i < SIZE; i++) {
      if (tab[i]) {
         printf("%d ", i);
         int j = i;
         while (j < SIZE) {
            j += i;
            tab[j] = false;
         }
      }
   }
   printf("\n");
}
int tab[3][4]; // déclaration d'un tableau 4x3
tab[2][1]; // accès à la case 2, 1
tab[2][1] = 14; // assignation de 14 à la position 2, 1
#define NX 50
#define NY 100
int tab[NX][NY];
for (int i = 0; i < NX; ++i) {
    for (int j = 0; j < NY; ++j) {
        tab[i][j] = rand() % 256; // 256 niveaux de gris
    }
}
for (int i = 0; i < NX; ++i) {
    for (int j = 0; j < NY; ++j) {
        printf("%d ", tab[i][j]);
    }
    printf("\n");
}
int tab[3][2] = { {1, 2}, {3, 4}, {5, 6} };
printf("%d\n", tab[2][1]);  // affiche?
printf("%d\n", tab[10][9]); // affiche?
printf("%d\n", tab[3][1]);  // affiche?
enum days {
    monday, tuesday, wednesday,
    thursday, friday, saturday, sunday
};
enum days {
    monday = 2, tuesday = 8, wednesday = -2,
    thursday = 1, friday = 3, saturday = 12, sunday = 9
};
enum days d = monday;
(d + 2) == tuesday + tuesday; // true
enum days d = monday;
switch (d) {
    case monday:
        // trucs
        break;
    case tuesday:
        printf("0 ou 1\n");
        break;
}
11 / 8 = 1, 11 % 8 = 3
3  / 4 = 0,  3 % 4 = 3
3  / 2 = 1,  3 % 2 = 1
1  / 1 = 1,  1 % 1 = 0
num = 247
while (2^N < num) {
    N += 1
}
while (N >= 0) {
    bit = num / 2^N
    num = num % 2^N
    N += 1
}
   1101         8+4+0+1 = 13
+  0110    +    0+4+2+0 =  6
-------    -----------------
  10011      16+0+0+2+1 = 19
     1101                13
*    0110    *            6
---------    --------------
     0000                78
    11010
   110100
+ 0000000
---------    --------------
  1001110    64+0+0+8+4+2+0
     0110
*    0010
---------
     0000
+   01100
---------
    01100
00000010: +2
10000010: -2
  00000010              2
+ 10000100           + -4
----------           ----
  10000110 = -6  !=    -2
     4 =  00000100
            ________
    -4 =>   00000100

            11111011
          + 00000001
          ----------
            11111100
+0 = 00000000
-0 = 11111111 + 00000001 = 100000000 => 00000000
  00000010            2
+ 11111100        +  -4
----------        -----
  11111110           -2
11111110 => 00000001 + 00000001 = 00000010 = 2.
01111111 =>  127
10000000 => -128 // par définition
int num1 = 1, denom1 = 2;
int num2 = 1, denom2 = 3;
int num3 = num1 * denom2 + num2 * denom1;
int denom3 = denom1 * denom2;
struct fraction { // déclaration du type
    int32_t num, denom;
}

struct fraction frac; // déclaration de frac
typedef unsinged int uint;
typedef struct fraction fraction_t;
typedef struct fraction {
    int32_t num, denom;
} fraction_t;
fraction_t frac = {1, -2}; // num = 1, denom = -2
fraction_t frac = {.denom = 1, .num = -2};
fraction_t frac = {.denom = 1}; // argl! .num non initialisé
fraction_t frac2 = frac; // copie
fraction_t *frac; // on crée un pointeur
frac->num = 1;    // seg fault...
frac->denom = -1; // mémoire pas allouée.
void fraction_init(fraction_t *frac,
                  int32_t re, int32_t im)
{
    // frac a déjà été allouée
    frac->num   = frac;
    frac->denom = denom;
}
int main() {
    fraction_t frac; // on alloue une fraction
    fraction_init(&frac, 2, -1); // on l'initialise
}
fraction_t fraction_create(int32_t re, int32_t im) {
    fraction_t frac;
    frac.num = re;
    frac.denom = im;
    return frac;
}
int main() {
    // on crée une fraction et on l'initialise
    // en copiant la fraction créé par fraction_create
    // deux allocation et une copie
    fraction_t frac = fraction_create(2, -1);
}