Est-il possible de remplacer un double nombre et d'écrire le programme en utilisant uniquement des entiers en C, avec la même sortie?

Question

Est-il possible d'écrire un programme comme celui-ci, en utilisant seulement le type entier et la bibliothèque standard <stdio.h> en C? La sortie du reste doit être affichée sous la forme d'un nombre décimal avec deux nombres derrière la virgule.

#include <stdio.h> 

int num1 = 0; 
int num2 = 1; 
int num3 = 6; 
int num4 = 3; 
int num5 = 7; 
int num6 = 3; 
int num7 = 9; 
int num8 = 8; 

int sum, product, Result; 
double division; 

int main() 
{ 
    sum = num1 + num2 + num3 + num4; 
    product = num5 * num6 * num7; 
    Result = ((++product) - (sum++)) * sum; 

    int Integer_division = Result/(num8+ 1); 
    int Remainder = Result % (num8+ 1); 
    double division = Result/(num8+ 1); 

    printf("Result = %d\n", Result); 
    printf("Integer division = %d\n", Integer_division); 
    printf("Remainder = %d\n", Remainder); 
    printf("Division = %.02f\n", division); 

    return 0; 
} 

Je pensais à le diviser en deux moitiés et l'imprimer avec une virgule entre (%% d. D) mais cela ressemble à mon dernier recours ...

Merci à l'avance.

Answer 1

Pour imprimer à virgule flottante comme le texte des entiers nécessite le signe, alors que numéro partie et la partie de fraction

char *sign = Result<0 ? "-":""; 
int whole = abs(Integer_division); 
char decimal_point = ','; // behind the comma. 
int hundredths = abs(Remainder *100/(num8+ 1)); // Convert fraction to 

1/100ème

// now print it 
printf("%s%d%c%02d", sign, whole, decimal_point, hundredths); 

---

cette affiche pourtant seulement résultat tronqué. Pour tour est le travail. La manière habituelle d'imiter la sortie à virgule flottante en utilisant des nombres entiers consiste à considérer la valeur comme une fraction de 2 parties entières: numerator, denominator qui nécessite une mise à l'échelle (par exemple x100 pour un affichage de 0,00). Pour plus de simplicité, supposons denominator > 0.

La première étape est arrondie en raison de la précision de l'affichage fini. Puisque l'étape suivante impliquera une division d'entiers "tronquée vers zéro" et que l'affichage en virgule flottante est habituellement "arrondi au plus proche", le code doit ajouter un 0.5 ou une moitié du dénominateur. Pour des raisons de simplicité, supposons denominator > 0 et est étrange afin que nous puissions éviter les cas à mi-chemin (encore plus de travail). Supposons également aucun dépassement int pour éviter plus de travail.

int numerator = Result; 
int denominator = num8+ 1; 
int scale = 100; // to print to 0.xx 

int scaled_numerator = numerator * scale; 
int scaled_half = denominator/2; 
if (scaled_numerator < 0) scaled_half = -scaled_half; 
int rounded_scaled_numerator = scaled_numerator + scaled_half; 

divisent maintenant

int scaled_value = rounded_scaled_numerator/denominator; 

char *sign = scaled_value<0 ? "-":""; 
scaled_value = abs(scaled_value); 
int whole = scaled_value/scale; 
char decimal_point = ','; 
int hundredths = scaled_value % scale; 
printf("%s%d%c%02d", sign, whole, decimal_point, hundredths);