fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define GRID_SIZE 6
  6. #define NUM_MINES 6
  7.  
  8. // Function to initialize the board with empty spaces
  9. void initializeBoard(char board[GRID_SIZE][GRID_SIZE], char display[GRID_SIZE][GRID_SIZE]) {
  10.     for (int i = 0; i < GRID_SIZE; i++) {
  11.         for (int j = 0; j < GRID_SIZE; j++) {
  12.             board[i][j] = ' ';
  13.             display[i][j] = '-'; // # represents hidden cells
  14.         }
  15.     }
  16. }
  17.  
  18. // Function to place mines randomly on the board
  19. void placeMines(char board[GRID_SIZE][GRID_SIZE]) {
  20.     int count = 0;
  21.     while (count < NUM_MINES) {
  22.         int row = rand() % GRID_SIZE;
  23.         int col = rand() % GRID_SIZE;
  24.         if (board[row][col] != 'M') { // If it's not already a mine
  25.             board[row][col] = 'M'; // Place a mine
  26.             count++;
  27.         }
  28.     }
  29. }
  30.  
  31. // Function to count the number of adjacent mines around a cell
  32. int countAdjacentMines(char board[GRID_SIZE][GRID_SIZE], int row, int col) {
  33.     int count = 0;
  34.     int directions[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
  35.  
  36.     for (int i = 0; i < 8; i++) {
  37.         int r = row + directions[i][0];
  38.         int c = col + directions[i][1];
  39.  
  40.         if (r >= 0 && r < GRID_SIZE && c >= 0 && c < GRID_SIZE) {
  41.             if (board[r][c] == 'M') {
  42.                 count++;
  43.             }
  44.         }
  45.     }
  46.  
  47.     return count;
  48. }
  49.  
  50. // Function to reveal a cell
  51. int revealCell(char board[GRID_SIZE][GRID_SIZE], char display[GRID_SIZE][GRID_SIZE], int row, int col) {
  52.     if (display[row][col] != '|') {
  53.         return 0; // Cell is already revealed
  54.     }
  55.  
  56.     display[row][col] = board[row][col]; // Reveal the cell
  57.  
  58.     if (board[row][col] == 'M') {
  59.         return 1; // Game Over
  60.     }
  61.  
  62.     // If no adjacent mines, recursively reveal neighboring cells
  63.     if (board[row][col] == ' ') {
  64.         int directions[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
  65.         for (int i = 0; i < 8; i++) {
  66.             int r = row + directions[i][0];
  67.             int c = col + directions[i][1];
  68.  
  69.             if (r >= 0 && r < GRID_SIZE && c >= 0 && c < GRID_SIZE && display[r][c] == '#') {
  70.                 revealCell(board, display, r, c);
  71.             }
  72.         }
  73.     }
  74.  
  75.     return 0; // Continue game
  76. }
  77.  
  78. // Function to check if all non-mine cells are revealed
  79. int checkWin(char board[GRID_SIZE][GRID_SIZE], char display[GRID_SIZE][GRID_SIZE]) {
  80.     for (int i = 0; i < GRID_SIZE; i++) {
  81.         for (int j = 0; j < GRID_SIZE; j++) {
  82.             if (board[i][j] != 'M' && display[i][j] == '- |') {
  83.                 return 0; // Not all non-mine cells are revealed
  84.             }
  85.         }
  86.     }
  87.     return 1; // Player wins
  88. }
  89.  
  90. // Function to print the board
  91. void printBoard(char display[GRID_SIZE][GRID_SIZE]) {
  92.     printf("  ");
  93.     for (int i = 0; i < GRID_SIZE; i++) {
  94.         printf("%d ", i);
  95.     }
  96.     printf("\n");
  97.  
  98.     for (int i = 0; i < GRID_SIZE; i++) {
  99.         printf("%d ", i);
  100.         for (int j = 0; j < GRID_SIZE; j++) {
  101.             printf("%c ", display[i][j]);
  102.         }
  103.         printf("\n");
  104.     }
  105. }
  106.  
  107. int main() {
  108.     srand(time(NULL)); // Seed for random number generator
  109.  
  110.     char board[GRID_SIZE][GRID_SIZE];
  111.     char display[GRID_SIZE][GRID_SIZE];
  112.  
  113.     initializeBoard(board, display);
  114.     placeMines(board);
  115.  
  116.     // Fill board with numbers indicating adjacent mines
  117.     for (int i = 0; i < GRID_SIZE; i++) {
  118.         for (int j = 0; j < GRID_SIZE; j++) {
  119.             if (board[i][j] != 'M') {
  120.                 int adjacentMines = countAdjacentMines(board, i, j);
  121.                 if (adjacentMines > 0) {
  122.                     board[i][j] = '0' + adjacentMines;
  123.                 }
  124.             }
  125.         }
  126.     }
  127.  
  128.     int gameOver = 0;
  129.     int row, col;
  130.  
  131.     // Main game loop
  132.     while (!gameOver) {
  133.         printBoard(display);
  134.  
  135.         printf("Enter row and column (0-5): ");
  136.         scanf("%d %d", &row, &col);
  137.  
  138.         if (row < 0 || row >= GRID_SIZE || col < 0 || col >= GRID_SIZE) {
  139.             printf("Invalid input! Please enter valid row and column.\n");
  140.             continue;
  141.         }
  142.  
  143.         // Reveal the selected cell
  144.         gameOver = revealCell(board, display, row, col);
  145.  
  146.         // Check for win condition
  147.         if (checkWin(board, display)) {
  148.             printBoard(display);
  149.             printf("You won! Congratulations!\n");
  150.             break;
  151.         }
  152.  
  153.         if (gameOver) {
  154.             printBoard(display);
  155.             printf("Game Over! You hit a mine.\n");
  156.         }
  157.     }
  158.  
  159.     return 0;
  160. }
Success #stdin #stdout 0.01s 5288KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
  0 1 2 3 4 5 
0 - - - - - - 
1 - - - - - - 
2 - - - - - - 
3 - - - - - - 
4 - - - - - - 
5 - - - - - - 
Enter row and column (0-5):   0 1 2 3 4 5 
0 - - - - - - 
1 - - - - - - 
2 - - - - - - 
3 - - - - - - 
4 - - - - - - 
5 - - - - - - 
You won! Congratulations!
https://ideone.com/SSyVXq
language:
C (gcc 8.3)
created:
10 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!