生命游戏

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include <stdio.h> 
#include <stdlib.h> 
#include <ctype.h> 

#define MAXROW 10 
#define MAXCOL 25 
#define DEAD 0 
#define ALIVE 1 
int map[MAXROW][MAXCOL], newmap[MAXROW][MAXCOL]; 

void init(); 
int neighbors(int, int);
void outputMap();
void copyMap();

int main() { 
   int row, col; 
   char ans; 

   init();

   while(1) {
      outputMap();
      for(row = 0; row < MAXROW; row++) {
         for(col = 0; col < MAXCOL; col++) {
            switch (neighbors(row, col)) {
               case 0: 
               case 1: 
               case 4: 
               case 5: 
               case 6: 
               case 7: 
               case 8: 
                  newmap[row][col] = DEAD; 
                  break; 
               case 2: 
                  newmap[row][col] = map[row][col]; 
                  break; 
               case 3: 
                  newmap[row][col] = ALIVE; 
                  break; 
            } 
         }
      }

      copyMap();

      printf("\nContinue next Generation ? ");
      getchar();
      ans = toupper(getchar());

      if(ans != 'Y')
          break;
   }
    
   return 0; 
} 

void init() {
   int row, col; 
    
   for(row = 0; row < MAXROW; row++) 
      for(col = 0; col < MAXCOL; col++) 
         map[row][col] = DEAD; 

   puts("Game of life Program"); 
   puts("Enter x, y where x, y is living cell");
   printf("0 <= x <= %d, 0 <= y <= %d\n", 
                 MAXROW-1, MAXCOL-1); 
   puts("Terminate with x, y = -1, -1");

   while(1) {
      scanf("%d %d", &row, &col); 
      if(0 <= row && row < MAXROW && 
         0 <= col && col < MAXCOL)
         map[row][col] = ALIVE;
      else if(row == -1 || col == -1)
         break;
      else 
         printf("(x, y) exceeds map ranage!"); 
   }
}

int neighbors(int row, int col) {
   int count = 0, c, r; 

   for(r = row-1; r <= row+1; r++) 
      for(c = col-1; c <= col+1; c++) { 
         if(r < 0 || r >= MAXROW || c < 0 || c >= MAXCOL) 
            continue; 
         if(map[r][c] == ALIVE) 
            count++; 
      } 

   if(map[row][col] == ALIVE) 
      count--; 
    
   return count; 
} 

void outputMap() {
   int row, col; 

   printf("\n\n%20cGame of life cell status\n"); 
   for(row = 0; row < MAXROW; row++) { 
      printf("\n%20c", ' '); 
      for(col = 0; col < MAXCOL; col++) 
         if(map[row][col] == ALIVE) 
            putchar('#'); 
         else 
            putchar('-'); 
   } 
} 

void copyMap() {
   int row, col; 

   for(row = 0; row < MAXROW; row++) 
      for(col = 0; col < MAXCOL; col++) 
         map[row][col] = newmap[row][col]; 
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LifeGame {
    private boolean[][] map;
    private boolean[][] newmap;
    
    public LifeGame(int maxRow, int maxColumn) {
        map = new boolean[maxRow][maxColumn];
        newmap = new boolean[maxRow][maxColumn];
    }
    
    public void setCell(int x, int y) {
        map[x][y] = true;
    }
    
    public void next() {
        for(int row = 0; row < map.length; row++) {
            for(int col = 0; col < map[0].length; col++) {
               switch (neighbors(row, col)) {
                  case 0: 
                  case 1: 
                  case 4: 
                  case 5: 
                  case 6: 
                  case 7: 
                  case 8: 
                     newmap[row][col] = false; 
                     break; 
                  case 2: 
                     newmap[row][col] = map[row][col]; 
                     break; 
                  case 3: 
                     newmap[row][col] = true; 
                     break; 
               } 
            }
         }

         copyMap();
    }

    public void outputMap() throws IOException { 
        System.out.println("\n\nGame of life cell status"); 
        for(int row = 0; row < map.length; row++) { 
            System.out.print("\n "); 
           for(int col = 0; col < map[0].length; col++) 
              if(map[row][col] == true) 
                  System.out.print('#'); 
              else 
                  System.out.print('-'); 
        } 
    }
    
    private void copyMap() {
        for(int row = 0; row < map.length; row++) 
           for(int col = 0; col < map[0].length; col++) 
              map[row][col] = newmap[row][col]; 
    }
    
    private int neighbors(int row, int col) {
        int count = 0; 

        for(int r = row-1; r <= row+1; r++) 
           for(int c = col-1; c <= col+1; c++) { 
              if(r < 0 || r >= map.length ||
                 c < 0 || c >= map[0].length) 
                 continue; 
              if(map[r][c] == true) 
                 count++; 
           } 

        if(map[row][col] == true) 
           count--; 
         
        return count; 
    } 
    
    public static void main(String[] args) 
                 throws NumberFormatException, IOException {
        BufferedReader bufReader = 
            new BufferedReader(
                    new InputStreamReader(System.in));
        
        LifeGame game = new LifeGame(10, 25);
        
        System.out.println("Game of life Program"); 
        System.out.println(
                   "Enter x, y where x, y is living cell");
        System.out.println("0 <= x < 10, 0 <= y < 25"); 
        System.out.println("Terminate with x, y = -1, -1");
        
        while(true) {
            String[] strs = bufReader.readLine().split(" ");
            int row = Integer.parseInt(strs[0]);
            int col = Integer.parseInt(strs[1]);

            if(0 <= row && row < 10 && 0 <= col && row < 25) 
                game.setCell(row, col);
            else if(row == -1 || col == -1) {
                break;
            }
            else { 
                System.out.print(
                         "(x, y) exceeds map ranage!");
            }
        }
        
        while(true) {
            game.outputMap();
            game.next();

            System.out.print(
                         "\nContinue next Generation ? ");
            
            String ans = bufReader.readLine().toUpperCase();

            if(!ans.equals("Y"))
                break;
        } 
    }
}