Number of cells a queen can move with obstacles on the chessboard

Consider a N X N chessboard with a Queen and K obstacles. The Queen cannot pass through obstacles. Given the position (x, y) of Queen, the task is to find the number of cells the queen can move.

Examples: 

Input : N = 8, x = 4, y = 4, 
        K = 0
Output : 27

Input : N = 8, x = 4, y = 4, 
        K = 1, kx1 = 3, ky1 = 5
Output : 24

Method 1:

The idea is to iterate over the cells the queen can attack and stop until there is an obstacle or end of the board. To do that, we need to iterate horizontally, vertically and diagonally. The moves from position (x, y) can be: 

(x+1, y): one step horizontal move to the right. 
(x-1, y): one step horizontal move to the left. 
(x+1, y+1): one step diagonal move up-right. 
(x-1, y-1): one step diagonal move down-left. 
(x-1, y+1): one step diagonal move left-up. 
(x+1, y-1): one step diagonal move right-down. 
(x, y+1): one step downward. 
(x, y-1): one step upward.

Below is C++ implementation of this approach:  

C++

// C++ program to find number of cells a queen can move
// with obstacles on the chessboard
#include<bits/stdc++.h>
using namespace std;

// Return if position is valid on chessboard
int range(int n, int x, int y)
{
  return (x <= n && x > 0 && y <= n && y > 0);
}

// Return the number of moves with a given direction
int check(int n, int x, int y, int xx, int yy,
                  map <pair<int, int>, int> mp)
{
  int ans = 0;

  // Checking valid move of Queen in a direction.
  while (range(n, x, y) && ! mp[{x, y}])
  {
    x += xx;
    y += yy;
    ans++;
  }

  return ans;
}

// Return the number of position a Queen can move.
int numberofPosition(int n, int k, int x, int y,
                  int obstPosx[], int obstPosy[])
{
  int x1, y1, ans = 0;
  map <pair<int, int>, int> mp;

  // Mapping each obstacle's position
  while(k--)
  {
    x1 = obstPosx[k];
    y1 = obstPosy[k];

    mp[{x1, y1}] = 1;
  }

  // Fetching number of position a queen can
  // move in each direction.
  ans += check(n, x + 1, y, 1, 0, mp);
  ans += check(n, x-1, y, -1, 0, mp);
  ans += check(n, x, y + 1, 0, 1, mp);
  ans += check(n, x, y-1, 0, -1, mp);
  ans += check(n, x + 1, y + 1, 1, 1, mp);
  ans += check(n, x + 1, y-1, 1, -1, mp);
  ans += check(n, x-1, y + 1, -1, 1, mp);
  ans += check(n, x-1, y-1, -1, -1, mp);

  return ans;
}

// Driven Program
int main()
{
  int n = 8;  // Chessboard size
  int k = 1;  // Number of obstacles
  int Qposx = 4; // Queen x position
  int Qposy = 4; // Queen y position
  int obstPosx[] = { 3 };  // x position of obstacles
  int obstPosy[] = { 5 };  // y position of obstacles

  cout << numberofPosition(n, k, Qposx, Qposy,
                   obstPosx, obstPosy) << endl;
  return 0;
}

Java

// Java program to find number of cells a queen can move
// with obstacles on the chessboard

import java.util.*;

class GFG{
  static class pair
  {
    int first, second;
    public pair(int first, int second)
    {
      this.first = first;
      this.second = second;
    }
  }
  // Return if position is valid on chessboard
  static boolean range(int n, int x, int y)
  {
    return (x <= n && x > 0 && y <= n && y > 0);
  }

  // Return the number of moves with a given direction
  static int check(int n, int x, int y, int xx, int yy,
                   HashMap <pair, Integer> mp)
  {
    int ans = 0;

    // Checking valid move of Queen in a direction.
    while (range(n, x, y) && ! mp.containsKey(new pair(x, y)))
    {
      x += xx;
      y += yy;
      ans++;
    }

    return ans;
  }

  // Return the number of position a Queen can move.
  static int numberofPosition(int n, int k, int x, int y,
                              int obstPosx[], int obstPosy[])
  {
    int x1, y1, ans = 0;
    HashMap <pair, Integer> mp = new HashMap<>();

    // Mapping each obstacle's position
    while(k>0)
    {
      k--;
      x1 = obstPosx[k];
      y1 = obstPosy[k];

      mp.put(new pair(x1, y1), 1);
    }

    // Fetching number of position a queen can
    // move in each direction.
    ans += check(n, x + 1, y, 1, 0, mp);
    ans += check(n, x-1, y, -1, 0, mp);
    ans += check(n, x, y + 1, 0, 1, mp);
    ans += check(n, x, y-1, 0, -1, mp);
    ans += check(n, x + 1, y + 1, 1, 1, mp);
    ans += check(n, x + 1, y-1, 1, -1, mp);
    ans += check(n, x-1, y + 1, -1, 1, mp);

    return ans;
  }

  // Driven Program
  public static void main(String[] args)
  {
    int n = 8;  // Chessboard size
    int k = 1;  // Number of obstacles
    int Qposx = 4; // Queen x position
    int Qposy = 4; // Queen y position
    int obstPosx[] = { 3 };  // x position of obstacles
    int obstPosy[] = { 5 };  // y position of obstacles

    System.out.print(numberofPosition(n, k, Qposx, Qposy,
                                      obstPosx, obstPosy) +"\n");
  }
}

// This code contributed by Rajput-Ji

Python3

# Python program to find number of cells a queen can move
# with obstacles on the chessboard
class pair :

    def __init__(self, first, second):
        self.first = first
        self.second = second

# Return if position is valid on chessboard
def range(n , x , y):
    return (x <= n and x > 0 and y <= n and y > 0)

# Return the number of moves with a given direction
def check(n , x , y , xx , yy, mp):
    ans = 0

    # Checking valid move of Queen in a direction.
    while range(n, x, y) and pair(x, y) not in mp :
        x += xx
        y += yy
        ans = ans+1

    return ans

# Return the number of position a Queen can move.
def numberofPosition(n , k , x , y , obstPosx , obstPosy):
    ans = 0
    mp = {}

    # Mapping each obstacle's position
    while (k > 0):
        k -= 1
        x1 = obstPosx[k]
        y1 = obstPosy[k]

        mp[pair(x1, y1)] = 1

        # Fetching number of position a queen can
        # move in each direction.
        ans += check(n, x + 1, y, 1, 0, mp)
        ans += check(n, x - 1, y, -1, 0, mp)
        ans += check(n, x, y + 1, 0, 1, mp)
        ans += check(n, x, y - 1, 0, -1, mp)
        ans += check(n, x + 1, y + 1, 1, 1, mp)
        ans += check(n, x + 1, y - 1, 1, -1, mp)
        ans += check(n, x - 1, y + 1, -1, 1, mp)

    return ans

# Driven Program

n = 8 # Chessboard size
k = 1 # Number of obstacles
Qposx = 4 # Queen x position
Qposy = 4 # Queen y position
obstPosx = [ 3 ] # x position of obstacles
obstPosy = [ 5 ] # y position of obstacles

print(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy))

# This code is contributed by shinjanpatra

C#

// C# program to find number of cells a queen can move
// with obstacles on the chessboard
using System;
using System.Collections.Generic;

public class GFG{
 public  class pair
  {
   public  int first, second;
    public pair(int first, int second)
    {
      this.first = first;
      this.second = second;
    }
  }

  // Return if position is valid on chessboard
  static bool range(int n, int x, int y)
  {
    return (x <= n && x > 0 && y <= n && y > 0);
  }

  // Return the number of moves with a given direction
  static int check(int n, int x, int y, int xx, int yy,
                   Dictionary <pair, int> mp)
  {
    int ans = 0;

    // Checking valid move of Queen in a direction.
    while (range(n, x, y) && ! mp.ContainsKey(new pair(x, y)))
    {
      x += xx;
      y += yy;
      ans++;
    }

    return ans;
  }

  // Return the number of position a Queen can move.
  static int numberofPosition(int n, int k, int x, int y,
                              int []obstPosx, int []obstPosy)
  {
    int x1, y1, ans = 0;
    Dictionary <pair, int> mp = new Dictionary<pair, int>();

    // Mapping each obstacle's position
    while(k>0)
    {
      k--;
      x1 = obstPosx[k];
      y1 = obstPosy[k];

      mp.Add(new pair(x1, y1), 1);
    }

    // Fetching number of position a queen can
    // move in each direction.
    ans += check(n, x + 1, y, 1, 0, mp);
    ans += check(n, x-1, y, -1, 0, mp);
    ans += check(n, x, y + 1, 0, 1, mp);
    ans += check(n, x, y-1, 0, -1, mp);
    ans += check(n, x + 1, y + 1, 1, 1, mp);
    ans += check(n, x + 1, y-1, 1, -1, mp);
    ans += check(n, x-1, y + 1, -1, 1, mp);

    return ans;
  }

  // Driven Program
  public static void Main(String[] args)
  {
    int n = 8;  // Chessboard size
    int k = 1;  // Number of obstacles
    int Qposx = 4; // Queen x position
    int Qposy = 4; // Queen y position
    int []obstPosx = { 3 };  // x position of obstacles
    int []obstPosy = { 5 };  // y position of obstacles

    Console.Write(numberofPosition(n, k, Qposx, Qposy,
                                      obstPosx, obstPosy) +"\n");
  }
}

// This code is contributed by Rajput-Ji

Javascript

<script>
// javascript program to find number of cells a queen can move
// with obstacles on the chessboard

     class pair {

         constructor(first , second) {
            this.first = first;
            this.second = second;
        }
    }

    // Return if position is valid on chessboard
    function range(n , x , y) {
        return (x <= n && x > 0 && y <= n && y > 0);
    }

    // Return the number of moves with a given direction
    function check(n , x , y , xx , yy, mp) {
        var ans = 0;

        // Checking valid move of Queen in a direction.
        while (range(n, x, y) && !mp.has(new pair(x, y))) {
            x += xx;
            y += yy;
            ans++;
        }

        return ans;
    }

    // Return the number of position a Queen can move.
    function numberofPosition(n , k , x , y , obstPosx , obstPosy) {
        var x1, y1, ans = 0;
        var mp = new Map();

        // Mapping each obstacle's position
        while (k > 0) {
            k--;
            x1 = obstPosx[k];
            y1 = obstPosy[k];

            mp.set(new pair(x1, y1), 1);
        }

        // Fetching number of position a queen can
        // move in each direction.
        ans += check(n, x + 1, y, 1, 0, mp);
        ans += check(n, x - 1, y, -1, 0, mp);
        ans += check(n, x, y + 1, 0, 1, mp);
        ans += check(n, x, y - 1, 0, -1, mp);
        ans += check(n, x + 1, y + 1, 1, 1, mp);
        ans += check(n, x + 1, y - 1, 1, -1, mp);
        ans += check(n, x - 1, y + 1, -1, 1, mp);

        return ans;
    }

    // Driven Program

        var n = 8; // Chessboard size
        var k = 1; // Number of obstacles
        var Qposx = 4; // Queen x position
        var Qposy = 4; // Queen y position
        var obstPosx = [ 3 ]; // x position of obstacles
        var obstPosy = [ 5 ]; // y position of obstacles

        document.write(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy) + "\n");

// This code is contributed by Rajput-Ji
</script>

Output

24

Time Complexity: O(n²)
Auxiliary Space: O(n)

Method 2:
The idea is to iterate over the obstacles and for those who are in the queen’s path, we calculate the free cells upto that obstacle. If there is no obstacle in the path we have to calculate the number of free cells upto end of board in that direction. 

For any (x₁, y₁) and (x₂, y₂): 

• If they are horizontally at same level: abs(x₁ – x₂ – 1)
• If they are vertically at same level: abs(y₁ – y₂ – 1) is the number of free cells between.
• If they are diagonal: both abs(x₁ – x₂ – 1) or abs(y₁ – y₂ – 1) is the number of free cells between.

Below is the implementation of this approach:  

C++

// C++ program to find number of cells a queen can move
// with obstacles on the chessborad
#include <bits/stdc++.h>
using namespace std;
// Return the number of position a Queen can move.
int numberofPosition(int n, int k, int x, int y,
int obstPosx[], int obstPosy[])
{
// d11, d12, d21, d22 are for diagonal distances.
// r1, r2 are for vertical distance.
// c1, c2 are for horizontal distance.
int d11, d12, d21, d22, r1, r2, c1, c2;
// Initialise the distance to end of the board.
d11 = min( x-1, y-1 );
d12 = min( n-x, n-y );
d21 = min( n-x, y-1 );
d22 = min( x-1, n-y );
r1 = y-1;
r2 = n-y;
c1 = x-1;
c2 = n-x;
// For each obstacle find the minimum distance.
// If obstacle is present in any direction,
// distance will be updated.
for (int i = 0; i < k; i++)
{
if ( x > obstPosx[i] && y > obstPosy[i] &&
x-obstPosx[i] == y-obstPosy[i] )
d11 = min(d11, x-obstPosx[i]-1);
if ( obstPosx[i] > x && obstPosy[i] > y &&
obstPosx[i]-x == obstPosy[i]-y )
d12 = min( d12, obstPosx[i]-x-1);
if ( obstPosx[i] > x && y > obstPosy[i] &&
obstPosx[i]-x == y-obstPosy[i] )
d21 = min(d21, obstPosx[i]-x-1);
if ( x > obstPosx[i] && obstPosy[i] > y &&
x-obstPosx[i] == obstPosy[i]-y )
d22 = min(d22, x-obstPosx[i]-1);
if ( x == obstPosx[i] && obstPosy[i] < y )
r1 = min(r1, y-obstPosy[i]-1);
if ( x == obstPosx[i] && obstPosy[i] > y )
r2 = min(r2, obstPosy[i]-y-1);
if ( y == obstPosy[i] && obstPosx[i] < x )
c1 = min(c1, x-obstPosx[i]-1);
if ( y == obstPosy[i] && obstPosx[i] > x )
c2 = min(c2, obstPosx[i]-x-1);
}
return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
}
// Driver code
int main(void)
{
int n = 8; // Chessboard size
int k = 1; // number of obstacles
int Qposx = 4; // Queen x position
int Qposy = 4; // Queen y position
int obstPosx[] = { 3 }; // x position of obstacles
int obstPosy[] = { 5 }; // y position of obstacles
cout << numberofPosition(n, k, Qposx, Qposy,
obstPosx, obstPosy);
return 0;
}

Java

// Java program to find number of cells a
// queen can move with obstacles on the
// chessborad
import java.io.*;
class GFG {
// Return the number of position a Queen
// can move.
static int numberofPosition(int n, int k, int x,
int y, int obstPosx[], int obstPosy[])
{

// d11, d12, d21, d22 are for diagonal distances.
// r1, r2 are for vertical distance.
// c1, c2 are for horizontal distance.
int d11, d12, d21, d22, r1, r2, c1, c2;

// Initialise the distance to end of the board.
d11 = Math.min( x-1, y-1 );
d12 = Math.min( n-x, n-y );
d21 = Math.min( n-x, y-1 );
d22 = Math.min( x-1, n-y );

r1 = y-1;
r2 = n-y;
c1 = x-1;
c2 = n-x;

// For each obstacle find the minimum distance.
// If obstacle is present in any direction,
// distance will be updated.
for (int i = 0; i < k; i++)
{
if ( x > obstPosx[i] && y > obstPosy[i] &&
x-obstPosx[i] == y-obstPosy[i] )
d11 = Math.min(d11, x-obstPosx[i]-1);

if ( obstPosx[i] > x && obstPosy[i] > y &&
obstPosx[i]-x == obstPosy[i]-y )
d12 = Math.min( d12, obstPosx[i]-x-1);

if ( obstPosx[i] > x && y > obstPosy[i] &&
obstPosx[i]-x == y-obstPosy[i] )
d21 = Math.min(d21, obstPosx[i]-x-1);

if ( x > obstPosx[i] && obstPosy[i] > y &&
x-obstPosx[i] == obstPosy[i]-y )
d22 = Math.min(d22, x-obstPosx[i]-1);

if ( x == obstPosx[i] && obstPosy[i] < y )
r1 = Math.min(r1, y-obstPosy[i]-1);

if ( x == obstPosx[i] && obstPosy[i] > y )
r2 = Math.min(r2, obstPosy[i]-y-1);

if ( y == obstPosy[i] && obstPosx[i] < x )
c1 = Math.min(c1, x-obstPosx[i]-1);

if ( y == obstPosy[i] && obstPosx[i] > x )
c2 = Math.min(c2, obstPosx[i]-x-1);
}

return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
}

// Driver code
public static void main (String[] args) {
int n = 8; // Chessboard size
int k = 1; // number of obstacles
int Qposx = 4; // Queen x position
int Qposy = 4; // Queen y position
int obstPosx[] = { 3 }; // x position of obstacles
int obstPosy[] = { 5 }; // y position of obstacles
System.out.println(numberofPosition(n, k, Qposx,
Qposy, obstPosx, obstPosy));
}
}
// This code is contributed by anuj_67.

Python3

# Python program to find number of cells a
# queen can move with obstacles on the
# chessborad
# Return the number of position a Queen
# can move.
def numberofPosition(n, k, x, y, obstPosx, obstPosy):
# d11, d12, d21, d22 are for diagonal distances.
# r1, r2 are for vertical distance.
# c1, c2 are for horizontal distance.
# Initialise the distance to end of the board.
d11 = min(x - 1, y - 1);
d12 = min(n - x, n - y);
d21 = min(n - x, y - 1);
d22 = min(x - 1, n - y);
r1 = y - 1;
r2 = n - y;
c1 = x - 1;
c2 = n - x;
# For each obstacle find the minimum distance.
# If obstacle is present in any direction,
# distance will be updated.
for i in range(k):
if (x > obstPosx[i] and y > obstPosy[i] and x - obstPosx[i] == y - obstPosy[i]):
d11 = min(d11, x - obstPosx[i] - 1);
if (obstPosx[i] > x and obstPosy[i] > y and obstPosx[i] - x == obstPosy[i] - y):
d12 = min(d12, obstPosx[i] - x - 1);
if (obstPosx[i] > x and y > obstPosy[i] and obstPosx[i] - x == y - obstPosy[i]):
d21 = min(d21, obstPosx[i] - x - 1);
if (x > obstPosx[i] and obstPosy[i] > y and x - obstPosx[i] == obstPosy[i] - y):
d22 = min(d22, x - obstPosx[i] - 1);
if (x == obstPosx[i] and obstPosy[i] < y):
r1 = min(r1, y - obstPosy[i] - 1);
if (x == obstPosx[i] and obstPosy[i] > y):
r2 = min(r2, obstPosy[i] - y - 1);
if (y == obstPosy[i] and obstPosx[i] < x):
c1 = min(c1, x - obstPosx[i] - 1);
if (y == obstPosy[i] and obstPosx[i] > x):
c2 = min(c2, obstPosx[i] - x - 1);

return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
# Driver code
if __name__ == '__main__':
n = 8; # Chessboard size
k = 1; # number of obstacles
Qposx = 4; # Queen x position
Qposy = 4; # Queen y position
obstPosx = [ 3] ; # x position of obstacles
obstPosy = [ 5 ]; # y position of obstacles
print(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy));
# This code is contributed by Rajput-Ji

C#

// C# program to find number of cells a
// queen can move with obstacles on the
// chessborad
using System;
class GFG {
// Return the number of position a Queen
// can move.
static int numberofPosition(int n, int k, int x,
int y, int []obstPosx, int []obstPosy)
{

// d11, d12, d21, d22 are for diagonal distances.
// r1, r2 are for vertical distance.
// c1, c2 are for horizontal distance.
int d11, d12, d21, d22, r1, r2, c1, c2;

// Initialise the distance to end of the board.
d11 = Math.Min( x-1, y-1 );
d12 = Math.Min( n-x, n-y );
d21 = Math.Min( n-x, y-1 );
d22 = Math.Min( x-1, n-y );

r1 = y-1;
r2 = n-y;
c1 = x-1;
c2 = n-x;

// For each obstacle find the Minimum distance.
// If obstacle is present in any direction,
// distance will be updated.
for (int i = 0; i < k; i++)
{
if ( x > obstPosx[i] && y > obstPosy[i] &&
x-obstPosx[i] == y-obstPosy[i] )
d11 = Math.Min(d11, x-obstPosx[i]-1);

if ( obstPosx[i] > x && obstPosy[i] > y &&
obstPosx[i]-x == obstPosy[i]-y )
d12 = Math.Min( d12, obstPosx[i]-x-1);

if ( obstPosx[i] > x && y > obstPosy[i] &&
obstPosx[i]-x == y-obstPosy[i] )
d21 = Math.Min(d21, obstPosx[i]-x-1);

if ( x > obstPosx[i] && obstPosy[i] > y &&
x-obstPosx[i] == obstPosy[i]-y)
d22 = Math.Min(d22, x-obstPosx[i]-1);

if ( x == obstPosx[i] && obstPosy[i] < y )
r1 = Math.Min(r1, y-obstPosy[i]-1);

if ( x == obstPosx[i] && obstPosy[i] > y )
r2 = Math.Min(r2, obstPosy[i]-y-1);

if ( y == obstPosy[i] && obstPosx[i] < x )
c1 = Math.Min(c1, x-obstPosx[i]-1);

if ( y == obstPosy[i] && obstPosx[i] > x )
c2 = Math.Min(c2, obstPosx[i]-x-1);
}

return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
}

// Driver code
public static void Main ()
{
int n = 8; // Chessboard size
int k = 1; // number of obstacles
int Qposx = 4; // Queen x position
int Qposy = 4; // Queen y position
int []obstPosx = { 3 }; // x position of obstacles
int []obstPosy = { 5 }; // y position of obstacles

Console.WriteLine(numberofPosition(n, k, Qposx,
Qposy, obstPosx, obstPosy));
}
}
// This code is contributed by anuj_67.

PHP

<?php
//PHP program to find number of cells a queen can move
// with obstacles on the chessborad
// Return the number of position a Queen can move.
function numberofPosition($n, $k, $x, $y,
$obstPosx, $obstPosy)
{
// d11, d12, d21, d22 are for diagonal distances.
// r1, r2 are for vertical distance.
// c1, c2 are for horizontal distance.
$d11;
$d12;
$d21;
$d22;
$r1;
$r2;
$c1;
$c2;
// Initialise the distance to end of the board.
$d11 = min( $x-1, $y-1 );
$d12 = min( $n-$x, $n-$y );
$d21 = min( $n-$x, $y-1 );
$d22 = min( $x-1, $n-$y );
$r1 = $y-1;
$r2 = $n-$y;
$c1 = $x-1;
$c2 = $n-$x;
// For each obstacle find the minimum distance.
// If obstacle is present in any direction,
// distance will be updated.
for ($i = 0; $i < $k; $i++)
{
if ( $x > $obstPosx[$i] && $y > $obstPosy[$i] &&
$x-$obstPosx[$i] == $y-$obstPosy[$i] )
$d11 = min($d11, $x-$obstPosx[$i]-1);
if ( $obstPosx[$i] > $x && $obstPosy[$i] > $y &&
$obstPosx[$i]-$x == $obstPosy[$i]-$y )
$d12 = min( $d12, $obstPosx[$i]-$x-1);
if ( $obstPosx[$i] > $x && $y > $obstPosy[$i] &&
$obstPosx[$i]-$x == $y-$obstPosy[$i] )
$d21 = min($d21, $obstPosx[$i]-$x-1);
if ( $x > $obstPosx[$i] && $obstPosy[$i] > $y &&
$x-$obstPosx[$i] == $obstPosy[$i]-$y )
$d22 = min($d22, $x-$obstPosx[$i]-1);
if ( $x == $obstPosx[$i] && $obstPosy[$i] < $y )
$r1 = min($r1, $y-$obstPosy[$i]-1);
if ( $x == $obstPosx[$i] && $obstPosy[$i] > $y )
$r2 = min($r2, $obstPosy[$i]-$y-1);
if ( $y == $obstPosy[$i] && $obstPosx[$i] < $x )
$c1 = min($c1, $x-$obstPosx[$i]-1);
if ( $y == $obstPosy[$i] && $obstPosx[$i] > $x )
$c2 = min($c2, $obstPosx[$i]-$x-1);
}
return $d11 + $d12 + $d21 + $d22 + $r1 + $r2 + $c1 + $c2;
}
// Driver code
$n = 8; // Chessboard size
$k = 1; // number of obstacles
$Qposx = 4; // Queen x position
$Qposy = 4; // Queen y position
$obstPosx = array(3 ); // x position of obstacles
$obstPosy = array(5 ); // y position of obstacles
echo numberofPosition($n, $k, $Qposx, $Qposy,
$obstPosx, $obstPosy);
// This code is contributed by ajit.
?>

Javascript

<script>
// Javascript program to find number of cells a queen
// can move with obstacles on the chessborad
// Return the number of position a Queen can move.
function numberofPosition( n, k, x, y,
obstPosx, obstPosy)
{
// d11, d12, d21, d22 are for diagonal distances.
// r1, r2 are for vertical distance.
// c1, c2 are for horizontal distance.
let d11, d12, d21, d22, r1, r2, c1, c2;
// Initialise the distance to end of the board.
d11 = Math.min( x-1, y-1 );
d12 = Math.min( n-x, n-y );
d21 = Math.min( n-x, y-1 );
d22 = Math.min( x-1, n-y );
r1 = y-1;
r2 = n-y;
c1 = x-1;
c2 = n-x;
// For each obstacle find the minimum distance.
// If obstacle is present in any direction,
// distance will be updated.
for (let i = 0; i < k; i++)
{
if ( x > obstPosx[i] && y > obstPosy[i] &&
x-obstPosx[i] == y-obstPosy[i] )
d11 = Math.min(d11, x-obstPosx[i]-1);
if ( obstPosx[i] > x && obstPosy[i] > y &&
obstPosx[i]-x == obstPosy[i]-y )
d12 = Math.min( d12, obstPosx[i]-x-1);
if ( obstPosx[i] > x && y > obstPosy[i] &&
obstPosx[i]-x == y-obstPosy[i] )
d21 = Math.min(d21, obstPosx[i]-x-1);
if ( x > obstPosx[i] && obstPosy[i] > y &&
x-obstPosx[i] == obstPosy[i]-y )
d22 = Math.min(d22, x-obstPosx[i]-1);
if ( x == obstPosx[i] && obstPosy[i] < y )
r1 = min(r1, y-obstPosy[i]-1);
if ( x == obstPosx[i] && obstPosy[i] > y )
r2 = Math.min(r2, obstPosy[i]-y-1);
if ( y == obstPosy[i] && obstPosx[i] < x )
c1 = Math.min(c1, x-obstPosx[i]-1);
if ( y == obstPosy[i] && obstPosx[i] > x )
c2 = Math.min(c2, obstPosx[i]-x-1);
}
return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
}
// Driver Code
let n = 8; // Chessboard size
let k = 1; // number of obstacles
let Qposx = 4; // Queen x position
let Qposy = 4; // Queen y position
let obstPosx = [ 3 ]; // x position of obstacles
let obstPosy = [ 5 ]; // y position of obstacles
document.write(numberofPosition(n, k, Qposx, Qposy,
obstPosx, obstPosy));
</script>

Time Complexity: O(n)
Auxiliary Space: O(1)

This article is contributed by Aarti Rathi and Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.