Discussion :

[Jinkas99]

Bonjour,

Pas trop de connaissance en C, je cherche à écrire une fonction minmax qui prend en paramètres un tableau d'entiers, la taille et les adresses des variables min et max.

Je voudrais que cette fonction me retourne un booléan si le calcul a pu être efféctué et modifie les variables pointées en leur affectant respectivement le plus petit et le plus grand élément du tableau.

J'ai pensé à faire un truc comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdio.h> /* utilisation de la librairie stdio.h pour pouvoir utiliser un
 
bool minmax(int a_Array[], int a_Size, int* a_Min, int* a_Max)
{
    int i, iMin, iMax;
     
    *a_Min = *a_Max = 0;
     
     
    if(a_Size > 1)
    {
        iMin = iMax = a_Array[0];
        i = 0;
        while(i < a_Size)
        {
            if(a_Array[i] < iMin) iMin = a_Array[i];
            if(a_Array[i] > iMax) iMax = a_Array[i];    
            i++;
        }
        *a_Min = iMin;
        *a_Max = iMax;
        return true;
    }
 
    return false;
}

Merci,

[foetus]

Ton algo ne fonctionne pas il faut mettre un gros nombre pour le minimum. 0 sera toujours un minimum si tu le compares avec tous les nombres positifs

Sinon, tu peux :

• Replacer ta boucle while par une boucle for
• Replacer tes 2 if ... if par un if ... else if. Si le nombre est un minimum, il ne sera jamais un maximum ... sauf si ton tableau ne contient que la même valeur. Pour ce cas, il faut juste initialiser le max avec la première valeur et mettre le test maximum dans le else
• Je ne suis pas fan du return en plein milieu . Moi j'aurais codé *

*, non compilé, non testé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
unsigned char minmax(int input_tab[], size_t input_size, int* output_min, int* output_max) {
    unsigned char ret;
 
    if ((input_tab != NULL) && (output_min != NULL) && (output_max != NULL)) {
        switch(input_size) {
        case 0:
            *output_min = 0;
            *output_max = 0;
 
            ret = 0;
            break;
        case 1:
            *output_min = input_tab[0];
            *output_max = input_tab[0];
 
            ret = 1;
            break;
        default:
            {
                size_t elt;
                int min, max;
 
                for(min=input_tab[0], max=input_tab[0], elt=1; elt < input_size; ++elt) {
                    if (input_tab[elt] < min) {
                        min = input_tab[elt];
                    } else if (input_tab[elt] > max) {
                       max = input_tab[elt];
                    }
                }
 
                *output_min = min;
                *output_max = max;
 
                ret = 1;
            }
            break;
        }
    } else {
        ret = 0;
    }
 
    return ret;
}

[Pyramidev]

Bonjour,

Je pense qu'il est préférable d'interdire l'utilisateur d'appeler minmax avec un tableau vide.
En effet, quand cela arrivera, ce sera probablement à cause d'une erreur de programmation.
Or, pour aider à détecter les erreurs de programmation dans la phase de débogage, le langage C fournit la macro assert.

Personnellement, voici comment j'aurais codé minmax :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <assert.h>
#include <stddef.h>
 
typedef struct { int min, max; } minmax_result_t;
 
minmax_result_t minmax(int const* nonEmptyArray, size_t size)
{
	assert(nonEmptyArray != NULL);
	assert(size >= 1);
 
	minmax_result_t result = {nonEmptyArray[0], nonEmptyArray[0]};
	for(size_t k = 1; k < size; ++k) {
		if     (result.min > nonEmptyArray[k]) result.min = nonEmptyArray[k];
		else if(result.max < nonEmptyArray[k]) result.max = nonEmptyArray[k];
	}
	return result;
}
 
// Exemple d'utilisation :
 
#include <stdio.h>
 
int main()
{
	int const arrayTest[] = {2, -3, 3, -7, 7, -5, 5};
	size_t const arrayTestSize = sizeof(arrayTest) / sizeof(int);
	minmax_result_t const minAndMax = minmax(arrayTest, arrayTestSize);
	printf("The minimum is %d and the maximum is %d.", minAndMax.min, minAndMax.max);
	return 0;
}

[Jinkas99]

Merci beaucoup pour vos réponses. En effet, il me faut suivre la consigne telle que je l’ai définie à savoir une fonction qui prend 4 paramètres et qui me retourne un booléen si le calcul est possible. Pouvez-vous svp me confirmer aussi que l’etoile * devant les paramètres Min et Max signife que ces paramètres vont contenir les adresses comme demandé dans la consigne. J’ai remarqué aussi que personne n’a utilisé le type bool devant le nom de la fonction est ce parce que cela n’est pas possible dans le langage c?

[Pyramidev]

Contrairement à ce que dit foetus, ton algo fonctionne. Je pense qu'il a lu trop vite et a sauté ton instruction iMin = iMax = a_Array[0];.
L'étoile devant tes paramètres a_Min et a_Max signifie bien que ces paramètres vont contenir des adresses.
bool existe bien en C, mais il faut inclure "stdbool.h".

Si on est obligé d'avoir 4 paramètres et de retourner un booléen, alors j'aurais écrit ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdbool.h>
#include <stddef.h>
 
bool minmax(int const* array, size_t size, int* outMin, int* outMax)
{
	if(array == NULL || outMin == NULL || outMax == NULL || size < 1)
		return false;
 
	*outMin = *outMax = array[0];
	for(size_t k = 1; k < size; ++k) {
		if     (*outMin > array[k]) *outMin = array[k];
		else if(*outMax < array[k]) *outMax = array[k];
	}
	return true;
}
 
// Exemple d'utilisation :
 
#include <stdio.h>
 
int main()
{
	int const arrayTest[] = {2, -3, 3, -7, 7, -5, 5};
	size_t const arrayTestSize = sizeof(arrayTest) / sizeof(int);
	int min, max;
	bool const ok = minmax(arrayTest, arrayTestSize, &min, &max);
	if(ok)
		printf("The minimum is %d and the maximum is %d.", min, max);
	else
		printf("Programming error!");
	return 0;
}

[Jinkas99]

Merci pour votre réactivité mais le premier paramètre doit être un tableau d’entiers.

[Pyramidev]

Quand un paramètre représente l'adresse d'un tableau, on peut l'écrire de plusieurs manières, dont celle que j'ai utilisée.
Pour plus de détails, voir la FAQ C, en particulier l'entrée : Comment passer un tableau en paramètre à une fonction ?

[Matt_Houston]

J'ajouterais à la proposition de Pyramidev qu'il s'agit d'un cas où il peut être intéressant de spécifier restrict :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void minmax(const int *restrict buf, size_t count, int *restrict minimum, int *restrict maximum);

..voire mieux, on renvoie le rang (ou l'adresse, c'est selon) des extrema :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void minmax(const int *restrict buf, size_t count, size_t *restrict minrank, size_t *restrict maxrank);

Si count vaut zéro, les valeurs des paramètres de sortie sont laissées inchangées. Sinon, la fonction ne peut pas échouer. Pourquoi renvoyer quoi que ce soit ? Ce n'est pas pertinent.

Ou encore, en version générique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void minmax(const void *restrict buf, size_t count, size_t size, int (*cmp)(const void *, const void *), size_t *restrict minrank, size_t *restrict maxrank);

[foetus]

Contrairement à ce que dit foetus, ton algo fonctionne. Je pense qu'il a lu trop vite et a sauté ton instruction iMin = iMax = a_Array[0];.

Ouais , et en plus c'est ce que j'ai fait dans mon exemple. C'est seulement si ton minimum est initialisé avec 0 et non pas avec la première valeur du tableau ni avec INT_MAX (<- lien en anglais)

Merci pour votre réactivité mais le premier paramètre doit être un tableau d’entiers.

C'est une particularité des tableaux en C : leur passage en paramètre de fonctions/ procédures est dégradé en pointeur ... sauf pour les fonctions/ procédures qui sont dans le même fichier source dans lequel le tableau est défini (<- à vérifier ).

[Jinkas99]

Merci beaucoup pour vos explications et réponses.

Par ailleurs, contrairement à la fonction minmax qui modifie les variables pointees en leur affectant respectivement
le plus petit et le plus grand elements du tableau, je voudrais écrire une autre fonction similaire qui modifie la place dans les cases du tableau de deux entiers
respectivement le plus petit et le plus grand elements du tableau.

De ce fait, que devrais-je modifier dans la fonction minmax pour écrire l'autre fonction?

Merci.

[Bktero]

leur passage en paramètre de fonctions/ procédures est dégradé en pointeur ... sauf pour les fonctions/ procédures qui sont dans le même fichier source dans lequel le tableau est défini (<- à vérifier ).

Il n'y a pas de sauf

[Matt_Houston]

Par ailleurs, contrairement à la fonction minmax qui modifie les variables pointees en leur affectant respectivement
le plus petit et le plus grand elements du tableau, je voudrais écrire une autre fonction similaire qui modifie la place dans les cases du tableau de deux entiers
respectivement le plus petit et le plus grand elements du tableau.

De ce fait, que devrais-je modifier dans la fonction minmax pour écrire l'autre fonction?

Intervertir les rangs des extrema tu veux dire ?

1. Modifier la signature de la fonction minmax pour qu'elle retourne un chemin d'accès aux éléments concernés (cf. ma proposition ci-avant) ;
2. se servir de minmax dans le corps de cette nouvelle fonction.

[Jinkas99]

Merci Matt_Houston.

Une fonction minmax2 ayant comme parametres un tableau d'entiers, sa taille
et un tableau de deux entiers et qui retourne un booléen précisant si le calcul
a pu être effectué et modifie la place dans les cases du tableau de deux entiers
respectivement le plus petit et le plus grand elements du tableau.

[Matt_Houston]

Énoncé on ne peut plus vague, qu'est-ce qu'on veut faire concrètement ? À quoi correspondent les paramètres supplémentaires ? Sont-ce des paramètres d'entrée ou de sortie ?

La valeur de retour n'a qu'une utilité très discutable, comme je l'ai écrit précédemment.

[Pyramidev]

Cet énoncé sur minmax2 équivaut à compléter le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdbool.h>
#include <stddef.h>
 
bool minmax(int const* array, size_t size, int* outMin, int* outMax)
{
	if(array == NULL || outMin == NULL || outMax == NULL || size < 1)
		return false;
 
	*outMin = *outMax = array[0];
	for(size_t k = 1; k < size; ++k) {
		if     (*outMin > array[k]) *outMin = array[k];
		else if(*outMax < array[k]) *outMax = array[k];
	}
	return true;
}
 
bool minmax2(int const* array, size_t size, int* outMinMax2DArray)
{
	// CODE À COMPLÉTER.
}
 
// Exemple d'utilisation de minmax2 :
 
#include <stdio.h>
 
int main()
{
	int const arrayTest[] = {2, -3, 3, -7, 7, -5, 5};
	size_t const arrayTestSize = sizeof(arrayTest) / sizeof(int);
	int minAndMax[2];
	bool const ok = minmax2(arrayTest, arrayTestSize, minAndMax);
	if(ok)
		printf("The minimum is %d and the maximum is %d.", minAndMax[0], minAndMax[1]);
	else
		printf("Programming error!");
	return 0;
}

Donc, quand on a compris les pointeurs et les tableaux, c'est facile.
Sinon, il faut réviser le cours ou lire la FAQ C : Pointeurs, tableaux et chaînes de caractères.

Remarque : si on veut utiliser des fonctionnalités avancées du langage C, alors on peut remplacer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool minmax2(int const* array, size_t size, int* outMinMax2DArray)

par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool minmax2(int const* restrict array, size_t size, int outMinMax2DArray[static restrict 2])

[Jinkas99]

Bonjour Pyramidev.

Est ce qu'il faut mettre un & devant minAndMax

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool const ok = minmax2(arrayTest, arrayTestSize, &minAndMax);

dans la fonction main.

Est ce que la fonction minmax2 s'écrit comme ceci?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
bool minmax2(int const* array, size_t size, int* outMinMax2DArray)
{
	if(array == NULL || outMinMax2DArray == NULL || size < 1)
		return false;
	outMinMax2DArray[0] = array[0];
	for(size_t k = 1; k < size; ++k) {
		if     (*outMinMax2DArray > array[k]) *outMinMax2DArray = array[0];
		else if(*outMinMax2DArray < array[k]) *outMinMax2DArray = array[1];
	}
	return true;
}

[Pyramidev]

Bonjour,

Est ce qu'il faut mettre un & devant minAndMax

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool const ok = minmax2(arrayTest, arrayTestSize, &minAndMax);

En langage C, on pourrait, mais ce serait inutile.
En outre, cela empêcherait de compiler le code en C++ (qui, à de rares incompatibilités près, est un sur-ensemble du C).

Est ce que la fonction minmax2 s'écrit comme ceci?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
bool minmax2(int const* array, size_t size, int* outMinMax2DArray)
{
	if(array == NULL || outMinMax2DArray == NULL || size < 1)
		return false;
	outMinMax2DArray[0] = array[0];
	for(size_t k = 1; k < size; ++k) {
		if     (*outMinMax2DArray > array[k]) *outMinMax2DArray = array[0];
		else if(*outMinMax2DArray < array[k]) *outMinMax2DArray = array[1];
	}
	return true;
}

Non. Ton implémentation choisit pour minimum soit le premier, soit le deuxième élément du tableau et ne choisit aucun maximum.
Pour faire des tests, si besoin, tu peux utiliser un compilateur C en ligne, par exemple : http://rextester.com/l/c_online_compiler_gcc

Remarque : On peut implémenter minmax2 en appelant directement minmax.

[Jinkas99]

Merci.

Donc pas besoin de faire une nouvelle boucle dans minmax2. Il suffit d'appeler minmax dans minmax2 dans un else et faire un return true.

C'est bien ça?