Ile pól atakuje król

Witam Serdecznie. Dopiero zacząłem swoją przygodę z C++ i potrzebuje pomocy z zadaniem dla córki.

Król może się przesuwać pionowo, poziomo i po przekątnej, ale tylko o jedno pole. Zdefiniuj funkcję ile_krol(int n, int x, int y), której parametrami są rozmiar szachownicy n oraz położenie figury (x, y), a wynikiem jest liczba pól ata­kowanych przez króla. Parametr n może przyjmować wartości od 2 do 30. Parametry x i y mogą przyjmować wartości od 1 do n. Sprawdź działanie funkcji dla podanych poniżej parametrów.

Wynikiem funkcji ile_krol(8, 1, 1) jest 3.
Wynikiem funkcji ile_krol(10, 4, 4) jest 8.

#include <iostream>
using namespace std;
int ile_krol(int n, int x, int y){
//zdefiniuj funkcję i sprawdź jej działanie

Z góry dziękuję za pomoc :)

I z czym konkretnie masz problem? Umiesz ten problem rozwiazać na kartce? Król bije wszystkie pola dookoła czyli nie wiecej niż 8 ale nie wychodzi poza szchownicę, więc w rogu bije już tylko 3

@Shalom: nie wiem jak zmodyfikować funkcję z czterema polami planszy aby pasowała do króla.
Dla gońca miałem taką:

return min(x-1, n-y) + min(x-1, y-1) + min(n-x, y-1) + min(n-x, n-y);

@Lukmaster80: Narysuj sobie na kartce szachownicę 3x3 i zdefiniuj jakie warunki musi spełnić król.
Przykład, czy król na pozycji x=0 i y=1, może zbić po swojej lewej na pozycji x=-1, y=1? Jaki warunek jest potrzebny?
Możesz najpierw napisać 8 warunków dla każdej opcji.

Podpowiedź, wieża atakuje zawsze: 2 * 7 pól
Ile pól atakuje goniec?

@MarekR22: król atakuje jedno pole w każdym kierunku. Ja to wszystko wiem, mam też rozrysowane plansze. Przepraszam, ale jestem prawnikiem a nie matematykiem, a chciałbym pomóc córce :)

Najprościej będzie po prostu sprawdzić wszystkie współrzędne gdzie zmieniasz X o +1,0,-1 i analogicznie Y o +1,0,-1 (z wyłączeniem 0,0 bo król nie bije samego siebie) i wystarczy sprawdzić czy któraś ze współrzędnych nie wychodzi poza planszę, czyli czy x+delta >= 0 i x+delta < boardSize i analogicznie dla y

Można też tak:

#include <iostream>

using namespace std;

int ile_krol( int n , int x , int y )
{   
    int result {8}, step {3};   
    if( x==1 || x==n ) result -= step--;
    if( y==1 || y==n ) result -= step;
    return result;   
}

int main()
{
    int size {9};
    for( int i {1} ; i<=size ; ++i )
    {
        for( int j {1} ; j<=size ; ++j )
        {
            cout << ile_krol(size,i,j) << "\t";
        }
        cout << endl;
    }    
}

https://godbolt.org/z/9z1TT519W

Najprościej na pałę : x,y - pozycja króla, n - rozmiar szachownicy; numerowanie pól od zera

pola=0
Dla każdego i od x-1 do x+1 {
  Dla każdego j od y-1 do y+1 {
    jeśli (i == x && j == y) { nie rób nic }
    jeśli (i < 0 || i >= n || j < 0 || j >= n) { nie rób nic }
    w przeciwnym razie pola++
  }
}
zwróć pola;

int KingMovesCoint(int x,int y)
{
	static const int up=~0b00000111;
	static const int lf=~0b00011100;
	static const int dn=~0b01110000;
	static const int rt=~0b11000001;
	int all=0b11111111;
	if(y<=1) all&=up;
	else if(y>=8) all&=dn;
	if(x<=1) all&=lf;
	else if(x>=8) all&=rt;
	int count=0;
	for(;all;++count) all&=all-1;
	return count;
}

Lub najkrótszy z możliwych:

int KingMovesCoint(int x,int y)
{
	static int tb[]={3,5,8};
	return tb[(1<x&&x<8)+(1<y&&y<8)];
}

Lub też dla koneserów:

int KingMovesCoint(int x,int y) { return ((1<x&&x<8)+(1<y&&y<8))["358"]-'0'; }

Tak sobie pomyślałem, jeżeli zapisać to samo nieco inaczej:

int KingMovesCoint(int x,int y)
{
	static int tb[]={3,5,8};
	return tb[min(1,min(x-1,8-x))+min(1,min(y-1,8-y))];
}

To dla skoczka wychodzi prawie tak samo:

int KnightMovesCoint(int x,int y)
{
	static int tb[]={2,3,4,6,8};
	return tb[min(2,min(x-1,8-x))+min(2,min(y-1,8-y))];
}

Ba nawet hetman podbnie:

int QueenMovesCoint(int x,int y)
{
	static int tb[]={21,23,25,27};
	return tb[min(min(x-1,8-x),min(y-1,8-y))];
}

int ile_krol(int n, int x, int y)
{
	static int tb[]={3,5,8};
	return tb[(x%n>1)+(y%n>1)];
}