• Source 
    1. #include<bits/stdc++.h>
    2.  
    3. using namespace std;
    4.  
    5. int king_x[8]= {-1,0,1,0,-1,-1,1,1};
    6.  
    7. int king_y[8]= {0,1,0,-1,-1,1,1,-1};
    8.  
    9. int knight_x[8]= {2,1,-1,-2,-2,-1,1,2};
    10.  
    11. int knight_y[8]= {1,2,2,1,-1,-2,-2,-1};
    12.  
    13. int main()
    14. {
    15.     int i,j,k,l,u,v,tc=0;
    16.  
    17.     char grid[10][10];
    18.  
    19.     while(1)
    20.     {
    21.         tc++;
    22.  
    23.         for(i=0; i<8; i++)
    24.         {
    25.             scanf("%s",grid[i]);
    26.         }
    27.  
    28.         int is_blank = 0;
    29.  
    30.         for(i=0; i<8; i++)
    31.         {
    32.             for(j=0; j<8; j++)
    33.             {
    34.                 if(grid[i][j]=='.')
    35.                     is_blank++;
    36.             }
    37.         }
    38.  
    39.         if(is_blank==64)
    40.             break;
    41.  
    42.         bool tag = false;
    43.  
    44.         for(i=0; i<8; i++)
    45.         {
    46.             for(j=0; j<8; j++)
    47.             {
    48.                 tag = false;
    49.  
    50.                 if(grid[i][j]=='p')
    51.                 {
    52.                     if(grid[i+1][j-1]=='K'||grid[i+1][j+1]=='K')
    53.                     {
    54.                         printf("Game #%d: white king is in check.\n",tc);
    55.  
    56.                         tag = true;
    57.  
    58.                         break;
    59.                     }
    60.                 }
    61.  
    62.                 else if(grid[i][j]=='P')
    63.                 {
    64.                     if(grid[i-1][j-1]=='k'||grid[i-1][j+1]=='k')
    65.                     {
    66.                         printf("Game #%d: black king is in check.\n",tc);
    67.  
    68.                         tag = true;
    69.  
    70.                         break;
    71.                     }
    72.                 }
    73.  
    74.                 if(grid[i][j]=='r'||grid[i][j]=='q')
    75.                 {
    76.                     tag = false;
    77.  
    78.                     for(k=j+1; k<8; k++)
    79.                     {
    80.                         if(grid[i][k]=='.')
    81.                             continue;
    82.  
    83.                         if(grid[i][k]!='K')
    84.                         {
    85.                             tag = false;
    86.  
    87.                             break;
    88.                         }
    89.                         else
    90.                         {
    91.                             tag = true;
    92.  
    93.                             break;
    94.                         }
    95.                     }
    96.  
    97.                     if(!tag)
    98.                     for(k=j-1; k>=0; k--)
    99.                     {
    100.                         if(grid[i][k]=='.')
    101.                             continue;
    102.  
    103.                         if(grid[i][k]!='K')
    104.                         {
    105.                             tag = false;
    106.  
    107.                             break;
    108.                         }
    109.                         else
    110.                         {
    111.                             tag = true;
    112.  
    113.                             break;
    114.                         }
    115.                     }
    116.  
    117.                     if(!tag)
    118.                     for(k=i+1; k<8; k++)
    119.                     {
    120.                         if(grid[k][j]=='.')
    121.                             continue;
    122.  
    123.                         if(grid[k][j]!='K')
    124.                         {
    125.                             tag = false;
    126.  
    127.                             break;
    128.                         }
    129.                         else
    130.                         {
    131.                             tag = true;
    132.  
    133.                             break;
    134.                         }
    135.                     }
    136.  
    137.                     if(!tag)
    138.                     for(k=i-1; k>=0; k--)
    139.                     {
    140.                         if(grid[k][j]=='.')
    141.                             continue;
    142.  
    143.                         if(grid[k][j]!='K')
    144.                         {
    145.                             tag = false;
    146.  
    147.                             break;
    148.                         }
    149.                         else
    150.                         {
    151.                             tag = true;
    152.  
    153.                             break;
    154.                         }
    155.                     }
    156.  
    157.                     if(tag)
    158.                     {
    159.                         printf("Game #%d: white king is in check.\n",tc);
    160.  
    161.                         break;
    162.                     }
    163.                 }
    164.                 else if(grid[i][j]=='R'||grid[i][j]=='Q')
    165.                 {
    166.                     tag = false;
    167.  
    168.                     for(k=j+1; k<8; k++)
    169.                     {
    170.                         if(grid[i][k]=='.')
    171.                             continue;
    172.  
    173.                         if(grid[i][k]!='k')
    174.                         {
    175.                             tag = false;
    176.  
    177.                             break;
    178.                         }
    179.                         else
    180.                         {
    181.                             tag = true;
    182.  
    183.                             break;
    184.                         }
    185.                     }
    186.  
    187.                     if(!tag)
    188.                     for(k=j-1; k>=0; k--)
    189.                     {
    190.                         if(grid[i][k]=='.')
    191.                             continue;
    192.  
    193.                         if(grid[i][k]!='k')
    194.                         {
    195.                             tag = false;
    196.  
    197.                             break;
    198.                         }
    199.                         else
    200.                         {
    201.                             tag = true;
    202.  
    203.                             break;
    204.                         }
    205.                     }
    206.  
    207.                     if(!tag)
    208.                     for(k=i+1; k<8; k++)
    209.                     {
    210.                         if(grid[k][j]=='.')
    211.                             continue;
    212.  
    213.                         if(grid[k][j]!='k')
    214.                         {
    215.                             tag = false;
    216.  
    217.                             break;
    218.                         }
    219.                         else
    220.                         {
    221.                             tag = true;
    222.  
    223.                             break;
    224.                         }
    225.                     }
    226.  
    227.                     if(!tag)
    228.                     for(k=i-1; k>=0; k--)
    229.                     {
    230.                         if(grid[k][j]=='.')
    231.                             continue;
    232.  
    233.                         if(grid[k][j]!='k')
    234.                         {
    235.                             tag = false;
    236.  
    237.                             break;
    238.                         }
    239.                         else
    240.                         {
    241.                             tag = true;
    242.  
    243.                             break;
    244.                         }
    245.                     }
    246.  
    247.                     if(tag)
    248.                     {
    249.                         printf("Game #%d: black king is in check.\n",tc);
    250.  
    251.                         break;
    252.                     }
    253.                 }
    254.  
    255.                 if(grid[i][j]=='b'||grid[i][j]=='q')
    256.                 {
    257.                     tag = false;
    258.  
    259.                     for(k=i+1,l=j+1; k<8; k++,l++)
    260.                     {
    261.                         if(grid[k][l]=='.')
    262.                             continue;
    263.  
    264.                         if(grid[k][l]!='K')
    265.                         {
    266.                             tag = false;
    267.  
    268.                             break;
    269.                         }
    270.                         else
    271.                         {
    272.                             tag = true;
    273.  
    274.                             break;
    275.                         }
    276.                     }
    277.  
    278.                     if(!tag)
    279.                     for(k=i-1,l=j-1; k>=0; k--,l--)
    280.                     {
    281.                         if(grid[k][l]=='.')
    282.                             continue;
    283.  
    284.                         if(grid[k][l]!='K')
    285.                         {
    286.                             tag = false;
    287.  
    288.                             break;
    289.                         }
    290.                         else
    291.                         {
    292.                             tag = true;
    293.  
    294.                             break;
    295.                         }
    296.                     }
    297.  
    298.                     if(!tag)
    299.                     for(k=i+1,l=j-1; k<8; k++,l--)
    300.                     {
    301.                         if(grid[k][l]=='.')
    302.                             continue;
    303.  
    304.                         if(grid[k][l]!='K')
    305.                         {
    306.                             tag = false;
    307.  
    308.                             break;
    309.                         }
    310.                         else
    311.                         {
    312.                             tag = true;
    313.  
    314.                             break;
    315.                         }
    316.                     }
    317.  
    318.                     if(!tag)
    319.                     for(k=i-1,l=j+1; k>=0; k--,l++)
    320.                     {
    321.                         if(grid[k][l]=='.')
    322.                             continue;
    323.  
    324.                         if(grid[k][l]!='K')
    325.                         {
    326.                             tag = false;
    327.  
    328.                             break;
    329.                         }
    330.                         else
    331.                         {
    332.                             tag = true;
    333.  
    334.                             break;
    335.                         }
    336.                     }
    337.  
    338.                     if(tag)
    339.                     {
    340.                         printf("Game #%d: white king is in check.\n",tc);
    341.  
    342.                         break;
    343.                     }
    344.                 }
    345.  
    346.                 else if(grid[i][j]=='B'||grid[i][j]=='Q')
    347.                 {
    348.                     tag = false;
    349.  
    350.                     for(k=i+1,l=j+1; k<8; k++,l++)
    351.                     {
    352.                         if(grid[k][l]=='.')
    353.                             continue;
    354.  
    355.                         if(grid[k][l]!='k')
    356.                         {
    357.                             tag = false;
    358.  
    359.                             break;
    360.                         }
    361.                         else
    362.                         {
    363.                             tag = true;
    364.  
    365.                             break;
    366.                         }
    367.                     }
    368.  
    369.                     if(!tag)
    370.                     for(k=i-1,l=j-1; k>=0; k--,l--)
    371.                     {
    372.                         if(grid[k][l]=='.')
    373.                             continue;
    374.  
    375.                         if(grid[k][l]!='k')
    376.                         {
    377.                             tag = false;
    378.  
    379.                             break;
    380.                         }
    381.                         else
    382.                         {
    383.                             tag = true;
    384.  
    385.                             break;
    386.                         }
    387.                     }
    388.  
    389.                     if(!tag)
    390.                     for(k=i+1,l=j-1; k<8; k++,l--)
    391.                     {
    392.                         if(grid[k][l]=='.')
    393.                             continue;
    394.  
    395.                         if(grid[k][l]!='k')
    396.                         {
    397.                             tag = false;
    398.  
    399.                             break;
    400.                         }
    401.                         else
    402.                         {
    403.                             tag = true;
    404.  
    405.                             break;
    406.                         }
    407.                     }
    408.  
    409.                     if(!tag)
    410.                     for(k=i-1,l=j+1; k>=0; k--,l++)
    411.                     {
    412.                         if(grid[k][l]=='.')
    413.                             continue;
    414.  
    415.                         if(grid[k][l]!='k')
    416.                         {
    417.                             tag = false;
    418.  
    419.                             break;
    420.                         }
    421.                         else
    422.                         {
    423.                             tag = true;
    424.  
    425.                             break;
    426.                         }
    427.                     }
    428.  
    429.                     if(tag)
    430.                     {
    431.                         printf("Game #%d: black king is in check.\n",tc);
    432.  
    433.                         break;
    434.                     }
    435.                 }
    436.  
    437.                 if(grid[i][j]=='n')
    438.                 {
    439.                     tag = false;
    440.  
    441.                     for(k=0; k<8; k++)
    442.                     {
    443.                         u = i+knight_x[k];
    444.  
    445.                         v = j+knight_y[k];
    446.  
    447.                         if(grid[u][v]=='K')
    448.                         {
    449.                             tag = true;
    450.  
    451.                             printf("Game #%d: white king is in check.\n",tc);
    452.  
    453.                             break;
    454.                         }
    455.                     }
    456.                 }
    457.  
    458.                 else if(grid[i][j]=='N')
    459.                 {
    460.                     tag = false;
    461.  
    462.                     for(k=0; k<8; k++)
    463.                     {
    464.                         u = i+knight_x[k];
    465.  
    466.                         v = j+knight_y[k];
    467.  
    468.                         if(grid[u][v]=='k')
    469.                         {
    470.                             tag = true;
    471.  
    472.                             printf("Game #%d: black king is in check.\n",tc);
    473.  
    474.                             break;
    475.                         }
    476.                     }
    477.                 }
    478.  
    479.                 if(tag)
    480.                     break;
    481.             }
    482.  
    483.             if(tag)
    484.                 break;
    485.         }
    486.  
    487.         if(!tag)
    488.             printf("Game #%d: no king is in check.\n",tc);
    489.     }
    490.  
    491.     return 0;
    492. }