fork(2) download 
  1.  
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4.  
  5. #define S 7
  6. #define M 4
  7. #define N (S*S) / M
  8.  
  9. int cell(int grid[S][S], int x, int y)
  10. {
  11.     if (x < 0 || x >= S) return 0;
  12.     if (y < 0 || y >= S) return 0;
  13.  
  14.     return grid[y][x];
  15. }
  16.  
  17. int solve(int *repo, int grid[S][S], int x, int y)
  18. {
  19.     if (y == S) {  
  20.         int i, j;
  21.  
  22.         for (i = 0; i < 7; i++) {
  23.             for (j = 0; j < 7; j++) {
  24.                 putchar(".RGYB"[grid[j][i]]);
  25.             }
  26.             putchar(10);
  27.         }
  28.         putchar(10);
  29.  
  30.         return 1;
  31.     } else {
  32.         int nextx = x + 1;
  33.         int nexty = y;
  34.         int res = 0;
  35.         int i;
  36.  
  37.         if (nextx == 7) {
  38.             nextx = 0;
  39.             nexty++;
  40.         }
  41.  
  42.         for (i = 0; i < M + 1; i++) {
  43.             if (repo[i] == 0) continue;
  44.             if (i && cell(grid, x - 1, y - 1) == i) continue;
  45.             if (i && cell(grid, x + 0, y - 1) == i) continue;
  46.             if (i && cell(grid, x + 1, y - 1) == i) continue;
  47.             if (i && cell(grid, x - 1, y + 0) == i) continue;
  48.  
  49.             grid[y][x] = i;
  50.             repo[i]--;
  51.  
  52.             res += solve(repo, grid, nextx, nexty);
  53.  
  54.             grid[y][x] = 0;
  55.             repo[i]++;
  56.         }
  57.  
  58.         return res;
  59.     }
  60. }
  61.  
  62. int main()
  63. {
  64.     int repo[M + 1] = {1, N, N, N, N};
  65.     int grid[S][S] = {{0}};
  66.     int n;
  67.  
  68.     n = solve(repo, grid, 0, 0);
  69.  
  70.     printf("%d cells, %d groups of %d prisoners: %d\n", S*S, M, N, n);
  71.  
  72.     return 0;
  73. }
  74.  
Success #stdin #stdout 0.08s 2168KB
comments (?)
stdin 
Standard input is empty
stdout 
RYRBGBG
GBGYRYR
RYRBGBG
GBG.YRY
YRYRBGB
BGBGYRY
YRYRBGB

RBRYGYG
GYGBRBR
RBRYGYG
GYG.BRB
BRBRYGY
YGYGBRB
BRBRYGY

RBRBGYG
GYGYRBR
RBRBGYG
YGY.RBR
BRBGYGY
YGYRBRB
BRBGYGY

RYRYGBG
GBGBRYR
RYRYGBG
BGB.RYR
YRYGBGB
BGBRYRY
YRYGBGB

RBRBYGY
YGYGRBR
RBRBYGY
GYG.RBR
BRBYGYG
GYGRBRB
BRBYGYG

RGRBYBY
YBYGRGR
RGRBYBY
YBY.GRG
GRGRBYB
BYBYGRG
GRGRBYB

RBRGYGY
YGYBRBR
RBRGYGY
YGY.BRB
BRBRGYG
GYGYBRB
BRBRGYG

RGRGYBY
YBYBRGR
RGRGYBY
BYB.RGR
GRGYBYB
BYBRGRG
GRGYBYB

RYRYBGB
BGBGRYR
RYRYBGB
GBG.RYR
YRYBGBG
GBGRYRY
YRYBGBG

RGRGBYB
BYBYRGR
RGRGBYB
YBY.RGR
GRGBYBY
YBYRGRG
GRGBYBY

RGRYBYB
BYBGRGR
RGRYBYB
BYB.GRG
GRGRYBY
YBYBGRG
GRGRYBY

RYRGBGB
BGBYRYR
RYRGBGB
BGB.YRY
YRYRGBG
GBGBYRY
YRYRGBG

GYGBRBR
RBRYGYG
GYGBRBR
RBR.YGY
YGYGBRB
BRBRYGY
YGYGBRB

GBGYRYR
RYRBGBG
GBGYRYR
RYR.BGB
BGBGYRY
YRYRBGB
BGBGYRY

GBGBRYR
RYRYGBG
GBGBRYR
YRY.GBG
BGBRYRY
YRYGBGB
BGBRYRY

GYGYRBR
RBRBGYG
GYGYRBR
BRB.GYG
YGYRBRB
BRBGYGY
YGYRBRB

GBGBYRY
YRYRGBG
GBGBYRY
RYR.GBG
BGBYRYR
RYRGBGB
BGBYRYR

GRGBYBY
YBYRGRG
GRGBYBY
YBY.RGR
RGRGBYB
BYBYRGR
RGRGBYB

GBGRYRY
YRYBGBG
GBGRYRY
YRY.BGB
BGBGRYR
RYRYBGB
BGBGRYR

GRGRYBY
YBYBGRG
GRGRYBY
BYB.GRG
RGRYBYB
BYBGRGR
RGRYBYB

GYGYBRB
BRBRGYG
GYGYBRB
RBR.GYG
YGYBRBR
RBRGYGY
YGYBRBR

GRGRBYB
BYBYGRG
GRGRBYB
YBY.GRG
RGRBYBY
YBYGRGR
RGRBYBY

GRGYBYB
BYBRGRG
GRGYBYB
BYB.RGR
RGRGYBY
YBYBRGR
RGRGYBY

GYGRBRB
BRBYGYG
GYGRBRB
BRB.YGY
YGYGRBR
RBRBYGY
YGYGRBR

YGYBRBR
RBRGYGY
YGYBRBR
RBR.GYG
GYGYBRB
BRBRGYG
GYGYBRB

YBYGRGR
RGRBYBY
YBYGRGR
RGR.BYB
BYBYGRG
GRGRBYB
BYBYGRG

YBYBRGR
RGRGYBY
YBYBRGR
GRG.YBY
BYBRGRG
GRGYBYB
BYBRGRG

YGYGRBR
RBRBYGY
YGYGRBR
BRB.YGY
GYGRBRB
BRBYGYG
GYGRBRB

YBYBGRG
GRGRYBY
YBYBGRG
RGR.YBY
BYBGRGR
RGRYBYB
BYBGRGR

YRYBGBG
GBGRYRY
YRYBGBG
GBG.RYR
RYRYBGB
BGBGRYR
RYRYBGB

YBYRGRG
GRGBYBY
YBYRGRG
GRG.BYB
BYBYRGR
RGRGBYB
BYBYRGR

YRYRGBG
GBGBYRY
YRYRGBG
BGB.YRY
RYRGBGB
BGBYRYR
RYRGBGB

YGYGBRB
BRBRYGY
YGYGBRB
RBR.YGY
GYGBRBR
RBRYGYG
GYGBRBR

YRYRBGB
BGBGYRY
YRYRBGB
GBG.YRY
RYRBGBG
GBGYRYR
RYRBGBG

YRYGBGB
BGBRYRY
YRYGBGB
BGB.RYR
RYRYGBG
GBGBRYR
RYRYGBG

YGYRBRB
BRBGYGY
YGYRBRB
BRB.GYG
GYGYRBR
RBRBGYG
GYGYRBR

BGBYRYR
RYRGBGB
BGBYRYR
RYR.GBG
GBGBYRY
YRYRGBG
GBGBYRY

BYBGRGR
RGRYBYB
BYBGRGR
RGR.YBY
YBYBGRG
GRGRYBY
YBYBGRG

BYBYRGR
RGRGBYB
BYBYRGR
GRG.BYB
YBYRGRG
GRGBYBY
YBYRGRG

BGBGRYR
RYRYBGB
BGBGRYR
YRY.BGB
GBGRYRY
YRYBGBG
GBGRYRY

BYBYGRG
GRGRBYB
BYBYGRG
RGR.BYB
YBYGRGR
RGRBYBY
YBYGRGR

BRBYGYG
GYGRBRB
BRBYGYG
GYG.RBR
RBRBYGY
YGYGRBR
RBRBYGY

BYBRGRG
GRGYBYB
BYBRGRG
GRG.YBY
YBYBRGR
RGRGYBY
YBYBRGR

BRBRGYG
GYGYBRB
BRBRGYG
YGY.BRB
RBRGYGY
YGYBRBR
RBRGYGY

BGBGYRY
YRYRBGB
BGBGYRY
RYR.BGB
GBGYRYR
RYRBGBG
GBGYRYR

BRBRYGY
YGYGBRB
BRBRYGY
GYG.BRB
RBRYGYG
GYGBRBR
RBRYGYG

BRBGYGY
YGYRBRB
BRBGYGY
YGY.RBR
RBRBGYG
GYGYRBR
RBRBGYG

BGBRYRY
YRYGBGB
BGBRYRY
YRY.GBG
GBGBRYR
RYRYGBG
GBGBRYR

49 cells, 4 groups of 12 prisoners: 48
https://ideone.com/c3hWkO
language:
C (gcc 8.3)
created:
8 years 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!