dire si ordre croissant decroissant desordre ou égaux dans un vecteur avec nbres saisis par user

**exercicec** · 15/11/2015, 22h16

Bonjour,

j'ai fait un tableau ou j'entre des nombres et je dois dire si ç'est ordre décroissant ou croissant ou égaux ou désordre.
j'ai essayé un peu mais ça marche pas du tout là
donnez moi des indices et ce que j'ai pas bien fait
merci

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
44
45
46
47
48
49
50
51
52
53
54
55
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int va[50];// vecteur
   int i = 0;//compteur
   int nbel = 0;//nombre de cases du vecteur
 
 
    printf("Entrez le nombre de cases utilisees :  ");
    fflush(stdin);
    scanf("%d", &nbel);
    for( i = 0; i < nbel; i++)
    {
        printf("\nEntrez la valeur de la case %d : \t", i);
        fflush(stdin);
        scanf("%d", &va[i]);
    }
 
     for( i = 0; i < nbel; i++)
     {
          printf("%d\t",va[i]);
     }
    printf("\n");
 
    for( i = 0;i < nbel ;i++ )
    {
        if( va[i] < va[i+1])
            printf("ordre croissant");
    }
    for( i = 0;i < nbel ;i++ )
    {
        if(va[i] == va[i+1])
            printf("tous egaux");
    }
 
 
    for( i = nbel -1; i > 0; i--)
    {
        if( va[i] > va[i-1])
            printf("ordre decroissant");
    }
    for( i = nbel -1; i > 0; i--)
 
    {
        if ( va[i] != va[i-1])
        printf("dans le desordre");
    }
 
 
 
        return 0;
}

**exercicec** · 15/11/2015, 23h47

[QUOTE=exercicec;8441144]Bonjour,

j'ai fait un tableau ou j'entre des nombres et je dois dire si ç'est ordre décroissant ou croissant ou égaux ou désordre.
j'ai essayé un peu mais ça marche pas du tout là
donnez moi des indices et ce que j'ai pas bien fait
merci

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int va[50];// vecteur
   int i = 0;//compteur
   int nbel = 0;//nombre de cases du vecteur
 
 
    printf("Entrez le nombre de cases utilisees :  ");
    fflush(stdin);
    scanf("%d", &nbel);
    for( i = 0; i < nbel; i++)
    {
        printf("\nEntrez la valeur de la case %d : \t", i);
        fflush(stdin);
        scanf("%d", &va[i]);
    }
 
     for( i = 0; i < nbel; i++)
     {
          printf("%d\t",va[i]);
     }
    printf("\n");
 
    for( i = 0;i <= nbel-2 ;i++ )
    {
        if( (va[i] < va[i+1])&&!(va[i]>va[i+1]))
        {
            printf("ordre croissant");
        }
 
        else
 
            if(va[i] == va[i+1])
                {
                    printf("tous egaux");
                }
            else
 
 
 
                if( (va[i] > va[i+1])&& !(va[i]<va[i+1]))
                {
                     printf("ordre decroissant");
 
                }
                else
 
                    if (( va[i] != va[i+1])&&!(va[i]>va[i+1])&&!(va[i]<va[i+1]))
                    {
                        printf("dans le desordre");
                    }
    }
 
 
 
 
 
 
 
        return 0;
}

**foetus** · 16/11/2015, 00h27

Normal: tu t'y prends comme un manche

C'est pourtant simple: sors papier crayon ... et réfléchis.

Pseudo-Code:

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
    /* Post condition: nbel >= 2 */
 
    unsigned short index = 0;
    bool tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] < tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre croissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] > tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre décroissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] == tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) {
        /*même valeur*/
    } else {
        /*capharnaüm*/
    }

**exercicec** · 16/11/2015, 00h57

Envoyé par foetus

Normal: tu t'y prends comme un manche

C'est pourtant simple: sors papier crayon ... et réfléchis.

Pseudo-Code:

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
/* Post condition: nbel >= 2 */
 
    unsigned short index = 0;
    bool tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[i] < tab[i + 1]);
        ++i;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre croissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[i] > tab[i + 1]);
        ++i;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre décroissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[i] == tab[i + 1]);
        ++i;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) {
        /*même valeur*/
    } else {
        /*capharnaüm*/
    }

est ce que le code que jmis est bon ou pas ? ou ç'est de la chance qu'il marche ? car ça marche pour croissant et décroissant et égaux mais pas pour desordre

**exercicec** · 16/11/2015, 01h12

Envoyé par exercicec

est ce que le code que jmis est bon ou pas ? ou ç'est de la chance qu'il marche ? car ça marche pour croissant et décroissant et égaux mais pas pour desordre

j'ai modifié le code un peu plus haut dans les messages

**foetus** · 16/11/2015, 01h36

Envoyé par exercicec

est ce que le code que jmis est bon ou pas ? ou ç'est de la chance qu'il marche ? car ça marche pour croissant et décroissant et égaux mais pas pour desordre

Envoyé par exercicec

j'ai modifié le code un peu plus haut dans les messages

Désolé, tu t'y prends comme un manche, 2ième fois

1) Tu ne dois pas utiliser une boucle pour: connais-tu la différence entre les boucles pour, tant que, faire tant que?

2) Effectivement tu peux supprimer le booléen en le remplaçant par le test, mais il faut tester après si ton index a parcouru toute ta collection.

3) Tu ne peux pas regrouper les 3 tests en 1 seule boucle, parce que ta collection ne pas être à la fois en ordre croissant, en ordre décroissant, avoir toutes les mêmes valeurs:

Mais dans quel espace-temps vis-tu? avec quel système mathématique?

À moins que je ne vois pas le truc

de comment regrouper les 3 tests (parmi 4 je rappelle) en 1 (<- comme le shampoing)

Si ta liste est en ordre croissant, pour chaque couple de cases consécutives, le test "en ordre décroissant" est faux, le test "avoir toutes les mêmes valeurs" est faux, et le test "en désordre" est faux

**exercicec** · 16/11/2015, 01h38

Envoyé par exercicec

est ce que le code que jmis est bon ou pas ? ou ç'est de la chance qu'il marche ? car ça marche pour croissant et décroissant et égaux mais pas pour desordre

j'ai modifié le code un peu plus haut dans les messages

**exercicec** · 17/11/2015, 18h15

Envoyé par foetus

Normal: tu t'y prends comme un manche

C'est pourtant simple: sors papier crayon ... et réfléchis.

Pseudo-Code:

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
    /* Post condition: nbel >= 2 */
 
    unsigned short index = 0;
    bool tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] < tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre croissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] > tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) { /*ordre décroissant*/ return; }
 
    index = 0;
    tmp_bool = true;
 
    while (((index + 1) < nbel) && tmp_bool) {
        tmp_bool = (tab[index] == tab[index + 1]);
        ++index;
    }
 
    if (tmp_bool && ((index + 1) == nbel)) {
        /*même valeur*/
    } else {
        /*capharnaüm*/
    }

je ne comprends pas ton pseudocode on a fait que 2 mois de langage c à l'école et je vois pas ce que ç'est bool tmpbool = true

**Sve@r** · 17/11/2015, 21h20

Envoyé par exercicec

je ne comprends pas ton pseudocode on a fait que 2 mois de langage c à l'école et je vois pas ce que ç'est bool tmpbool = true

Bonjour

C'est pourtant pas compliqué: ta suite est croissante si tous les éléments observent la relation d'ordre "element[i] < element[i+1]". Donc elle n'est pas croissante si un seul de ses éléments ne l'observe pas. Donc tu dis qu'elle est croissante par défaut et tu cherches si un de ses éléments brise cette relation. Si tu le trouves alors elle ne l'est pas sinon elle l'est.

Punaise, tu devrais sérieusement mettre ton cerveau à contribution. Surtout que tu fais peut-être du C depuis seulement 2 mois (quoique moi après 2 mois je faisais des trucs autrement plus complexes !!!) mais la logique mathématique qui sert de base au raisonnement, elle, tu l'as depuis le primaire !!!

Et pour ta question: Tu c'est ce qu'est un booléen (ou en tout cas tu devrais savoir car c'est une notion mathématique enseignée au lycée). Tu sais ce que veut dire "true". Donc...

**Iradrille** · 18/11/2015, 05h10

Envoyé par foetus

3) Tu ne peux pas regrouper les 3 tests en 1 seule boucle, parce que ta collection ne pas être à la fois en ordre croissant, en ordre décroissant, avoir toutes les mêmes valeurs:

Dans dans quel espace-temps? avec quel système mathématique?

[0, 0, 0] Cette collection :
* ne contient que des nombres positifs (mais pas strictement positifis)
* ne contient que des nombres négatifs (mais pas strictement négatifs - ok, je suis pas sur de celle là)
* ne contient que des nombres nuls
* est croissante (mais pas strictement croissante)
* est décroissante (mais pas strictement décroissante)
* toutes les valeurs qu'elle contient sont égales.

Mais sinon effectivement, ça n'a pas de sens de faire les 3 tests en même temps.

**foetus** · 18/11/2015, 10h00

D'ailleurs je me demande si on ne peut pas faire un truc du style

(.... tout en gardant mon booléen très scolaire

)

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
    /* Post condition: nbel >= 2 */
 
    unsigned short index = 1;
    bool tmp_bool = true;
 
    if (tab[0] != tab[1]) {
        if (tab[0] > tab[1]) {
            while (((index + 1) < nbel) && tmp_bool) {
                tmp_bool = (tab[index] > tab[index + 1]);
                ++index;
            }
 
            if (tmp_bool && ((index + 1) == nbel)) {
                /*ordre croissant*/
            } else {
                /*capharnaüm*/
            }
        } else {
            while (((index + 1) < nbel) && tmp_bool) {
                tmp_bool = (tab[index] < tab[index + 1]);
                ++index;
            }
 
            if (tmp_bool && ((index + 1) == nbel)) {
                /*ordre décroissant*/
            } else {
                /*capharnaüm*/
            }
        }
    } else {
        while (((index + 1) < nbel) && tmp_bool) {
            tmp_bool = (tab[index] == tab[index + 1]);
            ++index;
        }
 
        if (tmp_bool && ((index + 1) == nbel)) {
            /*même valeur*/
        } else {
            /*capharnaüm*/
        }
    }

Et ainsi avec l'exemple d'Iradrille et en fonction de l'ordre des tests, on aurait 1 des 3 cas.

**Sve@r** · 18/11/2015, 18h38

Envoyé par Iradrille

[0, 0, 0] Cette collection :
* ne contient que des nombres positifs (mais pas strictement positifis)
* ne contient que des nombres négatifs (mais pas strictement négatifs - ok, je suis pas sur de celle là)
* ne contient que des nombres nuls
* est croissante (mais pas strictement croissante)
* est décroissante (mais pas strictement décroissante)
* toutes les valeurs qu'elle contient sont égales.

C'est un cas particulier et unique. Tu peux donc le détecter dans un test "à part".

Sinon perso j'écrirais une fonction pour chaque possibilité. Ca va t'alléger le code...

Exemple

Code c :

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

1
2
3
4
5
6
7
int isPositifNegatif(int vecteur[], int nb, int sens /* vaudra "-1" si on cherche du "tout négatif", et "+1" si on cherche du "tout positif" */)
{    
    int i;
    for (i=0; i < nb; i++)
        if ((vecteur[i] * sens) < 0) return 0;
    return 1;
}

PS: cerise sur le gâteau, cette fonction vaut "vrai" pour (0, 0, 0) dans les deux possibilités (négatif/positif) ce qui laisse penser que finalement, si on programme bien les autres fonctions, le cas (0, 0, 0) n'aura pas besoin d'être à part...

**Iradrille** · 18/11/2015, 19h09

Envoyé par Sve@r

C'est un cas particulier et unique. Tu peux donc le détecter dans un test "à part".

PS: cerise sur le gâteau, cette fonction vaut "vrai" pour (0, 0, 0) dans les deux possibilités (négatif/positif) ce qui laisse penser que finalement, si on programme bien les autres fonctions, le cas (0, 0, 0) n'aura pas besoin d'être à part...

Ce n'est pas réellement un cas à part, c'est juste la différence entre des comparaisons ('<=' / '>=') et comparaisons strictes ('<' / '>'). Mais c'était une simple remarque sur le fait qu'une suite de nombres puisse être croissante et décroissante en même temps.

Envoyé par Sve@r

Sinon perso j'écrirais une fonction pour chaque possibilité. Ca va t'alléger le code...

Ou plus générique : 2 fonctions l'une traitant les nombres 2 par 2 pour tester si la suite est croissante / décroissante / constante; une 2eme traitant les nombres 1 par 1 pour tester si les nombres sont négatifs / positifs / nuls.

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
int eq_int(int lhs, int rhs) { return lhs == rhs; }
int lt_int(int lhs, int rhs) { return lhs < rhs; }
int gt_int(int lhs, int rhs) { return lhs > rhs; }
 
int gz_int(int n) { return n > 0; }
int lz_int(int n) { return n < 0; }
 
int all_by_pair_int(int const* start, int const* end, int(*cmp)(int, int)) {
	if (end - start < 2) {
		return 1;
	}
	--end;
	while (start != end && cmp(start[0], start[1])) {
		++start;
	}
	return start == end;
}
 
int all_int(int const* start, int const* end, int(fct)(int)) {
	if (start >= end) {
		return 1;
	}
	while (start != end && fct(*start)) {
		++start;
	}
	return start == end;
}
 
void test(int const* start, unsigned size) {
	printf("[ ");
	int i = 0;
	for (; i < size; ++i) {
		printf("%d ", start[i]);
	}
	printf("]: ");
 
	int const *end = start + size;
	int croissant = all_by_pair_int(start, end, lt_int);
	int decroissant = all_by_pair_int(start, end, gt_int);
	int egal = all_by_pair_int(start, end, eq_int);
	int gz = all_int(start, end, gz_int);
	int lz = all_int(start, end, lz_int);
 
	printf("croissant: %d; decroissant: %d; egal: %d, >0: %d, <0: %d\n", croissant, decroissant, egal, gz, lz);
}
 
int main() {
 
	int c0[] = { 1, 2, 3 };
	int c1[] = { -2, -2, -2 };
	int c2[] = { 1, 0, -1 };
	int c3[] = { 0, 2, 1 };
 
	test(c0, 0);
	test(c0, 1);
	test(c0, 3);
	test(c1, 3);
	test(c2, 3);
	test(c3, 3);
 
	return 0;
}

**Sve@r** · 18/11/2015, 21h55

Envoyé par Iradrille

Ou plus générique : 2 fonctions l'une traitant les nombres 2 par 2 pour tester si la suite est croissante / décroissante / constante; une 2eme traitant les nombres 1 par 1 pour tester si les nombres sont négatifs / positifs / nuls.

Mouais. Effectivement super pro et très maniable. Mais tu nous mets du pointeur de fonction. Et le pauvre "exercicec" qui a 2 mois de C et qui n'a même pas appris le pointeur de base, lui, il va paner que dalle...

PS: dans mon post précédent j'ai mal lu et j'ai répondu comme si tu étais le PO.

dire si ordre croissant decroissant desordre ou égaux dans un vecteur avec nbres saisis par user

C

Discussions similaires

Partager

Partager