[8.5] Da love machine !

Vous allez écrire ici un programme qui calcule la compatibilité entre deux prénoms. Suivez les instructions suivantes pour remplacer les TODO du programme ci-dessous.

$./8.5_da_love_machine/math.png$

Algorithme

Vous croyez avoir trouvé votre âme sœur, mais vous voulez en avoir le c♥eur net ? Vous ne serez pas déçu d’être venus aujourd’hui, car vous allez apprendre le secret d’un couple heureux. J’ai nommé, la numérologie des prénoms.

« Parce que vos prénoms en disent long sur vos personnalités, découvrez s’ils sont fait l’un pour l’autre... » (Elle.fr)

L’algorithme infaillible pour calculer la compatibilité de deux prénoms que nous avons sélectionné (issu d’un site de référence) est le suivant :

Étant donné deux prénoms (tristan et yseult), on remplace chaque lettre par un chiffre entre 1 et 9, qui correspond au tableau suivant :

1 2 3 4 5 6 7 8 9

a b c d e f g h i

j k l m n o p q r

s t u v w x y z

Vous remarquerez donc que la valeur d’une lettre est sa position dans l’alphabet (en commençant à compter à partir de zéro !), modulo 9, plus 1.

Par exemple, k est la lettre 10 de l’alphabet 10 % 9 + 1 = 2 et a est la lettre 0 de l’alphabet 0 % 9 + 1 = 1.

tristan ⮕ {2, 9, 9, 1, 2, 1, 5}

yseult ⮕ {7, 1, 5, 3, 3, 2}
On additionne ensuite les chiffres du prénom deux par deux, en laissant le dernier intact s’il y a un nombre impair :

(tristan) {2, 9, 9, 1, 2, 1, 5} ⮕ {11, 10, 3, 5}

(yseult) {7, 1, 5, 3, 3, 2} ⮕ {8, 8, 5}
On transforme chaque nombre au-dessus de 9 en un chiffre de 1 à 9 en additionnant les chiffres qui le composent :

Par exemple, 11 donnera 2.

(tristan) {11, 10, 3, 5} ⮕ {2, 1, 3, 5}

(yseult) {8, 8, 5} ⮕ {8, 8, 5}
On additionne deux par deux les chiffres qui restent :

(tristan) {2, 1, 3, 5} ⮕ {3, 8}

(yseult) {8, 8, 5} ⮕ {16, 5}
On transforme à nouveau les nombres supérieurs à 9 en chiffres de 1 à 9 :

(tristan) {3, 8} ⮕ {3, 8}

(yseult) {16, 5} ⮕ {7, 5}
On additionne à nouveau les chiffres deux par deux :

(tristan) {3, 8} ⮕ {11}

(yseult) {7, 5} ⮕ {12}
On transforme les nombres supérieurs à 9 en chiffres :

(tristan) {11} ⮕ {2}

(yseult) {12} ⮕ {3}
Quand on n’a plus qu’un seul chiffre pour chaque prénom, on calcule la compatibilité entre les deux. Plus la différence entre eux est grande, moins il y a de compatibilité :

Différence 0 1 2 3 4 5 6 7 8

Compatibilité 100% 87.5% 75% 62.5% 50% 37.5% 25% 12.5% 0%

On peut donc dire avec certitude que la compatibilité amoureuse entre Tristan et Yseult est de 87.5%.

Décomposition en sous-problèmes

La fonction de plus haut niveau que vous devrez implémenter est la fonction "compatibility" définie dans le code ci-dessous. Mais pour ce faire, vous devrez créer d’autres fonctions.

Étapes à suivre

Pour implémenter les fonctions nécessaires, vous devrez suivre les étapes suivantes.

Les spécifications de chaque fonction sont à chaque fois définies dans le code ci-dessous.

Implémentation de la fonction "`compatibility`"

En une dizaine de lignes, vous allez :

Calculer le score du prenom1
Calculer le score du prenom2
Calculer la différence (en valeur absolue) entre les deux
Calculer la compatibilité en multipliant la différence par 12.5 et soustraire le total de 100.

Implémentation de la fonction "`score`"

Cette fonction, un peu difficile, est déjà implémentée pour vous. Elle utilise toutefois des fonctions que vous devrez implémenter vous-mêmes :

"str_length"
"add_two_digits"
"numbers_to_digits"

Implémentation de la fonction "`str_length`"

Cette fonction permet de calculer la taille d’une chaine de caractères passée en argument. Comme on l’a vu, on sait une chose sur les chaines de caractères : elles se terminent nécessairement par un ’\0’. Donc il vous suffit de la parcourir comme un tableau, jusqu’à tomber sur ce caractère, et vous pouvez obtenir facilement la taille.

Implémentation de la fonction "`add_two_digits`"

Cette fonction permet d’additionner deux par deux les chiffres passés en arguments. Il n’y a pas de type de retour : le résultat est copié au fur et à mesure dans chiffresOut.

Implémentation de la fonction "`numbers_to_digits`"

Cette fonctions transforme tous les nombres d’un tableau en nombres de 1 à 9.

Testez !

Maintenant que tout est implémenté, n’hésitez pas à tester : entrez votre prénom et le prénom de quelqu’un d’autre, et voyez si ça vaut le coût d’essayer ou si ... next !

J’arrive. J’arrive.
Mais qu’est-ce que j’aurais bien aimé
Encore une fois prendre un amour
Comme on prend le train, pour plus être seul,
Pour être ailleurs, pour être bien.
J’arrive. J’arrive.
Mais qu’est-ce que j’aurais bien aimé
Encore une fois remplir d’étoiles
Un corps qui tremble et tomber mort,
Brûlé d’amour, le cœur en cendres.

Exemple

Par exemple, si l'utilisateur indique les prénoms "tristan" et "yseult", le programme devrait afficher:

Entrez un premier prénom: tristan
Entrez un second prénom: yseult
La compatibilité de tristan et yseult est de 87.500 %

Et si l'utilisateur indique les prénoms "alice" et "bob", le programme devrait afficher:

Entrez un premier prénom: alice
Entrez un second prénom: bob
La compatibilité de alice et bob est de 75.000 %

Et si l'utilisateur indique les prénoms "victor" et "bobette", le programme devrait afficher:

Entrez un premier prénom: victor
Entrez un second prénom: bobette
La compatibilité de victor et bobette est de 100.000 %

Et si l'utilisateur indique les prénoms "meredith" et "derek", le programme devrait afficher:

Entrez un premier prénom: meredith
Entrez un second prénom: derek
La compatibilité de meredith et derek est de 25.000 %

Autoévaluation

Une fois votre programme écrit, vérifiez et corrigez les points suivants:

Chaque instruction se termine-t-elle bien par un point virgule ?
La séquence d'instruction après l'accolade ouvrante est-elle alignée mais légèrement décalée vers la droite par rapport à "main" ?
Chaque variable est-elle déclarée ? C'est-à-dire, avez vous déterminé le type de chacune de vos variables ?
Avez-vous utilisé la fonction de lecture qui correspond au type de la variable dont vous voulez obtenir la valeur ? Par exemple, si vous voulez obtenir un int, avez-vous bien utilisé "scanf("%d", &votre_variable)" ?

Une fois votre programme corrigé, exécutez-le ! Si tout semble correct, postez votre réponse sur Webcampus !

Paste this command into your terminal:

The password to connect is

Le code

Rappel

Une chaine de caractères (ou « string ») est un tableau de caractères dont le dernier élément est le caractère ’\0’. Ce caractère indique la fin de la chaine. Ainsi, pour parcourir une chaine de caractères, pas besoin de connaitre sa taille : on peut s’arrêter dès qu’on rencontre le caractère ’\0’. Une chaine de caractère peut s’écrire sous la forme d’un tableau :
char chaine[] = {’b’,’o’,’b’,’\0’};
Ou en utilisant la notation avec guillemets doubles :
char chaine[] = "bob";
N’oubliez pas que la variable chaine contient en réalité l’adresse du premier élément du tableau. C’est pourquoi on pourrait aussi la déclarer de cette façon :
char* chaine;
De plus, certains caractères doivent être échappés pour être utilisés dans une chaine de caractères. C'est le cas du '%' qui doit être échappé par un autre '%' pour être utilisé dans un "printf".
printf("Le pourcentage est de %d %%", 100);

#include <stdio.h>

// PRE: tableau est un tableau initialisé et taille est la taille de tableau
// POST: affiche le contenu de tableau sous la forme [x1 x2 x3 ... xn]
void print_tab(int tableau[], int taille) {
    printf("[");
    for (int i = 0; i < taille; i++) {
        printf("%i ", tableau[i]);
    }
    printf("]\n");
}

// PRE: str est une chaine de caractère (se termine par '\0') initialisée
// POST: renvoie la taille de str (le nombre de caractères avant '\0')
int str_length(char* str) {
    // TODO: à compléter
}

// PRE: str  et score ont la même taille, str est une chaine de caractère (donc se termine par '\0'), ce sont des tableaux initialisés.
// POST: remplit score avec les valeurs correspondants aux lettres de str (de 1 à 9)
int letters_to_val(char* str, int* score) {
    int i = 0;

    while (*str) {
        score[i] = ((*str)-'a') % 9 + 1;
        i++;
        str++;
    }

    return i;
}

// PRE: taille est la taille de chiffresIn et chiffresIn est un tableau initialisé, chiffresOut aussi
//      la taille de chiffresOut est la moitie de celle de chiffresIn (si taille est pair) ou la moitie arrondie superieur sinon
// POST: chiffresOut est rempli de la somme des chiffres deux à deux de chiffresIn, en laissant le dernier intact (si chiffresIn est impair)
// Exemple: chiffresIn = 1,2,5,9,3,4,2; chiffreOut = 3,14,7,2
void add_two_digits(int* chiffresIn, int taille, int* chiffresOut) {
    // TODO: à compléter
}

// PRE: numbers est un tableau initialisé contenant des nombres de 0 à 18
//      taille est la taille de numbers
// POST: tous les nombres de numbers contenant deux chiffres sont remplacés
//       par la somme de leurs chiffres. Les autres sont inchangés
void numbers_to_digits(int* numbers, int taille) {
    // TODO: à completer
}

// PRE: prenom est une chaine de caractères initialisée et non vide
// POST: renvoie la valeur numérologique de prenom telle que présentée
//       par l'algorithme de http://compatibilite-prenoms.fr/description-algorithme-numerologie.php
int score(char* prenom) {
    int taille;
    int score[str_length(prenom)];

    // Transformation de chaque lettre du prenom en chiffre de 1 à 9, et copie de ces chiffres dans score
    // taille = la taille de score
    taille = letters_to_val(prenom, score);

    while (taille > 1) {
        // Taille du tableau contenant le prochain score
        int taille_new;

        if (taille % 2 == 0) {
            taille_new = taille / 2;
        } else {
            taille_new = (taille - 1) / 2 + 1;
        }

        // Tableau contenant le prochain score
        int score_new[taille_new];

        // Addition des chiffres de score 2 à 2.  Copie du résultat dans score_new
        add_two_digits(score, taille, score_new);

        // Transformation des nombres de score_new en chiffres de 1 à 9
        numbers_to_digits(score_new, taille_new);

        taille = taille_new;

        // Copie du contenu de score_new dans score
        for(int i = 0; i < taille_new; i++) {
            score[i] = score_new[i];
        }
    }

    return score[0];
}

// PRE: prenom1 et prenom2 sont des chaines de caractères initialisées
// POST: renvoie la compatibilité entre prenom1 et prenom2 selon l'algorithme présenté par http://compatibilite-prenoms.fr.
//       cette compatibilité est exprimée sous la forme d'une valeur réelle entre 0 et 1.
float compatibility(char* prenom1, char* prenom2) {
    // TODO: à compléter
}

int main(void) {
    char* prenom1;
    char* prenom2;

    printf("Entrez un premier prénom: ");
    scanf(" %ms", &prenom1);

    printf("Entrez un second prénom: ");
    scanf(" %ms", &prenom2);

    //TODO: à compléter

    return 0;
}

Author(s)	Berg Lucas
Deadline	Keine Frist
Abgabenlimit	No limitation

Information

Einloggen