le code
6.1 Le
programme square.c affiche la table carrée.
Écrivez maintenant un programme pour afficher la table carrée. Tout d'abord, le programme invite l'utilisateur à saisir un nombre, puis affiche le résultat des lignes, chaque ligne contient un nombre de 1 à n et sa valeur carrée.
Ce programme imprime un tableau de carrés.
Entrez le nombre d'entrées dans le tableau : 5
1 1
2 4
3 9
4 16
5 25
Stockez le nombre de carrés souhaité dans la variable n. Le programme doit utiliser une boucle pour afficher de manière répétée le nombre i et sa valeur carrée, et la boucle démarre lorsque i est égal à 1. Si i est inférieur ou égal à n, la boucle se répétera. Ce qu'il faut garantir, c'est que la valeur de i est incrémentée de 1 à chaque exécution de la boucle. Les boucles peuvent être écrites à l'aide de l'instruction while. (Franchement, il n'y a pas beaucoup d'autres options pour le moment, puisque l'instruction while est le seul type de boucle que nous maîtrisons jusqu'à présent.) Voici le programme terminé.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int n, i;
printf("This program prints a table of squares.\n");
printf("Enter number of entries in table: ");
scanf("%d", &n);
i = 1;
while (i <= n) {
printf("%10d%10d\n", i, i * i);
i++;
}
return 0;
}
Remarquez comment le programme square.c organise soigneusement la sortie en deux colonnes. L'astuce consiste à utiliser une spécification de conversion telle que %10d au lieu de %d et à profiter de la propriété de la fonction printf pour aligner à droite la sortie dans la largeur spécifiée.
6.1 Sommation du programme sum.c
Dans l'exemple suivant utilisant l'instruction while, nous avons écrit un programme pour additionner les séries entières saisies par l'utilisateur. Voici ce que voit l'utilisateur :
Ce programme additionne une série d'entiers.
Entrez les entiers (0 pour terminer) : 8 23 71 5 0
La somme est : 107
De toute évidence, le programme a besoin d'une boucle pour lire les nombres (en utilisant la fonction scanf) et les accumuler. Utilisez n pour désigner le nombre actuellement lu et sum pour désigner la somme de tous les nombres précédemment lus, le programme suivant est obtenu :
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int n, sum = 0;
printf("This program sums a series of integer.\n");
printf("Enter integers (0 to terminate) : ");
scanf("%d", &n);
while (n != 0) {
sum += n;
scanf("%d", &n);
}
printf("The sum is: %d\n", sum);
return 0;
}
Notez que la condition n != 0 est évaluée immédiatement après la lecture du nombre, afin que la boucle puisse être terminée le plus rapidement possible. De plus, deux appels de fonction scanf identiques sont utilisés dans le programme, ce qui est souvent difficile à éviter lors de l'utilisation d'une boucle while.
6.2 Le programme numdigit.c
calcule le nombre de chiffres d'un entier.
Bien que l'instruction while dans un programme C soit beaucoup plus fréquente que l'instruction do, cette dernière est très pratique pour les boucles qui doivent être exécutées au moins une fois. Pour illustrer ce point, écrivez maintenant un programme pour calculer le nombre de chiffres de l'entier saisi par l'utilisateur :
Entrez un entier non négatif : 60
Le nombre comporte 2 chiffres.
La méthode consiste à diviser à plusieurs reprises l'entier saisi par 10 jusqu'à ce que le résultat devient 0 pour arrêter ; Le nombre de divisions est le nombre de chiffres requis. Comme on ne sait pas exactement combien d'opérations de division sont nécessaires pour atteindre 0, il est clair que le programme a besoin d'une sorte de boucle. Mais dois-je utiliser l’instruction while ou l’instruction do ? Une instruction do est évidemment plus appropriée, puisque chaque entier (y compris 0) comporte au moins un chiffre. Ci-dessous la procédure.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int digits = 0, n;
printf("Enter a nonnegative integer: ");
scanf("%d", &n);
do {
n = n / 10;
digits++;
} while (n > 0);
printf("The number has %d digit(s).\n", digits);
return 0;
}
Pour montrer que l'instruction do est le bon choix, observons ce qui se passe si nous remplaçons la boucle do par une boucle while similaire :
while (n > 0) {
n /= 10;
digits++;
}
Si la valeur initiale de n est 0, la boucle ci-dessus ne s'exécutera pas du tout et le programme imprimera
Le nombre a 0 chiffre(s).
6.3 square2.c
Le programme square.c (➤ Section 6.1) peut être amélioré en convertissant la boucle while en une boucle for.
/* Prints a table of squares using a for statement */
#include <stdio.h>
int main(void)
{
int i, n;
printf("This program prints a table of squares.\n");
printf("Enter number of entries in table: ");
scanf("%d", &n);
for (i = 1; i <= n; i++)
printf("%10d%10d\n", i, i * i);
return 0;
}
Utilisez ce programme pour illustrer un point important concernant l'instruction for : C n'impose aucune restriction sur les trois expressions qui contrôlent le comportement de la boucle. Bien que ces expressions initialisent, évaluent et mettent généralement à jour la même variable, il n’est pas nécessaire qu’elles soient liées de quelque manière que ce soit. Jetez un œil à une autre version du même programme.
carré3.c
/* Prints a table of squares using an odd method */
#include <stdio.h>
int main(void)
{
int i, n, odd, square;
printf("This program prints a table of squares.\n");
printf("Enter number of entries in table: ");
scanf("%d", &n);
i = 1;
odd = 3;
for (square = 1; i <= n; odd += 2) {
printf("%10d%10d\n", i, square);
++i;
square += odd;
}
return 0;
}
L'instruction for de ce programme initialise une variable (carré), évalue une autre variable (i) et incrémente une troisième variable (impaire). La variable i est le nombre à mettre au carré, la variable carré est la valeur au carré de la variable i et la variable impaire est un nombre impair qui doit être ajouté à la valeur au carré actuelle pour obtenir la valeur au carré suivante (permettant aux calculs consécutifs valeurs au carré).
La grande flexibilité de l'instruction for est parfois très utile. Nous découvrirons plus tard que l'instruction for est très utile lorsqu'il s'agit de listes chaînées (➤ Section 17.5). Cependant, l'instruction for est facile à utiliser à mauvais escient, alors n'allez pas trop loin. Si vous réorganisez les différentes parties du programme square3.c, vous pouvez clairement montrer que la boucle est contrôlée par la variable i, donc la boucle for du programme est beaucoup plus claire.
6.4 Vérification du
règlement du livre de programmes
De nombreux programmes interactifs simples sont basés sur des menus : ils montrent à l'utilisateur une liste de commandes parmi lesquelles choisir ; une fois que l'utilisateur sélectionne une commande, le programme effectue l'opération correspondante, puis invite l'utilisateur à choisir la commande One. ; ce processus se poursuit jusqu'à ce que l'utilisateur sélectionne la commande "Quitter" ou "Stop". Le cœur de tels programmes est évidemment la boucle. Il y aura des instructions à l'intérieur de la boucle qui inviteront l'utilisateur à saisir une commande, à lire la commande, puis à déterminer l'action à effectuer :
for ( ; ; ) {
提示用户录入命令;
读入命令;
执行命令;
}
L'exécution de cette commande nécessiterait une instruction switch (ou des instructions if en cascade) :
for ( ; ; ) {
提示用户录入命令;
读入命令;
switch(命令){
case 命令1：执行操作1; break;
case 命令2：执行操作2; break;
.
.
.
case 命令n：执行操作n; break;
default: 显示错误消息; break;
}
}
Pour illustrer ce format, développez un programme qui maintient les soldes du grand livre. Le programme fournira à l'utilisateur un menu d'options : effacer le solde du compte, déposer de l'argent sur le compte, retirer de l'argent du compte, afficher le solde actuel et quitter le programme. Les options sont représentées par les entiers 0, 1, 2, 3 et 4, respectivement. Une session de programme ressemble à ceci :
*** Programme d'équilibrage de chéquier ACME ***
Commandes : 0=effacer, 1=crédit, 2=débit, 3=solde, 4=sortie
Saisir la commande : 1
Saisir le montant du crédit : 1042,56
Saisir la commande : 2
Saisir le montant du débit : 133,79
Saisir la commande : 1
Saisir le montant du crédit : 1754,32
Saisir la commande : 2
Saisir le montant du débit : 1400
Saisir la commande : 2
Saisir le montant du débit : 68
Saisir la commande : 2
Saisir le montant du débit : 50
Saisir la commande : 3
Solde actuel : 1 145,09 $
Saisir la commande : 4
Lorsque l'utilisateur entre la commande 4 (c'est-à-dire quitter), le programme doit quitter l'instruction switch et la boucle environnante. L'instruction break est impossible et nous ne voulons pas utiliser l'instruction goto. Par conséquent, il a été décidé d'utiliser l'instruction return, qui entraînerait l'arrêt du programme et son retour au système d'exploitation.
/* Balances a checkbook */
#include <stdio.h>
int main(void)
{
int cmd;
float balance = 0.0f, credit, debit;
printf("*** ACME checkbook-balancing program ***\n");
printf("Commands: 0=clear, 1=credit, 2=debit, ");
printf("3=balance, 4=exit\n\n");
for (;;) {
printf("Enter command: ");
scanf("%d", &cmd);
switch (cmd) {
case 0:
balance = 0.0f;
break;
case 1:
printf("Enter amount of credit: ");
scanf("%f", &credit);
balance += credit;
break;
case 2:
printf("Enter amount of debit: ");
scanf("%f", &debit);
balance -= debit;
break;
case 3:
printf("Current balance: $%.2f\n", balance);
break;
case 4:
return 0;
default:
printf("Commands: 0=clear, 1=credit, 2=debit, ");
printf("3=balance, 4=exit\n\n");
break;
}
}
}
questions pratiques
1. Quel est le résultat du fragment de programme suivant ?
i = 1;
while (i <= 128){
printf("%d ", i);
i *= 2;
}
1 2 4 8 16 32 64 128
2. Quel est le résultat du fragment de programme suivant ?
i = 9384;
do {
printf("%d ", i);
i /= 10;
} while (i > 0);
9384 938 93 9
3. Quel est le résultat de l’instruction for suivante ?
for (i = 5, j = i - 1; i > 0, j > 0; --i , j = i - 1)
printf("%d ", i);
5 4 3 2
4. Laquelle des affirmations suivantes n'est pas équivalente aux deux autres affirmations (en supposant que le corps de la boucle est le même) ?
(a) for (i = 0; i < 10; i++)...
(b) for (i = 0; i < 10; ++i)...
(c) for (i = 0; i++ < 10; )...
c
5. Laquelle des affirmations suivantes n'est pas équivalente aux deux autres affirmations (en supposant que le corps de la boucle est le même) ?
(a) while (i < 10) {
...}
(b) for (; i < 10;) {
...}
(c) do {
...} while (i < 10);
c
6. Réécrivez le fragment de programme de l'exercice 1 en tant qu'instruction for.
for (i = 1; i <= 128; i *= 2) {
pritnf("%d ", i);
}
7. Réécrivez le fragment de programme de l'exercice 2 en tant qu'instruction for.
for (i = 9384; i > 0; i /= 10) {
printf("%d ", i);
}
8. Quel est le résultat de l’instruction for suivante ?
for (i = 10; i >= 1; i /= 2)
printf("%d ", i++);
10 5 3 2 [1]
9. Réécrivez l'instruction for de l'exercice 8 comme une instruction while équivalente. En plus de la boucle while elle-même, une instruction supplémentaire est requise.
i = 10;
while (i >= 1) {
printf("%d ", i++);
i /= 2;
}
10. Montrez comment remplacer l'instruction continue par l'instruction goto équivalente.
Solution
Label the end of the loop and `goto` that label:
```c
for (i = 0; i <= 10; i++) {
if (i % 2 == 1)
continue;
printf("%d ", i);
}
est le même que
for (i = 0; i <= 10; i++) {
if (i % 2 == 1)
goto end;
printf("%d ", i);
end:
}
11. Quel est le résultat du fragment de programme suivant ?
sum = 0;
for (i = 0; i < 10; i++) {
if (i % 2)
continue;
sum += i;
}
printf("%d\n", sum);
20
- La boucle « prime test » suivante apparaît à titre d'exemple dans la section 6.4 :
for (d = 2; d < n; d++)
if (n % d == 0)
break;
Cette boucle n'est pas très efficace. Il n’est pas nécessaire de diviser n par tous les nombres de 2 à n-1 pour juger s’il s’agit d’un nombre premier. En fait, seuls les diviseurs de la racine carrée non supérieurs à n doivent être vérifiés. Utilisez-le pour modifier la boucle. Astuce : n'essayez pas de trouver la racine carrée de n, utilisez d*d pour comparer n.
solution
for (d = 2; d * d <= n; d++) {
if (n % d == 0)
break;
}
13. Réécrivez la boucle suivante afin que son corps de boucle soit vide.
for (n = 0; m > 0; n++)
m /= 2;
Solution
for (n = 0; m > 0; n++, m /= 2) {
;
}
14. Recherchez l'erreur dans le fragment de programme suivant et corrigez-la.
if (n % 2 == 0);
printf("n is even\n");
supprimer le point-virgule
questions de programmation
- Écrivez un programme pour trouver le plus grand nombre dans une série de nombres saisis par l'utilisateur. Le programme doit inviter l'utilisateur à saisir les chiffres un par un. Lorsque l'utilisateur saisit 0 ou un nombre négatif, le programme doit afficher le plus grand nombre non négatif qui a été saisi :
Saisissez un nombre : 60
Saisissez un nombre : 38,3 Saisissez un nombre
: 4,89
Saisissez un nombre : 100,62
Saisissez un nombre : 75,2295
Saisissez un nombre : 0
Le plus grand nombre saisi était 100,62.
Notez que le nombre saisi n'est pas nécessairement un nombre entier.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
float number, max = 0;
printf("Enter a number: ");
scanf("%f", &number);
while (number > 0) {
if (number > max) {
max = number;
}
printf("Enter a number: ");
scanf("%f", &number);
}
printf("The largest number entered was %.2f\n", max);
return 0;
}
Il y a un problème :
print et scanf sont utilisés deux fois
#include <stdio.h>
int main(void) {
float largest = 0.0f;
float current;
do {
printf("Enter a number: ");
scanf("%f", ¤t);
if (current > largest)
largest = current;
} while (current > 0);
printf("\nThe largest number entered was %f\n", largest);
return 0;
}
- Écrivez un programme qui demande à l'utilisateur de saisir deux entiers, puis de calculer et d'afficher le plus grand diviseur commun (PGCD) de ces deux entiers :
Saisissez deux entiers : 12 28
Plus grand diviseur commun : 4
Astuce : L'algorithme classique pour trouver le plus grand commun diviseur diviseur est l'algorithme d'Euclide, La méthode est la suivante : laissez les variables m et n stocker respectivement les valeurs de deux nombres. Si n est 0, arrêtez et la valeur en m est GCD ; sinon, calculez le reste de la division de m par n, stockez n dans m et stockez le reste dans n. Répétez ensuite le processus ci-dessus, à chaque fois pour déterminer si n est 0 ou non.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int m, n, temp;
printf("Enter two integers: ");
scanf("%d%d", &m, &n);
do {
if (n == 0) {
printf("Greatest common divisor: %d\n", m);
break;
}
else {
temp = n;
n = m % n;
m = temp;
}
} while (1);
return 0;
}
Problèmes existants :
davantage d'énoncés de jugement sont utilisés ; une boucle infinie est adoptée
#include <stdio.h>
int main(void) {
int m, n, r;
printf("Enter two integers: ");
scanf("%d%d", &m, &n);
while (n != 0) {
r = m % n;
m = n;
n = r;
}
printf("Greatest common divisor: %d\n", m);
return 0;
}
- Écrivez un programme qui demande à l'utilisateur de saisir une fraction, puis de la réduire à ses termes les plus bas : Entrez
une fraction : 6/12
En termes les plus bas : 1/2
Astuce : Pour réduire une fraction à ses termes les plus bas, calculez d'abord le numérateur et dénominateur, puis divisez le numérateur et le dénominateur par le plus grand diviseur commun.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int euclid(int m, int n);
int main(void)
{
int m, n, gcd;
printf("Enter a fraction: ");
scanf("%d/%d", &m, &n);
gcd = euclid(m, n);
printf("In lowest terms: %d/%d\n", m / gcd, n / gcd);
return 0;
}
int euclid(int m, int n)
{
int r;
while (n != 0) {
r = m % n;
m = n;
n = r;
}
return m;
}
Il y a un problème :
scanf("%d /%d", &m, &n);
#include <stdio.h>
int main(void) {
int num, denom, n, m, r;
printf("Enter a fraction: ");
scanf("%d /%d", &num, &denom);
m = num;
n = denom;
while (n != 0) {
r = m % n;
m = n;
n = r;
}
printf("In lowest terms: %d/%d\n", num / m, denom / m);
return 0;
}
- Ajoutez une boucle au programme broker.c dans la section 5.2 afin que l'utilisateur puisse saisir plusieurs transactions et que le programme puisse calculer la commission à chaque fois. Le programme se termine lorsque le montant de la transaction saisi par l'utilisateur est 0.
Entrez la valeur de l'échange : 30 000
Commission : 166,00 $
Entrez la valeur de l'échange : 20 000
Commission : 144,00 $
Entrez la valeur de l'échange : 0
/* Calculates a broker's commission */
#include <stdio.h>
int main(void) {
float commission, value;
printf("Enter value of trade: ");
scanf("%f", &value);
while (value > 0) {
if (value < 2500.00f)
commission = 30.00f + .017f * value;
else if (value < 6250.00f)
commission = 56.00f + .0066f * value;
else if (value < 20000.00f)
commission = 76.00f + .0034f * value;
else if (value < 50000.00f)
commission = 100.00f + .0022f * value;
else if (value < 500000.00f)
commission = 155.00f + .0011f * value;
else
commission = 255.00f + .0009f * value;
if (commission < 39.00f)
commission = 39.00f;
printf("Commission: $%.2f\n\nEnter value of trade: ", commission);
scanf("%f", &value);
}
return 0;
}
- Le problème de programmation 1 du chapitre 4 nécessite l'écriture d'un programme pour afficher l'ordre inverse des nombres à deux chiffres. Concevez un programme plus général capable de gérer des nombres à un, deux, trois chiffres ou plus. Astuce : utilisez une boucle do pour diviser à plusieurs reprises le nombre saisi par 10 jusqu'à ce que la valeur atteigne 0.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int number, amount = 0, temp, sum = 0, rank = 1;
printf("Enter a number: ");
scanf("%d", &number);
/* 计算数字的位数 */
temp = number;
do {
temp /= 10;
amount++;
} while (temp != 0);
for (int i = 1; i <= amount; i++) {
temp = number % 10;
/* 计算对应位数的权重 */
for (int j = 1; j <= amount - i; j++) {
rank *= 10;
}
sum += temp * rank;
number /= 10;
rank = 1;
}
printf("The reversal is: %d\n", sum);
return 0;
}
Problème :
Trop stupide
#include <stdio.h>
int main(void) {
int n;
printf("Enter an integer: ");
scanf("%d", &n);
printf("Digits reversed: ");
do {
printf("%d", n % 10);
n /= 10;
} while (n != 0);
printf("\n");
return 0;
}
- Écrivez un programme qui invite l'utilisateur à saisir un nombre n, puis affiche toutes les valeurs carrées des nombres pairs de 1 à n. Par exemple, si l'utilisateur saisit 100, le programme doit afficher ce qui suit :
4
16
36
64
100
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int n;
printf("Enter a number: ");
scanf("%d", &n);
for (int i = 2; i * i <= n; i += 2) {
printf("%d\n", i * i);
}
return 0;
}
#include <stdio.h>
int main(void) {
int n, i;
printf("Enter a number: ");
scanf("%d", &n);
for (i = 1; i * i <= n; i++) {
if ((i * i) % 2 != 0)
continue;
printf("%d\n", i * i);
}
return 0;
}
- Réorganisez le programme square3.c pour initialiser, juger et incrémenter la variable i dans la boucle for. Pas besoin de réécrire le programme, surtout n'utilisez aucune multiplication.
/* Prints a table of squares using an odd method */
#include <stdio.h>
int main(void) {
int i, n, odd, square;
printf("This program prints a table of squares.\n");
printf("Enter number of entries in table: ");
scanf("%d", &n);
odd = 3;
for (i = 1, square = 1; i <= n; odd += 2, ++i) {
printf("%10d%10d\n", i, square);
square += odd;
}
return 0;
}
- Écrivez un programme pour afficher un calendrier mensuel. L'utilisateur précise le nombre de jours du mois et le jour de la semaine où le mois commence :
Saisissez le nombre de jours du mois : 31
Saisissez le jour de début de la semaine (1=Dim, 7=Sam) : 3
1 2 3 4 5
6 7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27 28
29 30 31
Astuce : Ce programme n'est pas aussi difficile qu'il y paraît. La partie la plus importante est une instruction for qui utilise la variable i pour compter de 1 à n (où n est le nombre de jours dans le mois), chaque valeur de i doit être affichée dans l'instruction for. Dans la boucle, utilisez une instruction if pour déterminer si i est le dernier jour d'une semaine et, si c'est le cas, affichez une nouvelle ligne.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int days, startDay;
printf("Enter number of days in month: ");
scanf("%d", &days);
printf("Enter starting day of the week (1=Sun, 7=Sat): ");
scanf("%d", &startDay);
for (int i = 1; i <= days; i++) {
}
return 0;
}
Problème existant : aucune idée, idée stupide : une variable contrôle la boucle, et une variable se charge d'afficher les nombres
#include <stdio.h>
int main(void) {
int n, day, weekday, i;
printf("Enter number of days in month: ");
scanf("%d", &n);
printf("Enter starting day of the week (1=Mon, 7=Sun): ");
scanf("%d", &weekday);
printf("\n Mo Tu We Th Fr Sa Su\n");
for (i = 1, day = 1; i <= n + weekday - 1; i++) {
if (i < weekday)
printf(" ");
else
printf("%3d", day++);
if (i % 7 == 0)
printf("\n");
}
printf("\n");
return 0;
}
- La question de programmation 8 du chapitre 2 exige que la programmation calcule le montant restant du prêt après les premier, deuxième et troisième mois de remboursement. Modifiez le programme pour demander à l'utilisateur de saisir le nombre de remboursements du prêt et d'afficher le montant restant du prêt après chaque remboursement.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void) {
float loan = 0.0f,
rate = 0.0f,
payment = 0.0f;
int time;
printf("Enter amount of loan: ");
scanf("%f", &loan);
printf("Enter interest rate: ");
scanf("%f", &rate);
printf("Enter monthly payment: ");
scanf("%f", &payment);
printf("Enter time of payment: ");
scanf("%d", &time);
for (int i = 0; i < time; i++) {
loan = loan - payment + (loan * rate / 100.0f / 12.0f);
printf("Balance remaining after %d payment: $%.2f\n", i + 1, loan);
}
return 0;
}
#include <stdio.h>
int main(void) {
float loan = 0.0f,
rate = 0.0f,
payment = 0.0f;
int i,
num_of_payments;
printf("Enter amount of loan: ");
scanf("%f", &loan);
printf("Enter interest rate: ");
scanf("%f", &rate);
printf("Enter monthly payment: ");
scanf("%f", &payment);
printf("Enter number of payments: ");
scanf("%d", &num_of_payments);
for (i = 1; i <= num_of_payments; i++) {
loan = loan - payment + (loan * rate / 100.0 / 12.0);
printf("Balance remaining after payment %d: $%.2f\n", i, loan);
}
return 0;
}
- Le problème de programmation 9 du chapitre 5 vous demande d'écrire un programme pour déterminer quelle date est la plus ancienne. Généralisez le programme pour que l'utilisateur puisse saisir n'importe quel nombre de dates. Utilisez 0/0/0 pour indiquer la fin de la saisie, plus de saisie de date.
Entrez une date (mm/jj/aa) : 3/6/08
Entrez une date (mm/jj/aa) : 5/17/07
Entrez une date (mm/jj/aa) : 6/3/07
Entrez une date (mm/jj/aa) : 0/0/0
17/05/07 est la date la plus ancienne
Problème existant : encore stupide
#include <stdio.h>
int main(void) {
int d1, d2, m1, m2, y1, y2;
printf("Enter a date (mm/dd/yy): ");
scanf("%d /%d /%d", &m1, &d1, &y1);
while (1) {
printf("Enter a date (mm/dd/yy): ");
scanf("%d /%d /%d", &m2, &d2, &y2);
if (d2 == 0 && m2 == 0 && y2 == 0)
break;
if (y2 < y1 || (y1 == y2 && m2 < m1) ||
(y1 == y2 && m1 == m2 && d2 < d1)) {
d1 = d2;
m1 = m2;
y1 = y2;
}
}
printf("%d/%d/%.2d is the earliest date\n", m1, d1, y1);
return 0;
}
- La valeur de la constante mathématique e peut être exprimée par une série infinie :
écrivez un programme et utilisez la formule suivante pour calculer la valeur approximative :
Ici, n est un entier saisi par l'utilisateur.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void) {
int n, factorial = 1;
float approximateValue = 1;
printf("Enter a number: ");
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
factorial *= j;
}
approximateValue += 1.0f / factorial;
factorial = 1;
}
printf("e = %f", approximateValue);
return 0;
}
Il y a des problèmes : c'est compliqué, la clé est de trouver la relation entre la variable externe i et la variable interne
#include <stdio.h>
int main(void) {
int i, n, denom;
float e;
printf("Enter integer n: ");
scanf("%d", &n);
for (i = 1, denom = 1, e = 1.0f; i <= n; i++) {
e += 1.0f / (denom *= i);
}
printf("Approximation of e: %f\n", e);
return 0;
}
- Modifiez le problème de programmation 11 afin que le programme continue à additionner jusqu'à ce que l'élément actuel soit inférieur à u, où u est un petit nombre (à virgule flottante) entré par l'utilisateur.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void) {
int n, factorial = 1;
float approximateValue = 1, u;
printf("Enter a number: ");
scanf("%d", &n);
printf("Enter mix float: ");
scanf("%f", &u);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
factorial *= j;
}
approximateValue += 1.0f / factorial;
if (1.0f / factorial < u) {
break;
}
factorial = 1;
}
printf("e = %f", approximateValue);
return 0;
}
Il y a un problème :
je n'ai pas assimilé la leçon de la question 11, il est temps de jouer
#include <stdio.h>
int main(void) {
int i, denom;
float e, epsilon, term;
printf("Enter epsilon: ");
scanf("%f", &epsilon);
for (i = 1, denom = 1, e = 1.0f, term = 1.0f; term > epsilon; i++) {
term = (1.0f / (denom *= i));
e += term;
}
printf("Approximation of e: %f\n", e);
return 0;
}