Discussion :

[Amnael]

Bonsoir; j'aurais besoin d'un coup de main pour comprendre ce qui ne vas pas dans le code suivant; je précise que je débute en C; et des notions comme les pointeurs restent très très vagues pour moi.


Je vais vous raccourcir au maximum pour cerner le soucis.

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
 
void couplesAmis(int n1, int n2,int coupleAmi[100][2]);
 
int main()
{
int coupleAmi[100][2]={{0}}; /*j'initialise mon tableau à 0*/
 
/*je rentre dans un switch*/
 
case 5:
        nb=saisirNombre();
        n2=saisirNombre();
        couplesAmis(nb,n2,coupleAmi);
        printf("Les couples amis sont: \n");
        for (k=0;k<100;k++)
        {
            if (coupleAmi[k][0]!=0 && coupleAmi[k][1]!=0)
        {
            printf("%d et %d \n",coupleAmi[k][0],coupleAmi[k][1]);
        }
        }
        break;
 
/*fin du main*/
return 0
}
 
 
 
void couplesAmis(int n1,int n2, int coupleAmi[100][2])
{
    int k;
    int k2;
    char estAmis;
    int cpt=0;
    for (k=n1;k<n2;k++)
    {
        k2=n2;
        do
        {
        estAmis=sontAmis(k,k2);
        if (estAmis=='o')
        {
            coupleAmi[cpt][0]=k;
            coupleAmi[cpt][1]=k2;
            cpt=cpt+1;
        }
        k2=k2-1;
        }while(k2!=k);
    }
}

Il n'y a aucune erreur à la compilation. Le soucis est à l'exécution
Lorsque je rentre dans couplesAmis, pour une raison ou une autre je n'en ressors jamais...il ne me semble pas prendre une boucle infini dans mon void; la seule explication plausible est donc que je fais un mauvais passage de paramètre sur mon tableau à deux dimensions.

Je me suis cassé la tête là dessus toute l'aprèm et je ne vois toujours pas la solution.

Merci à vous.

[Médinoc]

Essaie en remplaçant }while(k2!=k); par }while(k2>k);.
Je ne dis pas que le problème est là, mais c'est ce qui me parait le plus fragile sans regarder plus en profondeur.

PS: Je pense que dans ton cas, un tableau de structures pourrait peut-être être plus facile d'emploi qu'un tableau à deux dimensions.

[Amnael]

Bonsoir,

après modification, le problème persiste toujours.


Je n'ai pas vu les "structures" en réalité notre prof nous fais pas voir beaucoup de code mais plutôt le coté vérification, spécification avec pfp et compagnie..au final on code très peu.

[Obsidian]

Essaie en remplaçant }while(k2!=k); par }while(k2>k);.
Je ne dis pas que le problème est là, mais c'est ce qui me parait le plus fragile sans regarder plus en profondeur.

C'est ce que j'avais écrit également avant de me rétracter parce que la boucle for du niveau au-dessus garantit que cela ne peut pas arriver. Cela dit, c'est une bonne idée de prendre l'habitude de toujours utiliser « < » et « > » dans les comparaisons d'indices de boucle.

Bonsoir, après modification, le problème persiste toujours.

Il est possible que tu aies un dépassement de tableau, ce qui écrase les indices de boucles se trouvant juste après. Il nous faudrait le programme entier pour trancher.

[Amnael]

Voilà le code entier mais je ne crois pas que cela vous apporte des choses en plus; l'essentiel est présenté au dessus.

Il y a surement des trucs mal fait et des trucs inutiles; j'ai pas regardé en détail du moment que ça marche à l'exe pour le moment..; le problème vient seulement dans le dernier cas.

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
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
#include <stdio.h>
#include <stdlib.h>
 
int sommeDiv(int nb);
int saisirNombre(void);
char estParfait(int nb);
int parfaitPlusProche(int nb);
void parfIntervalle(int n1, int n2,int parfait[],int N);
char sontAmis(int n1, int n2);
void couplesAmis(int n1, int n2,int coupleAmi[100][2]);
 
 
int main()
{
    int choix;
    int nb;
    char parf;
    int n2;
    char amis;
    int N;
    int parfait[100]={0};
    int k;
    int coupleAmi[100][2]={{0}};
 
    do
    {
    printf("Choisissez: \n");
    printf("1-Un entier est il parfait ?\n");
    printf("2-Chercher le parfait le plus proche\n");
    printf("3-Tous les parfaits d'un intervalle\n");
    printf("4-Deux entiers sont ils amis ?\n");
    printf("5-Toutes les paires d'amis d'un intervalle\n");
    printf("Tapez 6 pour s'arrêter\n");
    printf("Votre choix: ");
    scanf("%d",&choix);
 
    switch(choix)
    {
    case 1:
        nb=saisirNombre();
        parf=estParfait(nb);
        if (parf=='o')
        {
            printf("%d est un nombre parfait\n",nb);
        }
        if (parf=='n')
        {
            printf("%d n'ets pas un nombre parfait\n",nb);
        }
        break;
    case 2:
        nb=saisirNombre();
        n2=parfaitPlusProche(nb);
        printf("%d est le parfait le plus proche de %d\n",n2,nb);
        break;
    case 3:
        nb=saisirNombre();
        n2=saisirNombre();
        N=100;
        parfIntervalle(nb,n2,parfait,N);
        for (k=0;k<100;k++)
        {
            if (parfait[k] !=0)
        {
            printf("%d ",parfait[k]);
        }
        }
        printf("sont des parfait de l'intervalle [%d-%d]\n",nb,n2);
        break;
    case 4:
        nb=saisirNombre();
        n2=saisirNombre();
        amis=sontAmis(nb,n2);
        printf("%d et %d ",nb,n2);
        if (amis=='o')
        {
            printf("sont amis\n");
        }
        if (amis=='n')
        {
            printf("ne sont pas amis\n");
        }
        break;
    case 5:
        nb=saisirNombre();
        n2=saisirNombre();
        couplesAmis(nb,n2,coupleAmi);
        printf("Les couples amis sont: \n");
        for (k=0;k<100;k++)
        {
            if (coupleAmi[k][0]!=0 && coupleAmi[k][1]!=0)
        {
            printf("%d et %d \n",coupleAmi[k][0],coupleAmi[k][1]);
        }
        }
        break;
    case 6:
        printf("Arrêt \n");
        break;
    default:
        printf("Erreur\n");
        break;
    }
    }while (choix!=6);
    return 0;
}
 
int saisirNombre(void)
{
    int n;
    printf("Entrez un nombre: ");
    scanf("%d",&n);
    return n;
}
 
int sommeDiv(int nb)
{
    int k;
    int somme=0;
    for (k=1;k<=(nb/2);k++)
    {
        if (nb%k==0)
        {
            somme=somme+k;
        }
    }
    return somme;
}
char estParfait(int nb)
{
    int somme;
    char parfait='n';
    somme=sommeDiv(nb);
    if (somme==nb)
    {
        parfait='o';
    }
    return parfait;
}
 
int parfaitPlusProche(int nb)
{
    int T[2]={0, 0};
    char parf='n';
    int plusProche;
    int k=nb;
    do
    {
        parf=estParfait(k);
        k=k-1;
    }while(parf=='n');
    T[0]=k;
    k=nb;
    do
    {
        parf=estParfait(k);
        k=k+1;
    }while(parf=='n');
    T[1]=k;
    plusProche=T[0];
    if (nb-T[0] >= T[1]-nb)
    {
        plusProche=T[1];
    }
    return plusProche;
}
 
void parfIntervalle(int n1,int n2,int parfait[],int N)
{
    int k;
    int cpt=0;
    char test;
    for (k=n1;k<=n2;k++)
    {
        test=estParfait(k);
        if (test=='o')
        {
            parfait[cpt]=k;
            cpt=cpt+1;
        }
    }
}
 
 
char sontAmis(int n1, int n2)
{
    int s1;
    int s2;
    char amis='n';
    s1=sommeDiv(n1);
    s2=sommeDiv(n2);
    if (s1==s2)
    {
        amis='o';
    }
    return amis;
}
 
void couplesAmis(int n1,int n2, int coupleAmi[100][2])
{
    int k;
    int k2;
    char estAmis;
    int cpt=0;
    for (k=n1;k<n2;k++)
    {
        k2=n2;
        do
        {
        estAmis=sontAmis(k,k2);
        if (estAmis=='o')
        {
            coupleAmi[cpt][0]=k;
            coupleAmi[cpt][1]=k2;
            cpt=cpt+1;
        }
        k2=k2-1;
        }while(k2>k);
    }
}

[Obsidian]

Ton programme compile sans erreur à part le warning de la fonction parfIntervalle (paramètre N inutilisé). Cela dit, ce n'est pas pour cela qu'il en est forcément exempt à l'exécution.

En particulier, quel intervalle utilises-tu quand tu saisis ton nombre de départ et celui d'arrivée ? Je peux spécifier des intervalles très grands, par exemple de 1000 à 3000, et comme ton tableau ne contient que 100 entrées, j'arrive à le dépasser.

[Amnael]

Oui; je m'étais servi de N dans une version antérieure; j'ai modifié et j'ai oublié d'enlever; mais comme tu dis il est inutilisé donc rien à voir^^

Pour être sur de ne pas dépasser l'intervalle j'ai fait un simple test sur 50 valeur donc impossible de dépasser la capacité; du moins je ne pense pas.

Je vais essayer d'augmenter la taille de mon tableau.

EDIT: effectivement le problème venait de la taille; je n'avais pas pensé que pour un nombre je pouvais avoir plusieurs amis...j'ai des résultat étonnant du genre 2 et 47 sont amis; je me suis peut être trompé dans mon algo ou alors c'est bien ça; m'enfin le soucis est résolu quand au problème qui m'amenait là; merci beaucoup !