<mosaic.cnfolio.com>
PROGRAM
  1. /* START
  2.  
  3. # Declare Function ‘ Pidgey_1() ’
  4.  
  5.             SET Integer Candy_P as 12
  6.             SET  Integer transferCount , evolvecount as 0  AND canStillEvolve AND shouldTransfer as 1
  7.  
  8.             DISPLAY Enter Number Of Pidgey
  9.             READ integer
  10.  
  11.             DISPLAY Enter Number Of Candy
  12.             READ integer
  13.  
  14.                IF Pidgey OR PidgeyCandies is Greater than 9999
  15.                   THEN
  16.                         DISPLAY Please make sure you've filled in all input fields. Inputs take values from 0 to 9999.
  17.  
  18.                   END IF
  19.  
  20.                ELSE
  21.  
  22.                      WHILE canStillEvolve is TRUE
  23.       
  24.                  IF PidgeyCandies DIVIDED by Candy_P AND Pidgeys is equal to 0
  25.                                THEN
  26.                                     canStillEvolve Return FALSE
  27.  
  28.                            END IF
  29.  
  30.                            ELSE
  31.  
  32.                                  DECREMENT Pidgeys
  33.                                  SUBSTRACT  Candy_P from PidgeyCandies
  34.                                  INCREMENT PidgeyCandies
  35.                                  INCREMENT evolvecount
  36.  
  37.                            IF Pidgey is equal to 0
  38.                                THEN
  39.                                        BREAK
  40.                            END IF
  41.  
  42.  
  43.                      ENDWHILE
  44.  
  45.  
  46.                      WHILE shouldTransfer is TRUE
  47.          
  48.                               IF SUM of PidgeyCandies AND Pidgey is less than SUM of Candy_P AND 1 OR Pidgey is equal to 0
  49.  
  50.                                  THEN
  51.                                           shouldTransfer is FALSE
  52.                                           BREAK
  53.                               ENDIF
  54.  
  55.                            WHILE PidgeyCandies is less than Candy_P
  56.  
  57.                               INCREMENT transferCount
  58.                               DECREMENT Pidgeys
  59.                               INCREMENT PidgeyCandies
  60.       
  61.                            ENDWHILE
  62.  
  63.                                  DECREMENT Pidgeys
  64.                                  SUBSTRACT Candy_P From PidgeyCandies
  65.                                  INCREMENT PidgeyCandies
  66.                                  INCREMENT evolvecount
  67.                      ENDWHILE
  68.    
  69.                SET integer eggsToUse equal to COMPUTE (evolvecount * 35/60) is divided by 30
  70.                SET integer xpToGain equal to COMPUTE as MULTYPLY evolvecount with 1000
  71.                SET float evolveTime equal to COMPUTE as MULTIPLY evolvecount with 0.35
  72.  
  73.                      // OUTPUT
  74.  
  75.                        PRINT  1. Transfer before activating a Lucky Egg
  76.                        DISPLAY transferCount
  77.                        PRINT 2. Use Egg, Then Evolve
  78.                        DISPLAY evolvecount
  79.                        PRINT Recommendation
  80.                        DISPLAY xpToGain
  81.                        DISPLAY evolvecount AND evolveTime
  82.  
  83.  
  84.                IF eggToUse is greater than 0
  85.                      THEN
  86.                            DISPLAY eggsToUse
  87.    
  88.                END IF
  89.  
  90.                ELSE
  91.                         PRINT Don’t use any Eggs until you’ve found more Pidgey’s!
  92.        
  93. # Declare Function ‘ Rattata_2() ’
  94.  
  95.                SET Integer Candy_R as 25
  96.                SET  Integer transferCount , evolvecount as 0  AND canStillEvolve AND shouldTransfer as 1
  97.  
  98.                DISPLAY Enter Number Of Rattata
  99.                READ integer
  100.  
  101.                DISPLAY Enter Number Of Candy
  102.                READ integer
  103.  
  104.                     IF Rattata OR RattataCandies is Greater than 9999
  105.                        THEN
  106.                     DISPLAY Please make sure you've filled in all input fields. Inputs take values from 0 to 9999.
  107.                    
  108.                     END IF
  109.  
  110.                      ELSE
  111.  
  112.             WHILE canStillEvolve is TRUE
  113.       
  114.                IF RattataCandiess DIVIDED by Candy_R AND Rattata is equal to 0
  115.                          THEN
  116.                               canStillEvolve Return FALSE
  117.    
  118.                      END IF
  119.  
  120.                      ELSE
  121.            
  122.                         DECREMENT Rattata
  123.                         SUBSTRACT  Candy_R from RattataCandies
  124.                         INCREMENT RattataCandies
  125.                         INCREMENT evolvecount
  126.            
  127.                      IF Rattata is equal to 0
  128.                          THEN
  129.                               BREAK
  130.                      END IF
  131.  
  132.  
  133.             ENDWHILE
  134.  
  135.  
  136.             WHILE shouldTransfer is TRUE
  137.          
  138.                      IF SUM of RattataCandies AND Rattata is less than SUM of Candy_R AND 1 OR Rattata is equal to 0
  139.                  
  140.                         THEN
  141.                            shouldTransfer is FALSE
  142.                            BREAK
  143.                      ENDIF
  144.  
  145.                      WHILE RattataCandies is less than Candy_R
  146.                  
  147.                         INCREMENT transferCount
  148.                         DECREMENT Rattata
  149.                         INCREMENT RattataCandies
  150.                  
  151.                      ENDWHILE
  152.                  
  153.                         DECREMENT Rattata
  154.                         SUBSTRACT Candy_R From RattataCandies
  155.                         INCREMENT RattataCandies
  156.                         INCREMENT evolvecount
  157.            ENDWHILE
  158.    
  159.               SET integer eggsToUse equal to COMPUTE (evolvecount * 35/60) is divided by 30
  160.               SET integer xpToGain equal to COMPUTE as MULTYPLY evolvecount with 1000
  161.               SET float evolveTime equal to COMPUTE as MULTIPLY evolvecount with 0.35
  162.              
  163.     // OUTPUT
  164.              
  165.               PRINT  1. Transfer before activating a Lucky Egg
  166.               DISPLAY transferCount
  167.               PRINT 2. Use Egg, Then Evolve
  168.               DISPLAY evolvecount
  169.               PRINT Recommendation
  170.               DISPLAY xpToGain
  171.               DISPLAY evolvecount AND evolveTime
  172.  
  173.  
  174.               IF eggToUse is greater than 0
  175.                  THEN
  176.                     DISPLAY eggsToUse
  177.                  
  178.               END IF
  179.              
  180.               ELSE
  181.                     PRINT Don’t use any Eggs until you’ve found more Rattata’s!
  182.                  
  183.  
  184. # Declare Function ‘ Zubat_3() ’
  185.  
  186.                     SET Integer Candy_Z as 50
  187.                     SET  Integer transferCount , evolvecount as 0  AND canStillEvolve AND shouldTransfer as 1
  188.  
  189.                     DISPLAY Enter Number Of Zubat
  190.                     READ integer
  191.                    
  192.                     DISPLAY Enter Number Of Candy
  193.                     READ integer
  194.                    
  195.                     IF Zubat OR ZubatCandies is Greater than 9999
  196.                        THEN
  197.                     DISPLAY Please make sure you've filled in all input fields. Inputs take values from 0 to 9999.
  198.                    
  199.                     END IF
  200.  
  201.                     ELSE
  202.                    
  203.                        WHILE canStillEvolve is TRUE
  204.                          
  205.                                IF ZubatCandiess DIVIDED by Candy_Z AND Zubat is equal to 0
  206.                                     THEN
  207.                                    canStillEvolve Return FALSE
  208.                    
  209.                                END IF
  210.                    
  211.                                ELSE
  212.                    
  213.                                 DECREMENT Zubat
  214.                                 SUBSTRACT  Candy_Z from ZubatCandies
  215.                                 INCREMENT ZubatCandies
  216.                                 INCREMENT evolvecount
  217.  
  218.                                IF Zubat is equal to 0
  219.                      THEN
  220.                                           BREAK
  221.                                END IF
  222.  
  223.  
  224.                         ENDWHILE
  225.  
  226.  
  227.             WHILE shouldTransfer is TRUE
  228.          
  229.                         IF SUM of ZubatCandies AND Zubat is less than SUM of Candy_Z AND 1 OR Zubat is equal to 0
  230.                            THEN
  231.                                shouldTransfer is FALSE
  232.                                BREAK
  233.                         ENDIF
  234.  
  235.                        WHILE ZubatCandies is less than Candy_Z
  236.                    
  237.                           INCREMENT transferCount
  238.                           DECREMENT Zubat
  239.                           INCREMENT ZubatCandies
  240.                    
  241.                        ENDWHILE
  242.                    
  243.                           DECREMENT Zubat
  244.                           SUBSTRACT Candy_Z From ZubatCandies
  245.                           INCREMENT ZubatCandies
  246.                           INCREMENT evolvecount
  247.                 ENDWHILE
  248.    
  249.                           SET integer eggsToUse equal to COMPUTE (evolvecount * 35/60) is divided by 30
  250.                           SET integer xpToGain equal to COMPUTE as MULTYPLY evolvecount with 1000
  251.                           SET float evolveTime equal to COMPUTE as MULTIPLY evolvecount with 0.35
  252.  
  253. // OUTPUT
  254.                
  255.                 PRINT  1. Transfer before activating a Lucky Egg
  256.                 DISPLAY transferCount
  257.                 PRINT 2. Use Egg, Then Evolve
  258.                 DISPLAY evolvecount
  259.                 PRINT Recommendation
  260.                 DISPLAY xpToGain
  261.                 DISPLAY evolvecount AND evolveTime
  262.                
  263.                
  264.                 IF eggToUse is greater than 0
  265.                    THEN
  266.                       DISPLAY eggsToUse
  267.                    
  268.                 END IF
  269.                
  270.                 ELSE
  271.                       PRINT Don’t use any Eggs until you’ve found more Zubat’s!
  272.                      
  273.                      
  274.                      
  275.  
  276.  
  277. MAIN() Function
  278.          
  279.                        DISPLAY Pokemon GO Evolution Calculator
  280.                        
  281.                        DISPLAY 1.Pidgey
  282.                                2.Rattata
  283.                                3.Zubat
  284.                                
  285.                        DISPLAY Enter Your Choice
  286.                        SET Integer Choice
  287.                        READ integer Choice
  288.              
  289.               CASE Choice OF
  290.                        
  291.                  1 : Call Function Pidgey_1()
  292.                        BREAK
  293.              
  294.                    
  295.              
  296.                  2 : Call Function Rattata_2()
  297.                        BREAK
  298.              
  299.                    
  300.                  3 : Call Function Zubat_3()
  301.                        BREAK
  302.              
  303.                    
  304.                  default :DISPLAY You Have Entered Wrong Choice...Press Any Key To Continue.
  305.              
  306.               ENDCASE
  307.              
  308.  
  309.  
  310.  
  311.  
  312. END */
  313.  
  314.                
  315.  
  316.  
  317. /*                      ********* EXAMPLE ***********       
  318.  
  319.          How to use Pokemon GO Evolution Calculator
  320.          
  321.          First Enter the INPUT  :
  322.          
  323.          For Example :
  324.          
  325.          INPUT
  326.          
  327.          1
  328.          
  329.          40  60
  330.          
  331.          
  332.          OUTPUT
  333.          
  334.          
  335.                                        Pokemon GO Evolution Calculator
  336.           1.Pidgey 
  337.           2.Rattata
  338.           3.Zubat
  339.          
  340.           Enter Your Choice:
  341.          
  342.           Enter Number Of Pidgey:
  343.           Enter Number Of Candy:
  344.          
  345.           1. Transfer before activating a Lucky Egg:
  346.          
  347.                     29 Pidgey 
  348.          
  349.           2. Use Egg, Then Evolve
  350.                       8 Pidgey
  351.          
  352.           Recommendation:
  353.                   XP gained from evolving: 8000 XP
  354.                   Doing 8 evolutions (at ~35 sec each) takes 2.80 minutes.
  355.                   Don't use any Lucky Eggs until you've found more Pidgey's!
  356.                    
  357. */
  358.                    
  359.          
  360.                
  361.  
  362.  
  363.  
  364. #include<stdio.h>
  365.  
  366.  
  367. void  Pidgey_1()              /*Function For Pidgey Evolution*/
  368. {
  369.  
  370.       int Candy_P =12;
  371.       int Pidgeys, PidgeyCandies;
  372.       int transferCount = 0, evolvecount =0, canStillEvolve=1, shouldTransfer = 1;
  373.      
  374.      
  375.       printf("\n\nEnter Number Of Pidgey:")
  376.       scanf("%d",&Pidgeys);
  377.      
  378.       printf("\nEnter Number Of Candy:");
  379.       scanf("%d", &PidgeyCandies);
  380.      
  381.       if (Pidgeys > 9999 || PidgeyCandies > 9999)
  382.       {
  383.         printf("\n\nPlease make sure you've filled in all input fields. Inputs take values from 0 to 9999.");
  384.       }
  385.            
  386.       else
  387.       {
  388.             
  389.                
  390.              
  391.             while (canStillEvolve)         /*Condition is TRUE, canStillEvolve = 1 */
  392.             {
  393.                
  394.                    if ( (PidgeyCandies/ Candy_P) == 0 || Pidgeys == 0)
  395.                      {
  396.                
  397.                          canStillEvolve = 0 ;
  398.                      }
  399.                  
  400.            
  401.                  else
  402.                      {
  403.                
  404.                         Pidgeys--;                            /* Evolve a Pidgey*/
  405.                         PidgeyCandies -= Candy_P;             /* Remove the candy*/
  406.                         PidgeyCandies++;                      /* Gain 1 candy per evolution*/
  407.                         evolvecount++;
  408.                      }
  409.                    if (Pidgeys == 0)
  410.                     {
  411.                        break;
  412.                    
  413.                      }
  414.                  
  415.               }
  416.        }
  417.                
  418.  
  419.                                 
  420.         while (shouldTransfer)
  421.         {
  422.             /* Not enough to transfer and evolve or no Pidgeys left*/
  423.             if ((PidgeyCandies + Pidgeys) < (Candy_P + 1) || Pidgeys == 0)
  424.             {
  425.                 shouldTransfer = 0;
  426.                 break;
  427.             }
  428.  
  429.             /* Keep transferring until enough candies*/
  430.             while (PidgeyCandies < Candy_P)
  431.             {
  432.            
  433.                 transferCount++ ;             
  434.                 Pidgeys--;
  435.                 PidgeyCandies++;
  436.             }
  437.  
  438.             /* Evolve a Pidgey*/
  439.            
  440.             Pidgeys--;
  441.             PidgeyCandies -= Candy_P;
  442.             PidgeyCandies++;
  443.             evolvecount++;
  444.          }
  445.            
  446.         int eggsToUse =  ((evolvecount * 35 / 60) / 30); /* 35 = Time to Evolve, 60 = 1 Minutes , 30 Is a Lucky Egg TImer */
  447.         int xpToGain = (evolvecount * 1000);
  448.         float evolveTime = (evolvecount * 0.35 );
  449.        
  450.              /* Output*/
  451.        
  452.         printf("\n\n1. Transfer before activating a Lucky Egg:");
  453.         printf("\n\n          %d Pidgey ", transferCount);
  454.         printf("\n\n2. Use Egg, Then Evolve");
  455.         printf("\n            %d Pidgey", evolvecount);
  456.         printf("\n\nRecommendation:");
  457.         printf("\n        XP gained from evolving: %d XP", xpToGain);
  458.         printf("\n        Doing %d evolutions (at ~35 sec each) takes %.2f minutes.",evolvecount,evolveTime);
  459.        
  460.  
  461.  
  462.  
  463.         if (eggsToUse > 0)
  464.         {
  465.             printf("\n        Use Should Use%d Lucky Eggs",eggsToUse) ;
  466.         }
  467.         else
  468.         {
  469.             printf("\n        Don't use any Lucky Eggs until you've found more Pidgey's!");
  470.         }
  471.  
  472.        
  473. }
  474.  
  475. int Rattata_2()                        /* Function For Evolution of Rattata */
  476.  
  477. {
  478.  
  479.       int Candy_R =25;
  480.       int Rattata, RattataCandies, evolvecount =0, canStillEvolve=1, shouldTransfer = 1;
  481.       int transferCount = 0;
  482.      
  483.       printf("\n\nEnter Number Of Rattata:");
  484.       scanf("%d",&Rattata);
  485.      
  486.       printf("\nEnter Number Of Candy:");
  487.       scanf("%d", &RattataCandies);
  488.      
  489.       if (Rattata > 9999 || RattataCandies > 9999)
  490.       {
  491.        printf("\n\nPlease make sure you've filled in all input fields. Inputs take values from 0 to 9999.");
  492.       }
  493.            
  494.       else
  495.       {     
  496.             while (canStillEvolve)    /*Condition Is True. canStillEvolve = 1 */
  497.                               
  498.             {
  499.                if ( (RattataCandies/ Candy_R) == 0 || Rattata == 0)
  500.                
  501.                {
  502.                       canStillEvolve = 0 ;
  503.                }
  504.                  
  505.            
  506.                else
  507.                {
  508.                     Rattata--;                            /* Evolve a Rattata*/
  509.                     RattataCandies -= Candy_R;         /* Remove the candy*/
  510.                     RattataCandies++;                /* Gain 1 candy per evolution*/
  511.                     evolvecount++;
  512.                }
  513.                if (Rattata == 0)
  514.                {
  515.                     break;
  516.                    
  517.                }
  518.                  
  519.             }
  520.        }
  521.            
  522.                      
  523.         while (shouldTransfer)
  524.         {
  525.             /*Not enough to transfer and evolve or no Rattata left*/
  526.            
  527.             if ((RattataCandies + Rattata ) < (Candy_R + 1) || Rattata == 0)
  528.             {
  529.                 shouldTransfer = 0;
  530.                 break;
  531.             }
  532.  
  533.             else
  534.             { 
  535.             /* Keep transferring until enough candies*/
  536.            
  537.                   while (RattataCandies < Candy_R)
  538.                   {
  539.            
  540.                     transferCount++ ;
  541.                       Rattata--;
  542.                       RattataCandies++;
  543.                   }
  544.  
  545.             /* Evolve a Rattata*/
  546.            
  547.                         Rattata--;
  548.                         RattataCandies -= Candy_R;
  549.                         RattataCandies++;
  550.                 evolvecount++;
  551.           }
  552.         }
  553.           int eggsToUse =  ((evolvecount * 35 / 60) / 30)/* 35 = Time to Evolve, 60 = 1 Minutes , 30 Is a Lucky Egg TImer */
  554.            int xpToGain = (evolvecount * 1000);
  555.           float evolveTime = (evolvecount * 0.35 );
  556.        
  557.        
  558.          /* Output*/
  559.        
  560.         printf("\n\n1. Transfer before activating a Lucky Egg:");
  561.         printf("\n\n          %d Rattata ", transferCount);
  562.         printf("\n\n2. Use Egg, Then Evolve");
  563.         printf("\n            %d Rattata", evolvecount);
  564.         printf("\n\nRecommendation:");
  565.         printf("\n        XP gained from evolving: %d XP", xpToGain);
  566.         printf("\n        Doing %d evolutions (at ~35 sec each) takes %.2f minutes.",evolvecount,evolveTime);
  567.        
  568.  
  569.         printf("\n\n\tLucky Egg Recommendation: ");
  570.  
  571.         if (eggsToUse > 0)
  572.         {
  573.             printf("\n\n        Use %d Lucky Eggs",eggsToUse) ;
  574.         }
  575.         else
  576.         {
  577.             printf("Don't use any Lucky Eggs until you've found more Rattata's!");
  578.         }
  579.      
  580.        
  581. }
  582. void Zubat_3()        /* Function For Evolution of Zubat */
  583.  
  584. {
  585.  
  586.       int Candy_Z =50;
  587.       int Zubat, ZubatCandies, evolvecount =0, canStillEvolve=1, shouldTransfer = 1;
  588.       int transferCount = 0;
  589.      
  590.       printf("\n\nEnter Number Of Zubat:");
  591.       scanf("%d",&Zubat);
  592.      
  593.       printf("\nEnter Number Of Candy:");
  594.       scanf("%d", &ZubatCandies);
  595.      
  596.       if (Zubat > 9999 || ZubatCandies > 9999)
  597.       {
  598.        printf("\n\nPlease make sure you've filled in all input fields. Inputs take values from 0 to 9999.");
  599.       }
  600.            
  601.       else
  602.       {     
  603.             while (canStillEvolve)    /*Condition Is True. canStillEvolve = 1 */
  604.                               
  605.             {
  606.                if ( (ZubatCandies/ Candy_Z) == 0 || Zubat == 0)
  607.                
  608.                {
  609.                       canStillEvolve = 0 ;
  610.                }
  611.                  
  612.            
  613.                else
  614.                {
  615.                     Zubat--;                   /* Evolve a Zubat*/
  616.                     ZubatCandies -= Candy_Z;     /* Remove the candy*/
  617.                     ZubatCandies++;          /* Gain 1 candy per evolution*/
  618.                     evolvecount++;
  619.                }
  620.                if (Zubat == 0)
  621.                {
  622.                     break;
  623.                    
  624.                }
  625.                  
  626.             }
  627.        }
  628.            
  629.                      
  630.         while (shouldTransfer)
  631.         {
  632.             /*Not enough to transfer and evolve or no Zubat left*/
  633.            
  634.             if ((ZubatCandies + Zubat ) < (Candy_Z + 1) || Zubat == 0)
  635.             {
  636.                 shouldTransfer = 0;
  637.                 break;
  638.             }
  639.  
  640.             else
  641.             { 
  642.             /* Keep transferring until enough candies*/
  643.            
  644.                   while (ZubatCandies < Candy_Z)
  645.                   {
  646.            
  647.                     transferCount++ ;
  648.                       Zubat--;
  649.                       ZubatCandies++;
  650.                   }
  651.  
  652.             /* Evolve a Zubat*/
  653.            
  654.                         Zubat--;
  655.                         ZubatCandies -= Candy_Z;
  656.                         ZubatCandies++;
  657.                 evolvecount++;
  658.           }
  659.            
  660.           int eggsToUse =  ((evolvecount * 35 / 60) / 30)/* 35 = Time to Evolve, 60 = 1 Minutes , 30 Is a Lucky Egg TImer */
  661.            int xpToGain = (evolvecount * 1000);
  662.           float evolveTime = (evolvecount * 0.35 );
  663.        
  664.        
  665.          /* Output*/
  666.        
  667.         printf("\n\n1. Transfer before activating a Lucky Egg:");
  668.         printf("\n\n          %d Zubat ", transferCount);
  669.         printf("\n\n2. Use Egg, Then Evolve");
  670.         printf("\n            %d Zubat", evolvecount);
  671.         printf("\n\nRecommendation:");
  672.         printf("\n        XP gained from evolving: %d XP", xpToGain);
  673.         printf("\n        Doing %d evolutions (at ~35 sec each) takes %.2f minutes.",evolvecount,evolveTime);
  674.        
  675.  
  676.         printf("\n\n\tLucky Egg Recommendation: ");
  677.  
  678.         if (eggsToUse > 0)
  679.         {
  680.             printf("\n\n        Use %d Lucky Eggs",eggsToUse) ;
  681.         }
  682.         else
  683.         {
  684.             printf("Don't use any Lucky Eggs until you've found more Zubat's!");
  685.         }
  686.        
  687.          }
  688. }
  689.  
  690.  
  691. int main( void )
  692. {
  693.          
  694.          printf("\n                                       Pokemon GO Evolution Calculator");
  695.          printf("\n1.Pidgey \n2.Rattata\n3.Zubat");
  696.          printf("\n\nEnter Your Choice:");
  697.          int Choice ;
  698.          scanf("%d",&Choice);
  699.          
  700.          
  701.          
  702.          switch(Choice)
  703.          {     
  704.          
  705.                   case 1 : Pidgey_1();
  706.                            break;
  707.                            
  708.                   case 2 : Rattata_2(); break;
  709.                            break;
  710.                            
  711.                   case 3 : Zubat_3();
  712.                            break;
  713.                    
  714.                   default :
  715.                               printf("  You Have Entered Wrong Choice...Press Any Key To Continue. ");
  716.          }
  717. }