slt a tous
voila g un probléme pour resoudre cet algorithme,
merci de m'aider:
on remarque que:
12*42=21*24
12*63=21*36
21*48=12*84
 
1-Ecrire un algorithme qui demande à l'utilisateur de saisir deux entiers à deux chiffres chacun et de tester si les deux vérifient cette propriété ou non.
 
2-Si on désir modifier l'algorithme précédent de telle sorte qu'il donne directement tous les entiers vérifiant cette propriété sans l'intervention de l'utilisateur. Ecrire cet algorithme
 

On ne fait pas les exercices de cours. et ce n'est pas compliqué. Du tout.

tu as une contrainte de langage pour faire cet algo ?

nn  c juste en algorithmique

allez, chuis de bon poil, on va le faire ensemble.
Il faut raconter par étape ce qu'il faut faire pour tester l'égalité.
 
Je commence
1. demander un entier à l'utilisateur
2. vérifier qu'il est >9 et <100
3. si non revenir à 1.
4. si oui, l'enregistrer dans "A"
5. demander un deuxième entier à l'utilisateur
6. vérifier qu'il est >9 et <100
7. si non revenir à 1.
8. si oui, l'enregistrer dans "B"
 
à toi

ok stitech, mais je suis tous différent de toi
voila ce que je fais:
je dois recup: A,B,C et D de type entier d'un seul chiffre
:AB1, AB2, CD1, CD2 de type entier de deux chiffres
A==A*10 " car dizaine"
C==C*10
AB1=A+B
CD1=C+D
TOTAL1=AB1*CD1
 
A==A/10
B==B*10
C==C/10
D==D*10
AB2=A+B
CD2=C+D
TOTAL2=AB2*CD2
 
si TOTAL1=TOTAL2
alors la propriété est verifié
 
c'est une bonne idé n'est ce pas???

non ce n'est pas une bonne idée

ce n'est pas à ton utilisateur de décomposer les nombres au moment de la saisie mais à ton programme de le faire.

tu récupères le premier nombre P et le second nombre S
(tu vérifies qu'ils n'ont que 2 chiffres)

puis tu calcules :
la dizaine de P que tu nommes A
l'unité de P que tu nommes B
la dizaine de S que tu nommes C
et l'unité de S que tu nommes D

et après tu fais ce que tu viens d'écrire (et encore ce n'est pas DU TOUT écrit proprement ni correct mais au moins tu es sur la piste)

ah oui tu as droit,  
merci stitch+ pour votre aide

pour être sûre que tu as bien compris, dis moi comment tu calcules la dizaine et l'unité stp

je déclare  8 variables de deux chiffres A1,B1,C1,D1,AB1,AB2,CD1,CD2
               2 variable d'un seul chiffre A2,C2,A,B,C,D
et ca sera:
A1==A*10 " car dizaine"
C1==C*10
AB1=A1+B
CD1=C1+D
TOTAL1=AB1*CD1
 
A==A/10
B1==B*10
C==C/10
D1==D*10
AB2=A+B1
CD2=C+D1
TOTAL2=AB2*CD2
 
si TOTAL1=TOTAL2
alors la propriété est verifié

non.

tu n'as pas besoin d'autant de variables.
tu ne sais pas calculer la dizaine d'un nombre à 2 chiffres.

Tu n'as besoin que de 2 variables au mieux, 6 pour être à l'aise :
P et S les nombres donnés par l'utilisateur
A, B, C, D les chiffres que tu calcules à partir de P et S

et tu ne peux pas contraindre une variable sur son nombre de chiffres.
Sur son type oui (ici on ne veut que des entiers).

Si je te demande de calculer la dizaine de 84, quelle opération fais tu ? quel calcul fais tu ?
même chose pour l'unité de 84.

DSL il ya une faute :
A1==A*10 " car dizaine"
C1==C*10
AB1=A1+B
CD1=C1+D
TOTAL1=AB1*CD1
 
B1==B*10
D1==D*10
AB2=A+B1
CD2=C+D1
TOTAL2=AB2*CD2
 
si TOTAL1=TOTAL2
alors la propriété est verifié

tu peux lire le message que j'ai écrit et répondre aux questions stp

j'espére que j'ai trouvé la solution:
A=84DIV10  ====>8
B=84MOD10 ====>4

tu tiens le truc
maintenant décris comment à partir de 84 tu calcules le nombre 48
généralises en écrivant Y au lieu de 84

et après tu n'as plus qu'à raconter les étapes les unes après les autres
- la saisie
- la décomposition des unités / dizaines
- les calculs des deux multiplications
- la comparaison

voila je vous écrit tous le programme:
a,b,c,d: entier inférieur ou = 9
P,S: entier inférieur ou =99
 
saisie de ,S
 
a= P DIV 10
b= P MOD 10  
c= S DIV 10
d= SMOD 10
 
P=((a*10)+b)*((c*10)+d)
S=((b*10)+a)*((d*10)+c)
 
si P=S alors la propriété est verifie
 
????????????

 
bon ben voilà, maintenant passons à la question suivante.
 
il faut que tu considères ce que tu viens de faire comme une fonction que tu pourras utiliser.

j'ai coincé, vous pouvez m'aider encore??

j'ai reflechie de faire 4 boucle:
 
pour i de 0 à 9 faire
  pour j de 0 à 9 faire
     a=a+i;
     b=b+j;        
        pour k de 0 à 9 faire
            pour e de 0 à 9 faire
               c=c+k;
               d=d+e;
                  P=((a*10)+b)*((c*10)+d)
                  S=((b*10)+a)*((d*10)+c)  
             fin pour
           fin pour
         fin pour
       fin pour

on vient d'écrire l'algo suivant :
 
déclaration des variables
soit les variables entières a,b,c,d, P et S.
 
saisie des valeurs
saisie de P
vérification du fait que P soit un entier sur 2 chiffres : P>9 et P<100
si non on recommence la saisie de P
saisie de S
vérification du fait que P soit un entier sur 2 chiffres S>9 et S<100
si non on recommence la saisie de S
 
vérification de la propriété
a= P DIV 10
b= P MOD 10  
c= S DIV 10
d= S MOD 10
 
P=((a*10)+b)*((c*10)+d)
S=((b*10)+a)*((d*10)+c)
 
on renvoie (P==S)
si l'égalité est vraie ça dit vrai, si l'égalité est fausse, ça dit faux  

 
 
on peut considérer que la partie en rouge est une fonction "jeTeste(P,S)" : tu lui donnes P et S, elle te renvoie si P et S vérifie la propriété demandée.
 
par exemple,  jeTeste(12,42) renvoie vrai et jeTeste(12,13) renvoie faux.
 
Maintenant, essaye de réfléchir à comment essayer toutes les valeurs de P et de S
 
 
 

NON
 
tu dois penser à des nombres à 2 chiffres comme paramètres en entrée

voila ce que j'ai fais:
 
P=0, S=0
 pour i de 10 à 99 faire
   pour i de 10 à 99 faire
     P=P+i
     S=S+j
     jeteste (P,S)
   fin pour
  fin pour

"presque"
plus simplement :
 
pour P de 10 à 99 faire
  pour S de 10 à 99 faire
     Si (jeTeste(P,S)) alors afficher ( P,S)
  fin pour
fin pour
 
surtout il faut penser à ajouter quelque chose pour afficher ou enregistrer les valeurs qui "marchent" sinon ton algo ne sert à rien

C'est  beau l'instinct maternel. Quelle patience, quel sens de l'abnégation.

ouais enfin, tant que l'abnégation ne me mène pas dans la cat php, ma patience tiendra le choc.

wé voila on est fini, je vous remerci encore une fois stitech+
trop sympa la méthode

Je viens de lire aussi, quelle patience en effet !