├── flip.cpp
└── judge.cpp


/flip.cpp:
--------------------------------------------------------------------------------
  1 | #define row 8
  2 | #define column 8
  3 | 
  4 | ///////////////////////////////////////////////////////////////////////////
  5 | /////////////////////// Valid Moves Function //////////////////////////////
  6 | int abs(int num){
  7 |     return num>=0 ? num : -num;
  8 | }
  9 | 
 10 | int isInTable(int x,int y){
 11 |     if(x < 8 && x>=0 && y<8 && y>=0)    return 1;
 12 |     else    return 0;
 13 | }
 14 | 
 15 | int validNorth(int x0,int y0 ,int x ,int y, const int table[row][column],int player){    ////
 16 |     if(table[y0][x0]!=0)    return-1;
 17 |     y-=1;
 18 |     if(!isInTable(x,y))  return -1;
 19 | 
 20 |     if(table[y][x]== 0) return -1;
 21 |     else if(table[y][x]== player){
 22 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 23 |         else    return x0+y0*8;
 24 |     }
 25 |     else    return  validNorth(x0,y0,x,y,table,player);
 26 | }
 27 | 
 28 | int validSouth(int x0,int y0 ,int x ,int y, const int table[row][column],int player){    ////
 29 |     if(table[y0][x0]!=0)    return-1;
 30 |     y+=1;
 31 |     if(!isInTable(x,y))  return -1;
 32 | 
 33 |     if(table[y][x]== 0) return -1;
 34 |     else if(table[y][x]== player){
 35 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 36 |         else    return x0+y0*8;
 37 |     }
 38 |     else    return  validSouth(x0,y0,x,y,table,player);
 39 | }
 40 | 
 41 | int validWest(int x0,int y0 ,int x ,int y, const int table[row][column],int player){     ////
 42 |     if(table[y0][x0]!=0)    return-1;
 43 |     x-=1;
 44 |     if(!isInTable(x,y))  return -1;
 45 | 
 46 |     if(table[y][x]== 0) return -1;
 47 |     else if(table[y][x]== player){
 48 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 49 |         else    return x0+y0*8;
 50 |     }
 51 |     else    return  validWest(x0,y0,x,y,table,player);
 52 | }
 53 | 
 54 | int validEast(int x0,int y0 ,int x ,int y, const int table[row][column],int player){     ////
 55 |     if(table[y0][x0]!=0)    return-1;
 56 |     x+=1;
 57 |     if(!isInTable(x,y))  return -1;
 58 | 
 59 |     if(table[y][x]== 0) return -1;
 60 |     else if(table[y][x]== player){
 61 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 62 |         else    return x0+y0*8;
 63 |     }
 64 |     else    return  validEast(x0,y0,x,y,table,player);
 65 | }
 66 | 
 67 | int validNW(int x0,int y0 ,int x ,int y, const int table[row][column],int player){       ////
 68 |     if(table[y0][x0]!=0)    return-1;
 69 |     y-=1;   x-=1;
 70 |     if(!isInTable(x,y))  return -1;
 71 | 
 72 |     if(table[y][x]== 0) return -1;
 73 |     else if(table[y][x]== player){
 74 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 75 |         else    return x0+y0*8;
 76 |     }
 77 |     else    return  validNW(x0,y0,x,y,table,player);
 78 | }
 79 | 
 80 | int validNE(int x0,int y0 ,int x ,int y, const int table[row][column],int player){
 81 |     if(table[y0][x0]!=0)    return-1;
 82 |     y-=1;   x+=1;
 83 |     if(!isInTable(x,y))  return -1;
 84 | 
 85 |     if(table[y][x]== 0) return -1;
 86 |     else if(table[y][x]== player){
 87 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
 88 |         else    return x0+y0*8;
 89 |     }
 90 |     else    return  validNE(x0,y0,x,y,table,player);
 91 | }
 92 | 
 93 | int validSW(int x0,int y0 ,int x ,int y, const int table[row][column],int player){
 94 |     if(table[y0][x0]!=0)    return-1;
 95 |     y+=1;   x-=1;
 96 |     if(!isInTable(x,y))  return -1;
 97 | 
 98 |     if(table[y][x]== 0) return -1;
 99 |     else if(table[y][x]== player){
100 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
101 |         else    return x0+y0*8;
102 |     }
103 |     else    return  validSW(x0,y0,x,y,table,player);
104 | }
105 | 
106 | int validSE(int x0,int y0 ,int x ,int y, const int table[row][column],int player){
107 |     if(table[y0][x0]!=0)    return-1;
108 |     y+=1;   x+=1;
109 |     if(!isInTable(x,y))  return -1;
110 | 
111 |     if(table[y][x]== 0) return -1;
112 |     else if(table[y][x]== player){
113 |         if (abs(x-x0)==1 || abs(y-y0)==1 )    return -1;
114 |         else    return x0+y0*8;
115 |     }
116 |     else    return  validSE(x0,y0,x,y,table,player);
117 | }
118 | 
119 | ///////////////////////////////   Flip    //////////////////////////////////////
120 | 
121 | int flipNorth(int x ,int y, int table[row][column],int player){    ////
122 |     if (validNorth(x,y,x,y,table,player)== -1)  return 1;
123 |     table[y][x] =player;
124 |     y-=1;
125 |     while(table[y][x] == 3 - player){
126 |         table[y][x]= player;
127 |         y-=1;
128 |     }
129 |     return 0;
130 | }
131 | 
132 | int flipSouth(int x ,int y, int table[row][column],int player){    ////
133 |     if (validSouth(x,y,x,y,table,player)== -1)  return 1;
134 |     table[y][x] =player;
135 |     y+=1;
136 |     while(table[y][x] == 3 - player){
137 |         table[y][x]= player;
138 |         y+=1;
139 |     }
140 |     return 0;
141 | }
142 | 
143 | int flipWest(int x ,int y, int table[row][column],int player){     ////
144 |     if (validWest(x,y,x,y,table,player)== -1)  return 1;
145 |     table[y][x] = player;
146 |     x-=1;
147 |     while(table[y][x] == 3 - player){
148 |         table[y][x]= player;
149 |         x-=1;
150 |     }
151 |     return 0;
152 | }
153 | 
154 | int flipEast(int x ,int y, int table[row][column],int player){     ////
155 |     if (validEast(x,y,x,y,table,player)== -1)  return 1;
156 |     table[y][x] = player;
157 |     x+=1;
158 |     while(table[y][x] == 3 - player){
159 |         table[y][x]=player;
160 |         x+=1;
161 |     }
162 |     return 0;
163 | }
164 | 
165 | int flipNW(int x ,int y, int table[row][column],int player){       ////
166 |     if (validNW(x,y,x,y,table,player)== -1)  return 1;
167 |     table[y][x] = player;
168 |     y-=1;   x-=1;
169 |     while(table[y][x] == 3 - player){
170 |         table[y][x]= player;
171 |         y-=1;   x-=1;
172 |     }
173 |     return 0;
174 | }
175 | 
176 | int flipNE(int x ,int y, int table[row][column],int player){
177 |     if (validNE(x,y,x,y,table,player)== -1)  return 1;
178 |     table[y][x] = player;
179 |     y-=1;   x+=1;
180 |     while(table[y][x] == 3 - player){
181 |         table[y][x]= player;
182 |         y-=1;   x+=1;
183 |     }
184 |     return 0;
185 | }
186 | 
187 | int flipSW(int x ,int y, int table[row][column],int player){
188 |     if (validSW(x,y,x,y,table,player)== -1)  return 1;
189 |     table[y][x] = player;
190 |     y+=1;   x-=1;
191 |     while(table[y][x] == 3 - player){
192 |         table[y][x]= player;
193 |         y+=1;   x-=1;
194 |     }
195 |     return 0;
196 | }
197 | 
198 | int flipSE(int x ,int y, int table[row][column],int player){
199 |     if (validSE(x,y,x,y,table,player)== -1)  return 1;
200 |     table[y][x] = player;
201 |     y+=1;   x+=1;
202 |     while(table[y][x] == 3 - player){
203 |         table[y][x]= player;
204 |         y+=1;   x+=1;
205 |     }
206 |     return 0;
207 | }
208 | 
209 | int doFlip(int x ,int y, int table[row][column],int player){
210 |     int result = 1;
211 |     result *=flipNorth(x ,y,table,player);
212 |     result *=flipSouth(x ,y,table,player);
213 |     result *=flipEast(x ,y,table,player);
214 |     result *=flipWest(x ,y,table,player);
215 |     result *=flipNE(x ,y,table,player);
216 |     result *=flipNW(x ,y,table,player);
217 |     result *=flipSE(x ,y,table,player);
218 |     result *=flipSW(x ,y,table,player);
219 |     return 1-result;
220 | }


--------------------------------------------------------------------------------
/judge.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <stdexcept>
  3 | #include <stdio.h>
  4 | #include <string>
  5 | #include <stdlib.h>
  6 | #include <cstring>
  7 | 
  8 | #include "flip.cpp"
  9 | 
 10 | #define NoTeams 3
 11 | 
 12 | using namespace std;
 13 | 
 14 | string intArrayToString(int int_array[], int size_of_array) {
 15 |   string returnstring = "";
 16 |   for (int temp = 0; temp < size_of_array; temp++)
 17 |     returnstring += int_array[temp]+'0';
 18 |   return returnstring;
 19 | }
 20 | 
 21 | string exec(string str) {
 22 |     char cmd[str.size() + 1];
 23 | 	strcpy(cmd, str.c_str());	
 24 |     char buffer[128];
 25 |     string result = "";
 26 |     FILE* pipe = popen(cmd, "r");
 27 |     if (!pipe) throw runtime_error("popen() failed!");
 28 |     try {
 29 |         while (fgets(buffer, sizeof buffer, pipe) != NULL) {
 30 |             result += buffer;
 31 |         }
 32 |     } catch (...) {
 33 |         pclose(pipe);
 34 |         throw;
 35 |     }
 36 |     pclose(pipe);
 37 |     return result;
 38 | }
 39 | 
 40 | string boardToArgv(int board[][column]){
 41 |     string str[column];
 42 |     for(int i=0;i<row;i++){
 43 |         int array[column];
 44 |         for(int j=0;j<8;j++){
 45 |         array[j]=board[i][j];
 46 |         }
 47 |         str[i]=intArrayToString(array,column);
 48 |     }
 49 |     string argv = " ";
 50 |     for(int i =0;i<8;i++){
 51 |         argv+= str[i];
 52 |         argv+=" ";
 53 |     }
 54 |     return argv;
 55 | }
 56 | 
 57 | void printBoard(int table[row][column]){
 58 |     cout<<"  ";
 59 |     for(int i=0;i<column;i++)   cout<<i<<" ";
 60 |     cout<< std::endl;
 61 |     for(int i=0;i<row;i++){
 62 |         cout<<i<<" ";
 63 |         for(int j=0;j<column;j++){
 64 |             cout<<table[i][j]<<" ";
 65 |         }
 66 |         cout<< std::endl;
 67 |     }
 68 | 
 69 | }
 70 | 
 71 | int copyBoard(const int board1[row][column],int board2[row][column]){
 72 |     for(int i=0;i<column;i++){
 73 |         for(int j=0;j<row;j++){
 74 |             board2[i][j]=board1[i][j];
 75 |         }
 76 |     }
 77 | }
 78 | 
 79 | int winner(const int board[row][column]){
 80 |     int p1=0;
 81 |     int p2=0;
 82 |     for(int i=0;i<column;i++){
 83 |         for(int j=0;j<row;j++){
 84 |             if(board[i][j]==1)  p1++;
 85 |             if(board[i][j]==2)  p2++;
 86 |         }
 87 |     }
 88 |     if(p1>p2)   return 1;
 89 |     if(p1==p2)  return 0;
 90 |     if(p2>p1)   return 2;
 91 | }
 92 | 
 93 | void printBoardToFile(const int board[row][column],FILE *fptr){
 94 |     fprintf(fptr,"%s","   0 1 2 3 4 5 6 7\n");
 95 |     string str[column];
 96 |     for(int i=0;i<row;i++){
 97 |         fprintf(fptr,"%d",i);
 98 |         fprintf(fptr,"%s"," :");
 99 |         for(int j=0;j<8;j++){
100 |             fprintf(fptr,"%d",board[i][j]);
101 |             fprintf(fptr,"%s"," ");
102 |         }
103 |         // str[i]="i :"+intArrayToString(array,column)+"\n";
104 |         // char stri[str[i].size() + 1];
105 | 	    // strcpy(stri, str[i].c_str());
106 |         fprintf(fptr,"%s","\n");
107 |     }
108 | }
109 | 
110 | 
111 | void play(string black,string white,int board[][column],int player,int *result){
112 |     
113 |     string argv = boardToArgv(board);
114 | 
115 |     if(player == 1)
116 |         argv ="./codes/" + black + argv + "1";
117 |     else
118 |         argv ="./codes/" + white + argv + "2";
119 | 
120 |     string value = exec(argv);
121 | 
122 |     int x = value[0] - 48;
123 |     int y = value[2] - 48;
124 | 
125 |     FILE *fptr;
126 |     string name ="./logs/" + black + " - " + white+".txt";
127 |     char nameChar[name.size() + 1];
128 | 	strcpy(nameChar, name.c_str());
129 |     fptr = fopen(nameChar,"a");
130 |     if(doFlip(x,y,board,player) && isInTable(x,y)){
131 |         string str;
132 |         string xStr = to_string(x);
133 |         string yStr = to_string(y);
134 |         string playerStr = to_string(player);
135 |         str = "-Player: "+playerStr+"  -Move :"+xStr+","+yStr+"\n";
136 |         char stri[str.size() + 1];
137 | 	    strcpy(stri, str.c_str());
138 |         fprintf(fptr,"%s",stri);
139 |         
140 |         // cout<<"-Player: "<<player<<"  -Move :"<<x<<","<<y<<endl ;
141 |         *result = 0;
142 |         
143 |     }else{
144 |         string str;
145 |         string xStr = to_string(x);
146 |         string yStr = to_string(y);
147 |         string playerStr = to_string(player);
148 |         str = "-Player: "+playerStr+" Cant Move/Invalid Move !: "+xStr+","+yStr+"\n";
149 |         char stri[str.size() + 1];
150 | 	    strcpy(stri, str.c_str());
151 |         fprintf(fptr,"%s",stri);
152 | 
153 |         // cout<< "-Player: "<<player<<" Cant Move/Invalid Move !: "<<x<<","<<y<<endl;
154 |         *result+=1;
155 |     }
156 |     printBoardToFile(board,fptr);
157 |     // printBoard(board);
158 |     fprintf(fptr,"%s","-----------------------\n");
159 |     // cout<<"-----------------------"<<endl;
160 |     fclose(fptr);
161 | }
162 | 
163 | int game(string black,string white,int board1[][column]){
164 |     int result = 0;
165 |     int count =0;
166 |     int board[row][column];
167 |     copyBoard(board1,board);
168 | 
169 |     FILE *fgame;
170 |     fgame=fopen("games.txt","a");
171 | 
172 |     while(1){
173 |         play(black,white,board,count%2+1,&result);
174 |         if(result == 2) break;
175 |         count ++;
176 |     }
177 | 
178 |     if(winner(board)==1){
179 |         string str = black + " > " + white+"\n";
180 |         char stri[str.size() + 1];
181 | 	    strcpy(stri, str.c_str());
182 |         fprintf(fgame,"%s",stri);
183 | 
184 |         cout << black << " > " << white;
185 |         return 1;
186 |     }else if(winner(board)==2){
187 |         string str = black + " > " + white+"\n";
188 |         char stri[str.size() + 1];
189 | 	    strcpy(stri, str.c_str());
190 |         fprintf(fgame,"%s",stri);
191 | 
192 |         cout << black << " < " << white;
193 |         return 2;
194 |     }else if(winner(board)==0){
195 |         string str = black + " > " + white+"\n";
196 |         char stri[str.size() + 1];
197 | 	    strcpy(stri, str.c_str());
198 |         fprintf(fgame,"%s",stri);
199 | 
200 |         cout << black << " = " << white;
201 |         return 0;
202 |     }
203 |     fclose(fgame);
204 | }
205 | 
206 | int main(){
207 |     const string Team[]={
208 |         "Force",
209 |         "LQ",
210 |         // "iran16",
211 |         // "Magic_world",
212 |         // "SSDEBF",
213 |         // "MONOLITH",
214 |         // "Loser",
215 |         // "NumOne01",
216 |         // "flipper_the_dolphin",
217 |         // "Oftaadegaan",
218 |         // "shift",
219 |         "Boro_dame_khoontoon_bazi_kon",
220 |         // "EH"
221 |     };
222 |     int table[NoTeams][3]={0};
223 | 
224 |     int board[8][8]={
225 |         {0, 0 ,0 ,0 ,0 ,0 ,0 ,0},
226 | 
227 |         {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0},
228 | 
229 |         {0, 0 ,0 ,0 ,0 ,0 ,0 ,0},
230 | 
231 |         {0 ,0 ,0 ,2 ,1 ,0 ,0 ,0},
232 | 
233 |         {0 ,0 ,0 ,1 ,2 ,0 ,0 ,0},
234 | 
235 |         {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0},
236 | 
237 |         {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0},
238 | 
239 |         {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0}        
240 |     };
241 |     int result;
242 |     for(int i =0;i<NoTeams;i++){
243 |         for(int j=i+1;j<NoTeams;j++){
244 |             result = game(Team[i],Team[j],board);
245 |             if(result==1){
246 |                 table[i][0]++;
247 |                 table[j][2]++;
248 |             }else if(result==2){
249 |                 table[j][0]++;
250 |                 table[i][2]++;
251 |             }else if(result==0){
252 |                 table[j][1]++;
253 |                 table[i][1]++;
254 |             }
255 |             getchar();
256 |             result = game(Team[j],Team[i],board);
257 |             if(result==1){
258 |                 table[j][0]++;
259 |                 table[i][2]++;
260 |             }else if(result==2){
261 |                 table[i][0]++;
262 |                 table[j][2]++;
263 |             }else if(result==0){
264 |                 table[j][1]++;
265 |                 table[i][1]++;
266 |             }
267 |             getchar();
268 |         }
269 |     }
270 |     
271 |     FILE *fscore;
272 |     fscore = fopen("score.txt","a");
273 |     fprintf(fscore,"%s","Teams");
274 |     fprintf(fscore,"%s","\t\t\t\t");
275 |     fprintf(fscore,"%s\t%s\t%s\n","Wins","draws","Loses");
276 |     for(int i=0;i<NoTeams;i++){
277 |         char stri[Team[i].size() + 1];
278 | 	    strcpy(stri, Team[i].c_str());
279 |         fprintf(fscore,"%s",stri);
280 |         fprintf(fscore,"%s","\t\t\t\t");
281 |         fprintf(fscore,"%d\t%d\t%d\n",table[i][0],table[i][1],table[i][2]);
282 |     }
283 | 
284 |     fclose(fscore);
285 | 
286 |     return 0;
287 | }


--------------------------------------------------------------------------------