Exercice langage C : Programmes d'affichage et Calcule


Travail à Faire:

  1. On veut répartir p personnes en g groupes, d'effectif les plus équilibrés possible (différents d'au plus une unité). Écrire un programme, qui à partir de p et de g lus au clavier, affiche les effectifs des petits et grands groupes, et qui affiche les nombres de grands et petits groupes.
  2. Réaliser un programme qui affiche la valeur du n-ième bit d'une valeur entière, n et cette valeur sont saisies au clavier
  3. Réaliser un programme qui affiche en hexadécimal la valeur des 4 octets composant une valeur entière, saisie au clavier
  4. Faites de même pour une valeur de type float : retrouvez les 3 champs indiqués en cours

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

/* Programme de calcul et d'affichage de la repartition en groupes de
 * personnes, d'effectifs equilibres, valeurs lues au clavier */

#include 

int main() 
{
  int groupes, personnes;
  printf("groupes: ");
  scanf("%d", &groupes);
  printf("personnes: ");
  scanf("%d", &personnes);

  printf("Nombre de grands groupes : %d et leur effectif %d\n",
    personnes % groupes, personnes / groupes);

  printf("Nombre de petits groupes : %d et leur effectif %d\n",
    groupes - personnes % groupes, 1 + personnes / groupes);

  return 0;
}

2)

/* Programme de calcul et d'affichage du n-ieme bit d'une valeur entiere
 * lue au clavier, ainsi que n (les bits sont numerotes de 0 a 31) */

#include 

int main() 
{
  int valeur, bit, n;
  printf("valeur: ");
  scanf("%d", &valeur);
  printf("numero du bit (0 a 31): ");
  scanf("%d", &n);

  /* Le decalage '>>' vers la droite de n bits permet de placer le bit
   * recherche a la premiere position. Le masquage avec 1 permet de l'isoler.
   */
  bit = (valeur >> n) & 1;

  printf("valeur du %d-ieme bit = %d\n", n, bit);

  return 0;
}

3)
/* Programme de calcul et d'affichage des 4 octets d'une valeur entiere,
 * lue au clavier */

#include 

int main() 
{
  int ivaleur, octet;
  printf("valeur entiere: ");
  scanf("%d", &ivaleur);

  /* acces a un octet par masquage tout a 1 de l'octet */
  octet = ivaleur & 0xFF;
  printf("1er octet  = 0x%2.2X\n", octet);

  /* Decalage de 8 bits pour placer l'octet suivant dans l'octet de poids
   * faible. "ivaleur >>= 8" est equiv. a "ivaleur = ivaleur >> 8" */
  ivaleur >>=8;
  octet = ivaleur & 0xFF;
  printf("2eme octet = 0x%2.2X\n", octet);

  ivaleur >>=8;
  octet = ivaleur & 0xFF;
  printf("3eme octet = 0x%2.2X\n", octet);

  ivaleur >>=8;
  octet = ivaleur & 0xFF;
  printf("4eme octet = 0x%2.2X\n", octet);

  return 0;
}

4)
/* Programme de calcul et d'affichage des 4 octets d'une valeur flottante,
 * lue au clavier */

#include 

int main() 
{
  /* Les operateurs de decalage sont des operateurs entiers, et non flottants.
   * Pour faire cet exercice, deux solutions : utiliser une union qui permet
   * de "voir" un meme espace memoire de plusieurs facons : */
  union {
    int ivaleur;
    float fvaleur;
  } u;

  /* Une seconde solution est d'utiliser un changement de type lors de l'acces
   * a la variable :
   *   int ivaleur;
   *   float fvaleur;
   *   printf("valeur flottante: ");
   *   scanf("%f", &fvaleur);
   *
   *   ivaleur = *((int *) &fvaleur);
   */

  int octet;
  printf("valeur flottante: ");
  scanf("%f", &u.fvaleur);

  octet = u.ivaleur & 0xFF;
  printf("1er octet  = 0x%2.2X\n", octet);

  u.ivaleur >>=8;
  octet = u.ivaleur & 0xFF;
  printf("2eme octet = 0x%2.2X\n", octet);

  u.ivaleur >>=8;
  octet = u.ivaleur & 0xFF;
  printf("3eme octet = 0x%2.2X\n", octet);

  u.ivaleur >>=8;
  octet = u.ivaleur & 0xFF;
  printf("4eme octet = 0x%2.2X\n", octet);

  return 0;
}