Conditions | Exercices 11-15

Enoncé exercice 11

Ecrire un programme C qui lit un nombre impair n et confirme que 32 divise (n2+3)(n2+7).

Correction exercice 11

Dans ce programme, on est amené à vérifier si un nombre est divisible ou non par 32. Seulement, le nombre sur lequel on va effectuer le test est à calculer à partir d’un nombre entré par l’utilisateur.

La quantité (n2+3)(n2+7) est toujours divisible par 32 pour tout entier n impair. Mais, au lieu de démontrer cette propriété mathématiquement on va la tester pour quelques entiers impairs.

Pour ça, on va demander à l’utilisateur d’entrer un nombre impair qu’on va lire vers la variable entière n (lignes 6-7). Puis, on va calculer la quantité précédente en fonction de n. Et on va la mettre dans une autre variable entière a (ligne 8).

Une fois ceci est fait, on va effectuer un test sur la valeur du reste de la division de a par 32 (lignes 9-12). Et dans le cas où le résultat est nul, ce qui correspond à la divisibilité de a par 32, on va afficher un message indiquant que la quantité a est bien divisible par 32 (ligne 10). Dans l’autre cas, on va afficher le contraire (ligne 12).

Solution exercice 11
#include<stdio.h>
#include<stdlib.h>
int main()
{
    int n,a;
    printf("Entrer un entier impair\n");
    scanf("%d",&n);
    a=(n*n+3)*(n*n+7);
    if(a%32==0)
       printf("32 divise (%d^2+3)(%d^2+7)\n",n,n);
    else
       printf("32 ne divise pas (%d^2+3)(%d^2+7)\n",n,n);
    system("pause");
    return 0;
}
Enoncé exercice 12

Ecrire un programme C qui lit deux entiers représentant le grand rayon a et le petit rayon b d’une ellipse. Puis détermine si oui ou non l’aire de cette ellipse est supérieure ou égale à 100.

Correction exercice 12

La démarche pour résoudre cet exercice est la plus directe qui soit. On va commencer par la lecture des deux rayons de l’ellipse vers les deux variables entières a et b (lignes 7-10). Une fois ces valeurs en mains, on va les utiliser pour calculer l’aire de l’ellipse qu’on va mettre dans la variable aire de type float.

L’aire d’une ellipse de rayons a et b est donnée par la formule πab. Pour le nombre π, on pourra utiliser tout simplement l’approximation 3,14 car on n’a pas besoin de beaucoup de précision pour ce calcul (ligne 11).

Une fois que l’aire de l’ellipse est calculée, il suffira de la comparer avec la valeur 100 pour répondre à la question. Pour ceci, on va utiliser la structure if else (lignes 12-15). Elle va permettre de vérifier si la valeur de la variable aire est supérieure ou non à 100. On va donc utiliser comme condition d’exécution du bloc if, l’expression aire˃=100. Dans le cas où cette expression est vraie, la fonction printf va afficher un message indiquant que l’aire de l’ellipse est supérieure ou égale à 100 (ligne 13). Dans le cas contraire, c’est-à-dire dans le cas où l’expression est fausse, c’est le bloc de else qui sera exécuté. Ce bloc contient une seule instruction constituée de la fonction printf, qui permettra d’affichage un message indiquant que l’aire calculée est inférieure à 100 (ligne 15).

Solution exercice 12
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a,b;
	float aire;
	printf("Entrer le grand rayon a: ");
	scanf("%d",&a);
	printf("Entrer le petit rayon b: ");
	scanf("%d",&b);
	aire=3.14*a*b;
	if(aire>=100)
	   printf("L'aire de cette ellipse est superieure a 100.\n");
	else
	   printf("L'aire de cette ellipse est inferieure a 100.\n");
	system("pause");
	return 0;
}
Enoncé exercice 13

Ecrire un programme C qui lit trois entiers qui représentent les longueurs des côtés d’un triangle, et permet de dire s’il s’agit d’un triangle équilatéral, isocèle ou scalène.

Correction exercice 13

Il est clair que la nature d’un triangle dépend de la relation d’égalité entre les longueurs de ses trois côtés. Il suffira donc de les comparer. Mais en faisant ça, il faudra faire attention à deux choses :

  • Eviter d’afficher deux messages à la fois. Ceci peut provenir dans notre cas, du fait qu’un triangle équilatéral et aussi isocèle.
  • Eviter d’utiliser des conditions trop étalées et réduire le nombre de conditions utilisées, et ceci en exploitant l’imbrication des structures if else.

On commencera le programme comme toujours par la déclaration des variables dont on aura besoin. Ici, trois variables a, b et c de type int sont assez suffisantes. Chacune de ces trois variables va contenir une des longueurs des trois côtés du triangle. Et vont par la suite servir pour effectuer les tests de comparaison. Leur lecture est effectuée à l’aide de la fonction scanf (ligne 7).

L’algorithme adopté dans le programme proposé ici, consiste à vérifier dans un premier temps si le triangle est équilatéral. Si c’est le cas, on affiche un message exprimant ceci (lignes 8-9). Et dans le cas contraire, on va procéder à la vérification des deux autres possibilités (lignes 10-14). Avant ça, il sera utile pour quelques-uns d’entre nous de noter qu’il n’est pas possible en langage C d’exprimer la condition pour le triangle équilatéral en écrivant a==b==c. On peut bien sûr contourner cette limitation en faisant a==b && b==c qui veut dire exactement la même chose. Il ne sera pas nécessaire d’ajouter a==c. Car par transitivité, si b est égal en même temps à a et à c ça veut forcément dire que a et c sont égaux.

Dans le cas où le triangle n’est pas équilatéral, c’est le premier bloc else qui sera exécuté. Dedans on trouve au début la vérification de la condition qui donne un triangle isocèle. Pour que le triangle soit isocèle, il suffit que les longueurs de deux côtés quelconques soient égales. On va donc étaler toutes les possibilités qui existent et qui sont au nombre de trois. On peut avoir soit a et b égaux, a et c ou b et c. Ceci va résulter dans la condition a==b || a==c || b==c où les deux barres verticales || représentent le ou logique en langage C (ligne 11). Si cette expression est vraie, on va afficher que le triangle est isocèle (ligne 12). Sinon, le triangle ne sera pas isocèle. En plus de ça, on sait déjà qu’il n’est pas équilatéral, donc on affiche que le triangle est scalène (lignes 13-14).

Solution exercice 13
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a,b,c;
	printf("Donner les longueurs des 3 cotes:\n");
	scanf("%d%d%d",&a,&b,&c);
	if(a==b && b==c)
	   printf("Ce triangle est equilateral.\n");
	else
	   if(a==b || a==c || c==b)
	      printf("Ce triangle est isocele.\n");
	   else
	      printf("Ce triangle est scalene.\n");
	system("pause");
	return 0;
}
Enoncé exercice 14

Ecrire un programme C qui lit un caractère et détermine ensuite s’il est un chiffre, une lettre de l’alphabet ou un autre type de caractères.

Correction exercice 14

On va commencer ce programme, comme toujours, par la déclaration des variables nécessaires. Une seule variable c de type char est tout ce dont on aura besoin ici (ligne 5). Après sa déclaration, on enchaînera par la lecture du caractère entré par l’utilisateur, en utilisant la fonction scanf et en veillant à mentionner le format correct correspondant au type char qui est %c (lignes 6-7). Une fois le caractère est lu vers la variable c, on pourra alors procéder aux différents tests.On peut adopter diverses méthodes pour exécuter la tâche demandée. Celle choisie ici consiste à vérifier par une première structure if else si le caractère est une lettre ou non. Dans le cas où il l’est, on affiche un message indiquant cela en utilisant la fonction printf (ligne 9). Et dans le cas contraire, on va exploiter le bloc else pour trancher entre les deux cas possibles qui restent. Et cela en utilisant de nouveau la structure if else (lignes 11-14).

Pour ce deuxième if, il aura comme condition une expression qui sera vraie si le caractère est un chiffre. A l’intérieur de ce bloc if on doit avoir une instruction qui se chargera de l’affichage du message adéquat. A savoir que le caractère en question est un chiffre (ligne 11-12).

Pour le dernier bloc else, on affichera que le caractère c n’est, ni une lettre ni un chiffre (ligne 13-14).

En ce qui concerne les expressions utilisées pour tester si le caractère c est une lettre ou un chiffre, elles sont simples à concevoir du moment où on sait que les caractères en langage C sont codés sous forme de nombres entiers, et le langage C permet de les traiter comme tels.

Solution exercice 14
#include<stdio.h>
#include<stdlib.h>
int main()
{
	char c;
	printf("Saisir un caractere:\n");
	scanf("%c",&c);
	if((c>='a' && c<='z') || (c>='A' && c<='Z'))
		printf("Le caractere '%c' est une lettre.\n",c);
	else
	    if(c>='0' && c<='9')
	        printf("Le caractere '%c' est un chiffre.\n",c);
	    else
	        printf("Le caractere '%c' n'est ni un chiffre ni une lettre.\n",c);
	system("pause");
	return 0;
}
Enoncé exercice 15

Ecrire un programme C qui permet de lire deux nombres réels a et b, puis un entier n et afficher le résultat de la division de a par b avec une précision de n (0≤n≤3) chiffres après la virgule.

Correction exercice 15

L’objectif de cet exercice est d’utiliser les structures de contrôle afin d’afficher un nombre réel, qui est dans ce cas le résultat d’une opération arithmétique, avec une précision qui dépend du choix de l’utilisateur.

On commence par la déclaration des variables réelles a et b puis la variable entière n et on effectue ensuite leurs lectures (lignes 5-10).

Pour afficher un nombre réel contenu dans une variable de type float avec un nombre déterminé de chiffre après la virgule, il suffit de mentionner ce nombre, précédé d’un point, entre le % et le f du format %f. Par exemple, si on souhaite afficher la valeur d’une variable de type float avec 3 chiffres après la virgule, il suffira d’utiliser le format %.3f.

Jusqu’à ici, les choses sont toutes simples. La petite difficulté qui se pose est qu’on doit préciser le nombre de chiffres d’une manière claire, c’est-à-dire sous forme d’une constante. On ne peut donc pas exploiter directement la variable n.

La solution réside dans l’utilisation de la structure switch. Et selon la valeur de n, on affiche le résultat a/b avec la précision correspondante (ligne 11-24). Remarquez que dans le programme proposé, on a traité séparément les cas où n est égal à 0, 1 et 2, puis on a utilisé l’option default de la structure switch pour répondre à toute autre valeur de n (pour les valeurs de n différentes de 0, 1 et 2). Dans ce dernier cas, on va afficher le résultat avec une précision de trois chiffres après la virgule quelle qu’elle soit la valeur de n (lignes 22-23).

Solution exercice 15
#include<stdio.h>
#include<stdlib.h>
int main()
{
	float a,b;
	int n;
	printf("Saisir deux nombres reels:\n");
	scanf("%f%f",&a,&b);
	printf("Entrer un entier inferieur ou egal a 3:\n");
	scanf("%d",&n);
	switch(n)
	{
		case 0:
			printf("Le resultat de la division est: %.0f\n",a/b);
			break;
		case 1:
			printf("Le resultat de la division est: %.1f\n",a/b);
			break;
		case 2:
			printf("Le resultat de la division est: %.2f\n",a/b);
			break;
		default:
			printf("Le resultat de la division est: %.3f\n",a/b);
	}
	system("pause");
	return 0;
}