fonction booleénne minmax

Version imprimable

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:

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,

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

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:

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;
}

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:

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;
}

23/04/2018, 23h04
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?

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:

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; }

23/04/2018, 23h35
Jinkas99

Merci pour votre réactivité mais le premier paramètre doit être un tableau d’entiers.
23/04/2018, 23h49
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 ?
23/04/2018, 23h53
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:

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:

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:

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);
24/04/2018, 00h05
foetus

Citation:

Envoyé par 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];.

Ouais :mrgreen:, 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)

Citation:

Envoyé par Jinkas99

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

C'est une particularité des tableaux en C :mrgreen: : 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 :whistle:).
24/04/2018, 11h53
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.
24/04/2018, 12h10
Bktero

Citation:

Envoyé par foetus

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 :whistle:).

Il n'y a pas de sauf ;)
24/04/2018, 12h17
Matt_Houston
Citation:

Envoyé par Jinkas99

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.
24/04/2018, 12h27
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.
24/04/2018, 12h36
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.

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

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:

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

par :

Code:

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

Bonjour Pyramidev.

Est ce qu'il faut mettre un & devant minAndMax

Code:

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

dans la fonction main.

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

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; }

Bonjour,

Citation:

Envoyé par Jinkas99

Est ce qu'il faut mettre un & devant minAndMax

Code:

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).
Citation:
Envoyé par Jinkas99
Est ce que la fonction minmax2 s'écrit comme ceci?
Code:

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.

25/04/2018, 16h19
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?