Quelle est la règle de travail de ce programme, Explanation?

Je suis un peu confus dans ce programme que je veux si quelqu’un pouvait m’expliquer la fonctionnalité de ce code et la sortie, je reçois la sortie de ce programme en tant que tel

1 1 2 2 3 3 

Tout ce que je veux savoir la règle de travail de ces deux fonctions comment ils calculent les valeurs?

 #include  #include  #include  int M(const int n); int F(const int n) { return(n==0)?1:nM(F(n-1)); } int M(const int n) { return (n==0)?0:nF(M(n-1)); } int main() { int i; for(i=0;i<6;i++) { printf("%2d\n",F(i)); } printf("\n"); return 0; } 

Considérez for

 for(i=0;i<6;i++) { printf("%2d\n",F(i)); } 

Réponse courte:

F(0) => 1;

F(1)=> 1 - M(F(0))

 when F(0):1 then F(1) = 1 - M(1) go to calculate M(1), but we start from 0, M(0)= 0; M(1) = 1- F(M(0)) = 1- F(0) = 1-1=0; last we have M(1) = 0; and as F(1) = 1-M(1) = 1-0=1 last we have: F(1)=1 

Plus achevé:

Laissez voir F() façon de travailler. la dernière commande de F() , return(n==0)?1:nM(F(n-1));

élargi à

 if (n==0){ return 1; }else{ return nM(F(n-1)); } 

En premier lieu pour l'itération i:0 , nous voulons F(0) car n est égal à zéro, ( n:0 ), le if (n==0) est vrai, return 1; est exécuté et la valeur de F(0) doit être 1.

pour la deuxième itération, nous voulons F(1) , pour cela if (n==0) est faux et sinon bloc est exécuté.

comme maintenant le n:1 , F(1) = 1 - M (F(0)) .

Dans l'itération précédente, nous avons F(0)=1 , OK, nous pouvons maintenant recréer l'équation ou l'équation: F(1) = 1 - M(1) , il est évident que si nous avons la valeur de M(1) , il suffit de la mettre à la dernière formule, F(1) ont été résolus.

pour cela, nous devons développer la fonction M() .

De même, nous pouvons écrire pour M() .

 if (n==0){ return 0; }else{ return nF(M(n-1)); } 

M(0) = 0;

M(1)= 1- F(M(0))= 1- F(0) = 1 - 1=0;

maintenant nous avons M(1) = 0; en le mettant sur le F(1) = 1 - M(1) on obtient F(1) = 1 .

Maintenant, les deux premières paires de 1 en sortie de votre code sont calculées manuellement.

pour d'autres, faites-le encore et encore.

Comme suggéré dans les commentaires, essayez de tracer le code à la main, je vais parcourir les deux premières itérations avec vous pour que vous ayez une idée.

Lorsque votre programme démarre, il appelle votre fonction main et commence à exécuter la boucle for comme suit:

 i=0 => calls F(n=0) => is n==0 true? Yes => return 1 => print 1 i=1 => calls F(n=1) => is n==0 true? No => then 1-M(F(0)) => F(0) calculated from the previous iteration to return a value of 1 => call M(n=1) => is n==0 true? No => then 1-F(M(0)) => M(0) returns 0 since n==0 is true => then 1-F(M(0)) is equal to 1-F(0) => we calculated F(0) to return 1 => so 1-F(0) return 0 from M => take the return back to 1-M(F(0)) => 1-0 = 1 => print 1 

Ne soyez pas frustré, car ce que vous demandez serait en réalité beaucoup plus facile à comprendre avec un patient. Je vous recommande vivement de tenir un stylo et du papier et de commencer à vous repérer.

  1. Aller itération par itération comme je l’ai fait.
  2. Appelez chaque fonction en fonction du stream correct des conditions if.
  3. Lorsque vous appelez une fonction, marquez où il vous rest du code pour accéder à cette fonction, de sorte qu’une fois qu’il renvoie une valeur, vous savez exactement où placer la valeur renvoyée.

Paix de papier, patience et trace.