Pourquoi C me donne-t-il une réponse différente de celle de ma calculasortingce?

J’ai rencontré un problème étrange avec ce code:

legibIndex = 206.385 - 84.6 * (countSylb / countWord) - 1.015 * (countWord / countSent);

C’est le calcul de l’indice de lisibilité d’un fichier texte donné. Puisqu’il s’agit d’un devoir, on nous a dit ce que devrait être l’indice (80 ou exactement 80,3)

Le nombre de syllabes, le nombre de mots et le nombre de phrases sont corrects (ils correspondent aux nombres donnés pour les fichiers de texte exemples.

Même si je code en dur les nombres, je n’obtiens pas 80, même si je le fais quand je le mets dans mon calculateur exactement comme on le voit. Je ne peux pas imaginer ce qui ne va pas.

Voici l’équation qui nous a été donnée:

Index = 206.835 - 84.6 * (# syllables/# words) - 1.015 * (# words/# sentences)

Comme vous pouvez le constater, je viens de twigr mes variables (qui contiennent les valeurs correctes. Pour référence, les valeurs sont les suivantes: 55 syllabes, 40 mots, 4 phrases, données par l’instructeur. Les valeurs que mon programme produit lors de l’exécution sont Indice de lisibilité de 112.

Est-ce qu’il me manque des crochets ou quoi? Je suis perplexe!

Dès le départ, à partir des noms (qui incluent le nombre de mots), je suppose que countSylb , countSent et countWord sont déclarés en tant countSent et que, par conséquent, vos divisions font de l’arithmétique des entiers, tronquant les parties décimales. Jetez-les en flotteurs et cela devrait résoudre le problème.

 legibIndex = 206.385 - 84.6 * ((float)countSylb / ((float)countWord) - 1.015 * (((float)countWord / ((float)countSent); 

Vous avez probablement un problème de type de données où vous arrondissez parce que int / int = int au lieu de float.

Si vous lancez ou déclarez flotter, cela devrait vous aider.

Fonctionne ici. Peut-être que vous faites la division entière au lieu de la division float:

 >>> def leg(syl, wor, sen): ... return 206.835 - 84.6 * (float(syl) / wor) - 1.015 * (float(wor) / sen) ... >>> print leg(55, 40, 4) 80.36 

Si vos calculs entre parenthèses sont des entiers purs, le calcul supprimera les parties décimales et sera arrondi (comme si vous utilisiez floor ()), ce qui modifiera évidemment le résultat.

Lorsque je lance ceci dans Haskell, j’obtiens la bonne réponse (80.36000000000001).

Je pense que le problème est que (# syllabes / # mots) vient à 1 si vous utilisez l’arithmétique entière. Si vous vous assurez que vous effectuez le calcul en utilisant l’arithmétique à virgule flottante (donc # syllabes / # mots = 1.375), vous devriez obtenir la bonne réponse.

Comme indiqué ci-dessus, vos variables de comptage sont probablement des entiers entiers, mais votre expression contient des nombres à virgule flottante. Le fait de lancer ces ints en float donnera la valeur correcte. Vous devez également vous assurer que le contenu de l’expression (legibIndex) dans lequel vous stockez le résultat est également de type float.

C’est probablement un problème de priorité des opérateurs . Pour être sûr, regroupez les choses que vous pensez devoir arriver en premier lieu plus que ce que vous avez déjà.

Edit Non, ce n’est pas le cas. en utilisant la priorité de l’opérateur C, je reçois 80,36. Je m’attends à ce que Sparks ait raison (et le premier au début) qu’il s’agisse d’un problème de type de données et que vous renconsortingez des problèmes d’arrondi prématuré.