API tools faq
paste
Advertisement
thibthibaut

Untitled

thibthibaut
Apr 16th, 2015
207
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.28 KB | None | 0 0
raw download clone embed print report diff
  1. /******
  2. MAIN3.C
  3. ******/
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7.  
  8. #define C1 1        /* C1   E1   C2     */
  9. #define C2 2        /*          */
  10. #define C3 3        /* E2   M    E3     */
  11. #define C4 4        /*          */
  12.             /* C3   E4   C4     */
  13. #define E1 5
  14. #define E2 6
  15. #define E3 7
  16. #define E4 8
  17.  
  18. #define  M 9
  19. //-----------
  20.  
  21.  
  22. #define DEPTH 8
  23.  
  24.  
  25. typedef struct path
  26. {
  27.     char path[DEPTH+1];
  28.     char taken[10];
  29.     int index;
  30.  
  31. }t_path;
  32.  
  33.  
  34.  
  35. /* PROTOTYPES */
  36. void drawpattern(t_path*);
  37. void pathfinder(t_path* current_path, int depth);
  38. void addToPath(t_path* p, char toAdd);
  39. void moveCursor(int, int);
  40. void drawTakenMap(t_path* p);
  41. void updateTakenMap(t_path* p);
  42.  
  43.  
  44. //------- NEEEWWWWWW-------
  45. char iHaveBeenThere[10000];
  46.  
  47.  
  48. int main(){
  49.  
  50.  
  51.     t_path* my_path = (t_path*)malloc(sizeof(t_path));
  52.     int i;
  53.     for(i=1;i<=9;i++){
  54.         my_path->taken[i] = 0;
  55.     }
  56.     my_path->index = 0;
  57.  
  58.  
  59.     my_path->path[0] = C1;
  60.     my_path->taken[C1] = 1;
  61.  
  62.  
  63.  
  64.     //t_path** pathList = malloc(10000*sizeof(t_path*));
  65.  
  66.  
  67.     pathfinder(my_path, 0);
  68.  
  69.     drawpattern(my_path);
  70.     return 0;
  71. }
  72.  
  73.  
  74.  
  75. void pathfinder(t_path* current_path, int depth){
  76.     int k;
  77.  
  78.     /*printf("\n");
  79.     for(k=0; k<depth; k++){
  80.         printf("  ");
  81.     }
  82.     printf("Called : depth:%d  | ", depth);
  83.     drawpattern(current_path);
  84.     for(k=0; k<depth; k++){
  85.         printf("  ");
  86.     }
  87.     drawTakenMap(current_path);*/
  88.  
  89.     if(depth==DEPTH){ //Depth Touched !
  90.         //printf("---------\nDepth touched\n");
  91.         drawpattern(current_path);
  92.         //drawTakenMap(current_path);
  93.         current_path->index--;
  94.         current_path->taken[current_path->path[current_path->index]]=0;
  95.                
  96.         return;
  97.     }
  98.  
  99.  
  100.     //printf("called index:%d\n", current_path->index);
  101.  
  102.     int i = 0;
  103.     int check = 0;
  104.  
  105.     char init = current_path->path[current_path->index];//The init part is the last element of the path
  106.  
  107.     if(init==C1){
  108.  
  109.             if(current_path->taken[E1]==0) //If E1 is not taken
  110.             {
  111.                 addToPath(current_path, E1);
  112.                 pathfinder(current_path, depth+1);
  113.  
  114.             }
  115.             if (current_path->taken[E2]==0) //  E1 is taken so we check if E2 is taken
  116.             {
  117.                 addToPath(current_path, E2);
  118.                 pathfinder(current_path, depth+1);
  119.  
  120.             }
  121.             if (current_path->taken[E3]==0) //  E2 is taken so we check if E3 is taken
  122.             {
  123.                 addToPath(current_path, E3);
  124.                 pathfinder(current_path, depth+1);
  125.  
  126.             }
  127.             if (current_path->taken[E4]==0) //  E2 is taken so we check if E3 is taken
  128.             {
  129.                 addToPath(current_path, E4);
  130.                 pathfinder(current_path, depth+1);
  131.  
  132.             }
  133.             if(current_path->taken[M]==0)
  134.             {
  135.                 addToPath(current_path, M);
  136.                 pathfinder(current_path, depth+1);
  137.  
  138.             }
  139.             if(current_path->taken[E1]==1 && current_path->taken[C2]==0) //Jump condition
  140.             {
  141.                 addToPath(current_path, C2);
  142.                 pathfinder(current_path, depth+1);
  143.  
  144.             }
  145.             if(current_path->taken[E2]==1 && current_path->taken[C3]==0) //Jump condition
  146.             {
  147.                 addToPath(current_path, C3);
  148.                 pathfinder(current_path, depth+1);
  149.  
  150.             }
  151.             if(current_path->taken[M]==1 && current_path->taken[C4]==0) //Jump condition M->C4
  152.             {
  153.                 addToPath(current_path, C4);
  154.                 pathfinder(current_path, depth+1);
  155.  
  156.             }
  157.             //  there is no way possible, STOP (In fact we can take into account the jump)
  158.            
  159.                 //printf("No possible from C1\n");
  160.                 //drawpattern(current_path);
  161.  
  162.                 current_path->path[current_path->index] = 0;
  163.                 current_path->index--;
  164.                 updateTakenMap(current_path);
  165.  
  166.  
  167.                 return;
  168.            
  169.         }
  170.            
  171.         if(init==C2){
  172.            
  173.             if(current_path->taken[E1]==0) //If E1 is not taken
  174.             {
  175.                 addToPath(current_path, E1);
  176.                 pathfinder(current_path, depth+1);
  177.  
  178.             }
  179.             if (current_path->taken[E3]==0) //  E1 is taken so we check if E3 is taken
  180.             {
  181.                 addToPath(current_path, E3);
  182.                 pathfinder(current_path, depth+1);
  183.  
  184.             }
  185.             if (current_path->taken[E2]==0)
  186.             {
  187.                 addToPath(current_path, E2);
  188.                 pathfinder(current_path, depth+1);
  189.  
  190.             }
  191.             if (current_path->taken[E4]==0)
  192.             {
  193.                 addToPath(current_path, E4);
  194.                 pathfinder(current_path, depth+1);
  195.  
  196.             }
  197.             if(current_path->taken[M]==0)
  198.             {
  199.                 addToPath(current_path, M);
  200.                 pathfinder(current_path, depth+1);
  201.  
  202.             }
  203.             if(current_path->taken[E2]==1 && current_path->taken[C1]==0) //Jump condition
  204.             {
  205.                 addToPath(current_path, C1);
  206.                 pathfinder(current_path, depth+1);
  207.  
  208.             }
  209.             if(current_path->taken[E4]==1 && current_path->taken[C4]==0) //Jump condition
  210.             {
  211.                 addToPath(current_path, C4);
  212.                 pathfinder(current_path, depth+1);
  213.  
  214.             }
  215.             if(current_path->taken[M]==1 && current_path->taken[C3]==0) //Jump condition M->C3
  216.             {
  217.                 addToPath(current_path, C3);
  218.                 pathfinder(current_path, depth+1);
  219.  
  220.             }
  221.             //  there is no way possible, STOP (In fact we can take into account the jump)
  222.            
  223.  
  224.                 //drawpattern(current_path);
  225.                 //printf("No possible from C2\n");
  226.                 //drawpattern(current_path);
  227.  
  228.                 current_path->path[current_path->index] = 0;
  229.                 current_path->index--;
  230.                 updateTakenMap(current_path);
  231.                 return;
  232.            
  233.  
  234.  
  235.  
  236.             //END OF C2 CASE
  237.  
  238.         }
  239.        
  240.         if(init==C3){
  241.  
  242.  
  243.             if(current_path->taken[E2]==0) //If E1 is not taken
  244.             {
  245.                 addToPath(current_path, E2);
  246.                 pathfinder(current_path, depth+1);
  247.  
  248.             }
  249.             if (current_path->taken[E4]==0) //  E1 is taken so we check if E3 is taken
  250.             {
  251.                 addToPath(current_path, E4);
  252.                 pathfinder(current_path, depth+1);
  253.  
  254.             }
  255.             if (current_path->taken[E3]==0)
  256.             {
  257.                 addToPath(current_path, E3);
  258.                 pathfinder(current_path, depth+1);
  259.  
  260.             }
  261.             if (current_path->taken[E1]==0)
  262.             {
  263.                 addToPath(current_path, E1);
  264.                 pathfinder(current_path, depth+1);
  265.  
  266.             }
  267.             if(current_path->taken[M]==0)
  268.             {
  269.                 addToPath(current_path, M);
  270.                 pathfinder(current_path, depth+1);
  271.  
  272.             }
  273.             if(current_path->taken[E1]==1 && current_path->taken[C1]==0) //Jump condition
  274.             {
  275.                 addToPath(current_path, C1);
  276.                 pathfinder(current_path, depth+1);
  277.  
  278.             }
  279.             if(current_path->taken[E3]==1 && current_path->taken[C4]==0) //Jump condition
  280.             {
  281.                 addToPath(current_path, C4);
  282.                 pathfinder(current_path, depth+1);
  283.  
  284.             }
  285.             if(current_path->taken[M]==1 && current_path->taken[C2]==0) //Jump condition M->C2
  286.             {
  287.                 addToPath(current_path, C2);
  288.                 pathfinder(current_path, depth+1);
  289.  
  290.             }
  291.             //  there is no way possible, STOP (In fact we can take into account the jump)
  292.  
  293.  
  294.                 //printf("No possible from C3\n");
  295.                 current_path->path[current_path->index] = 0;
  296.                 current_path->index--;
  297.                 updateTakenMap(current_path);
  298.                 return;
  299.            
  300.            
  301.         }
  302.         if(init==C4){
  303.  
  304.             if(current_path->taken[E3]==0) //Classic
  305.             {
  306.                 addToPath(current_path, E3);
  307.                 pathfinder(current_path, depth+1);
  308.  
  309.             }
  310.             if (current_path->taken[E4]==0) //Classic
  311.             {
  312.                 addToPath(current_path, E4);
  313.                 pathfinder(current_path, depth+1);
  314.  
  315.             }
  316.             if (current_path->taken[E1]==0) //Long
  317.             {
  318.                 addToPath(current_path, E1);
  319.                 pathfinder(current_path, depth+1);
  320.  
  321.             }
  322.             if (current_path->taken[E2]==0) //Long
  323.             {
  324.                 addToPath(current_path, E2);
  325.                 pathfinder(current_path, depth+1);
  326.  
  327.             }
  328.             if(current_path->taken[M]==0)
  329.             {
  330.                 addToPath(current_path, M);
  331.                 pathfinder(current_path, depth+1);
  332.  
  333.             }
  334.             if(current_path->taken[E1]==1 && current_path->taken[C1]==0) //Jump condition
  335.             {
  336.                 addToPath(current_path, C1);
  337.                 pathfinder(current_path, depth+1);
  338.  
  339.             }
  340.             if(current_path->taken[E3]==1 && current_path->taken[C4]==0) //Jump condition
  341.             {
  342.                 addToPath(current_path, C4);
  343.                 pathfinder(current_path, depth+1);
  344.  
  345.             }
  346.             if(current_path->taken[M]==1 && current_path->taken[C1]==0) //Jump condition M->C1
  347.             {
  348.                 addToPath(current_path, C1);
  349.                 pathfinder(current_path, depth+1);
  350.  
  351.             }
  352.             //  there is no way possible, STOP (In fact we can take into account the jump)
  353.  
  354.                 //printf("No possible from C4\n");
  355.                 //drawpattern(current_path);
  356.                 current_path->path[current_path->index] = 0;
  357.                 current_path->index--;
  358.                 updateTakenMap(current_path);
  359.                 return;
  360.            
  361.  
  362.  
  363.            
  364.             }
  365.  
  366.             //----------------------------------------------------
  367.             //END OF CORNER CASES
  368.             //------------------------------------------------------
  369.  
  370.             if(init==E1){
  371.                 if(current_path->taken[C1]==0) //Corner
  372.                 {
  373.                     addToPath(current_path, C1);
  374.                     pathfinder(current_path, depth+1);
  375.  
  376.                 }
  377.                 if(current_path->taken[C2]==0)//Corner
  378.                 {
  379.                     addToPath(current_path, C2);
  380.                     pathfinder(current_path, depth+1);
  381.  
  382.                 }
  383.                 if(current_path->taken[E2]==0)//Edge
  384.                 {
  385.                     addToPath(current_path, E2);
  386.                     pathfinder(current_path, depth+1);
  387.  
  388.                 }
  389.                 if(current_path->taken[E3]==0)//Edge
  390.                 {
  391.                     addToPath(current_path, E3);
  392.                     pathfinder(current_path, depth+1);
  393.  
  394.                 }
  395.                 if(current_path->taken[M]==0)//Middle
  396.                 {
  397.                     addToPath(current_path, M);
  398.                     pathfinder(current_path, depth+1);
  399.  
  400.                 }
  401.                 if(current_path->taken[M]==1 && current_path->taken[E4]==0)//Jump over middle
  402.                 {
  403.                     addToPath(current_path, E4);
  404.                     pathfinder(current_path, depth+1);
  405.  
  406.                 }
  407.                 //NO PATH
  408.  
  409.                 //printf("No possible from E1\n");
  410.                 //drawpattern(current_path);
  411.                 current_path->path[current_path->index] = 0;
  412.                 current_path->index--;
  413.                 updateTakenMap(current_path);
  414.                 return;
  415.                
  416.             }
  417.  
  418.             if(init==E2){
  419.                 if(current_path->taken[C1]==0) //Corner
  420.                 {
  421.                     addToPath(current_path, C1);
  422.                     pathfinder(current_path, depth+1);
  423.  
  424.                 }
  425.                 if(current_path->taken[C3]==0)//Corner
  426.                 {
  427.                     addToPath(current_path, C3);
  428.                     pathfinder(current_path, depth+1);
  429.  
  430.                 }
  431.                 if(current_path->taken[E1]==0)//Edge
  432.                 {
  433.                     addToPath(current_path, E1);
  434.                     pathfinder(current_path, depth+1);
  435.  
  436.                 }
  437.                 if(current_path->taken[E4]==0)//Edge
  438.                 {
  439.                     addToPath(current_path, E4);
  440.                     pathfinder(current_path, depth+1);
  441.  
  442.                 }
  443.                 if(current_path->taken[M]==0)//Middle
  444.                 {
  445.                     addToPath(current_path, M);
  446.                     pathfinder(current_path, depth+1);
  447.  
  448.                 }
  449.                 if(current_path->taken[M]==1 && current_path->taken[E3]==0)//Jump over middle
  450.                 {
  451.                     addToPath(current_path, E3);
  452.                     pathfinder(current_path, depth+1);
  453.  
  454.                 }
  455.                
  456.                 //NO PATH
  457.  
  458.                 //printf("No possible from E2\n");
  459.                 //drawpattern(current_path);
  460.                 current_path->path[current_path->index] = 0;
  461.                 current_path->index--;
  462.                 updateTakenMap(current_path);
  463.                    
  464.             }
  465.                
  466.            
  467.  
  468.  
  469.             if(init==E3){
  470.                 if(current_path->taken[C2]==0) //Corner
  471.                 {
  472.                     addToPath(current_path, C2);
  473.                     pathfinder(current_path, depth+1);
  474.  
  475.                 }
  476.                 if(current_path->taken[C4]==0)//Corner
  477.                 {
  478.                     addToPath(current_path, C4);
  479.                     pathfinder(current_path, depth+1);
  480.  
  481.                 }
  482.                 if(current_path->taken[E1]==0)//Edge
  483.                 {
  484.                     addToPath(current_path, E1);
  485.                     pathfinder(current_path, depth+1);
  486.  
  487.                 }
  488.                 if(current_path->taken[E4]==0)//Edge
  489.                 {
  490.                     addToPath(current_path, E4);
  491.                     pathfinder(current_path, depth+1);
  492.  
  493.                 }
  494.                 if(current_path->taken[M]==0)//Middle
  495.                 {
  496.                     addToPath(current_path, M);
  497.                     pathfinder(current_path, depth+1);
  498.  
  499.                 }
  500.                 if(current_path->taken[M]==1 && current_path->taken[E2]==0)//Jump over middle
  501.                 {
  502.                     addToPath(current_path, E2);
  503.                     pathfinder(current_path, depth+1);
  504.  
  505.                 }
  506.                 //NO PATH
  507.  
  508.                 //printf("No possible from E3\n");
  509.                 //drawpattern(current_path);
  510.                 current_path->path[current_path->index] = 0;
  511.                 current_path->index--;
  512.                 updateTakenMap(current_path);
  513.                 return;
  514.                
  515.             }
  516.  
  517.             if(init==E4){
  518.                 if(current_path->taken[C3]==0) //Corner
  519.                 {
  520.                     addToPath(current_path, C3);
  521.                     pathfinder(current_path, depth+1);
  522.  
  523.                 }
  524.                 if(current_path->taken[C4]==0)//Corner
  525.                 {
  526.                     addToPath(current_path, C4);
  527.                     pathfinder(current_path, depth+1);
  528.  
  529.                 }
  530.                 if(current_path->taken[E2]==0)//Edge
  531.                 {
  532.                     addToPath(current_path, E2);
  533.                     pathfinder(current_path, depth+1);
  534.  
  535.                 }
  536.                 if(current_path->taken[E3]==0)//Edge
  537.                 {
  538.                     addToPath(current_path, E3);
  539.                     pathfinder(current_path, depth+1);
  540.  
  541.                 }
  542.                 if(current_path->taken[M]==0)//Middle
  543.                 {
  544.                     addToPath(current_path, M);
  545.                     pathfinder(current_path, depth+1);
  546.  
  547.                 }
  548.                 if(current_path->taken[M]==1 && current_path->taken[E1]==0)//Jump over middle
  549.                 {
  550.                     addToPath(current_path, E1);
  551.                     pathfinder(current_path, depth+1);
  552.  
  553.                 }
  554.                
  555.                 //NO PATH
  556.                
  557.                 //printf("No possible from E4\n");
  558.                 //drawpattern(current_path);
  559.                 current_path->path[current_path->index] = 0;
  560.                 current_path->index--;
  561.                 updateTakenMap(current_path);
  562.                 return;
  563.                
  564.             }
  565.  
  566.             //----------------------------------------------------
  567.             //END OF EDGE CASES
  568.             //------------------------------------------------------
  569.  
  570.         if(init==M){
  571.  
  572.             if(current_path->taken[E1]==0) //If E1 is not taken
  573.             {
  574.                 addToPath(current_path, E1);
  575.                 pathfinder(current_path, depth+1);
  576.  
  577.             }
  578.             if (current_path->taken[E2]==0) //  E1 is taken so we check if E2 is taken
  579.             {
  580.                 addToPath(current_path, E2);
  581.                 pathfinder(current_path, depth+1);
  582.  
  583.             }
  584.             if (current_path->taken[E3]==0) //  E2 is taken so we check if E3 is taken
  585.             {
  586.                 addToPath(current_path, E3);
  587.                 pathfinder(current_path, depth+1);
  588.  
  589.             }
  590.             if (current_path->taken[E4]==0) //  E2 is taken so we check if E3 is taken
  591.             {
  592.                 addToPath(current_path, E4);
  593.                 pathfinder(current_path, depth+1);
  594.  
  595.             }
  596.             if(current_path->taken[C1]==0) //If E1 is not taken
  597.             {
  598.                 addToPath(current_path, C1);
  599.                 pathfinder(current_path, depth+1);
  600.  
  601.             }
  602.             if (current_path->taken[C2]==0) //  E1 is taken so we check if E2 is taken
  603.             {
  604.                 addToPath(current_path, C2);
  605.                 pathfinder(current_path, depth+1);
  606.  
  607.             }
  608.             if (current_path->taken[C3]==0) //  E2 is taken so we check if E3 is taken
  609.             {
  610.                 addToPath(current_path, C3);
  611.                 pathfinder(current_path, depth+1);
  612.  
  613.             }
  614.             if (current_path->taken[C4]==0) //  E2 is taken so we check if E3 is taken
  615.             {
  616.                 addToPath(current_path, C4);
  617.                 pathfinder(current_path, depth+1);
  618.  
  619.             }
  620.  
  621.  
  622.             //NO PATH
  623.  
  624.                 //printf("No possible from M\n");
  625.                 //drawpattern(current_path);
  626.                 current_path->path[current_path->index] = 0;
  627.                 current_path->index--;
  628.                 updateTakenMap(current_path);
  629.                 return;
  630.            
  631.  
  632.         }
  633.  
  634.        
  635.  
  636.    
  637.     //pathfinder(current_path, depth+1);
  638.  
  639. }
  640.  
  641.  
  642.  
  643.  
  644. void addToPath(t_path* p, char toAdd){
  645.  
  646.     if(toAdd<1 || toAdd>9){
  647.         printf("Error: addToPath Function cannot take this parameter: toAdd =%d\n", toAdd);
  648.         exit(-1);
  649.     }
  650.     else{
  651.  
  652.        
  653.         if(p->taken[toAdd]==1){
  654.             printf("Bug: not possible to add a taken to path...\n");
  655.             exit(-1);
  656.         }
  657.         else{
  658.  
  659.         p->index++; //Add a step to the path
  660.         p->path[p->index] = toAdd; //Add toAdd to current path
  661.         updateTakenMap(p);
  662.    
  663.         }
  664.  
  665.     }
  666.  
  667. }
  668.  
  669.  
  670.  
  671. void drawpattern(t_path* p){
  672.  
  673.        
  674.  
  675.         int i;
  676.         for(i=0; i<p->index+1; i++){
  677.  
  678.         switch(p->path[i]){
  679.             case E1:
  680.                 printf("->E1");
  681.                 break;
  682.             case E2:
  683.                 printf("->E2");
  684.                 break;
  685.             case E3:
  686.                 printf("->E3");
  687.                 break;
  688.             case E4:
  689.                 printf("->E4");
  690.                 break;
  691.             case C1:
  692.                 printf("->C1");
  693.                 break;
  694.             case C2:
  695.                 printf("->C2");
  696.                 break;
  697.             case C3:
  698.                 printf("->C3");
  699.                 break;
  700.             case C4:
  701.                 printf("->C4");
  702.                 break;
  703.             case M:
  704.                 printf("->M");
  705.                 break;
  706.             default :
  707.                 printf("default");
  708.  
  709.         }
  710.     }
  711.     printf("\n");
  712. }
  713.  
  714.  
  715. void moveCursor(int row, int col){
  716.     printf("\033[2J");
  717.     printf("\033[%d;%dH", row, col);
  718.     printf("Coucou\n");
  719. }
  720.  
  721.  
  722.  
  723. t_path* copyTPath(t_path* toCopy){
  724.  
  725.  
  726.     t_path* toReturn = NULL;
  727.     char p[DEPTH];
  728.     char tak[9];
  729.     int index;
  730.     int i;
  731.  
  732.  
  733.     toReturn = (t_path*)malloc(sizeof(t_path));
  734.    
  735.     for (i = 0; i < toCopy->index; ++i)
  736.     {
  737.         toReturn->path[i] = toCopy->path[i];
  738.     }
  739.  
  740.    
  741.    
  742.     for (i = 1; i <=9; ++i)
  743.     {
  744.         toReturn->taken[i] = toCopy->taken[i];
  745.     }
  746.  
  747.  
  748.    
  749.     toReturn->index = toCopy->index;
  750.  
  751.     return toReturn;
  752. }
  753.  
  754.  
  755.  
  756. void drawTakenMap(t_path* p){
  757.  
  758.     int i;
  759.     printf("taken:");
  760.  
  761.     for (i = 1; i <= 9; ++i)
  762.     {
  763.         if(p->taken[i] == 1){
  764.  
  765.             switch(i){
  766.             case E1:
  767.                 printf(" E1 ");
  768.                 break;
  769.             case E2:
  770.                 printf(" E2 ");
  771.                 break;
  772.             case E3:
  773.                 printf(" E3 ");
  774.                 break;
  775.             case E4:
  776.                 printf(" E4 ");
  777.                 break;
  778.             case C1:
  779.                 printf(" C1 ");
  780.                 break;
  781.             case C2:
  782.                 printf(" C2 ");
  783.                 break;
  784.             case C3:
  785.                 printf(" C3 ");
  786.                 break;
  787.             case C4:
  788.                 printf(" C4 ");
  789.                 break;
  790.             case M:
  791.                 printf(" M ");
  792.                 break;
  793.             default :
  794.                 printf("default : %d", i);
  795.  
  796.         }
  797.  
  798.         }
  799.     }
  800.     printf("\n");
  801.  
  802. }
  803.  
  804.  
  805. void updateTakenMap(t_path* p){
  806.  
  807.     int i = 0;
  808.     //reset taken
  809.     for(i = 1; i<=9; i++){
  810.         p->taken[i] = 0;
  811.     }
  812.  
  813.  
  814.     for(i = 0; i<=p->index; i++){
  815.  
  816.         p->taken[p->path[i]] = 1;
  817.     }
  818.  
  819. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!