Count number of coordinates from an array satisfying the given conditions

Given an array arr[] consisting of N coordinates in the Cartesian Plane, the task is to find the number of coordinates, such as (X, Y), that satisfies all the following conditions:

1. All possible arr[i][0] must be less than X and arr[i][1] must be equal to Y.
2. All possible arr[i][0] must be greater than X and arr[i][1] must be equal to Y.
3. All possible arr[i][0] must be less than Y and arr[i][1] must be equal to X.
4. All possible arr[i][0] must be greater than Y and arr[i][1] must be equal to X.

Examples:

Input: arr[][] = {{0, 0}, {0, 1}, {1, 0}, {0, -1}, {-1, 0}}
Output: 1
Explanation: There exists only one coordinate that satisfy the given condition, i.e. (0, 0), based on the following conditions:

1. arr[2] = {1, 0}: Since arr[2][0](= 1) > X(= 0) and arr[2][1](= 0) == Y(= 0), condition 1 is satisfied.
2. arr[4] = {-1, 0}: Since arr[4][0](= -1) < 0 and arr[4][1](= 0) == Y(= 0), condition 2 is satisfied.
3. arr[1] = {0, 1}: Since arr[1][0](= 0) == X(= 0) and arr[1][1](= 1) > Y(= 0), condition 3 is satisfied.
4. arr[3] = {0, -1}: Since arr[3][0](= 0) == X(= 0) and arr[3][1](= -1) < Y(= 0), condition 4 is satisfied.

Therefore, the total number of points is 1.

Input: arr[][] = {{1, 0}, {2, 0}, {1, 1}, {1, -1}}
Output: 0

Approach: The given problem can be solved by considering every coordinate, say (arr[i][0], arr[i][1]) as the resultant coordinates, and if the coordinate (arr[i][0], arr[i][1]) satisfies all the given conditions, then count the current coordinates. After checking for all the coordinates, print the value of the total count obtained.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to count the number of
// coordinates from a given set
// that satisfies the given conditions
int centralPoints(int arr[][2], int N)
{
    // Stores the count of central points
    int count = 0;

    // Store the count of
    // each x and y coordinates
    int c1, c2, c3, c4;

    // Find all possible pairs
    for (int i = 0; i < N; i++) {

        // Initialize variables c1, c2,
        // c3, c4 to define the status
        // of conditions
        c1 = 0, c2 = 0, c3 = 0;
        c4 = 0;

        // Stores value of each point
        int x = arr[i][0];
        int y = arr[i][1];

        // Check the conditions for
        // each point by generating
        // all possible pairs
        for (int j = 0; j < N; j++) {

            // If arr[j][0] > x and
            // arr[j][1] == y
            if (arr[j][0] > x
                && arr[j][1] == y) {
                c1 = 1;
            }

            // If arr[j][0] < x and
            // arr[j][1] == y
            if (arr[j][1] > y
                && arr[j][0] == x) {
                c2 = 1;
            }

            // If arr[j][1] > y and
            // arr[j][0] == x
            if (arr[j][0] < x
                && arr[j][1] == y) {
                c3 = 1;
            }

            // If arr[j][1] < y and
            // arr[j][0] == x
            if (arr[j][1] < y
                && arr[j][0] == x) {
                c4 = 1;
            }
        }

        // If all conditions satisfy
        // then point is central point
        if (c1 + c2 + c3 + c4 == 4) {

            // Increment the count by 1
            count++;
        }
    }

    // Return the count
    return count;
}

// Driver Code
int main()
{
    int arr[4][2] = { { 1, 0 }, { 2, 0 },
                      { 1, 1 }, { 1, -1 } };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << centralPoints(arr, N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

public class GFG {

    // Function to count the number of
    // coordinates from a given set
    // that satisfies the given conditions
    static int centralPoints(int arr[][], int N)
    {

        // Stores the count of central points
        int count = 0;

        // Store the count of
        // each x and y coordinates
        int c1, c2, c3, c4;

        // Find all possible pairs
        for (int i = 0; i < N; i++) {

            // Initialize variables c1, c2,
            // c3, c4 to define the status
            // of conditions
            c1 = 0;
            c2 = 0;
            c3 = 0;
            c4 = 0;

            // Stores value of each point
            int x = arr[i][0];
            int y = arr[i][1];

            // Check the conditions for
            // each point by generating
            // all possible pairs
            for (int j = 0; j < N; j++) {

                // If arr[j][0] > x and
                // arr[j][1] == y
                if (arr[j][0] > x && arr[j][1] == y) {
                    c1 = 1;
                }

                // If arr[j][0] < x and
                // arr[j][1] == y
                if (arr[j][1] > y && arr[j][0] == x) {
                    c2 = 1;
                }

                // If arr[j][1] > y and
                // arr[j][0] == x
                if (arr[j][0] < x && arr[j][1] == y) {
                    c3 = 1;
                }

                // If arr[j][1] < y and
                // arr[j][0] == x
                if (arr[j][1] < y && arr[j][0] == x) {
                    c4 = 1;
                }
            }

            // If all conditions satisfy
            // then point is central point
            if (c1 + c2 + c3 + c4 == 4) {

                // Increment the count by 1
                count++;
            }
        }

        // Return the count
        return count;
    }

    // Driver Code
    public static void main(String[] args)
    {

        int arr[][]
            = { { 1, 0 }, { 2, 0 }, { 1, 1 }, { 1, -1 } };
        int N = arr.length;
        System.out.println(centralPoints(arr, N));
    }
}

// This code is contributed by Kingash.

Python3

# Python3 program for the above approach

# Function to count the number of
# coordinates from a given set
# that satisfies the given conditions
def centralPoints(arr, N):

    # Stores the count of central points
    count = 0

    # Find all possible pairs
    for i in range(N):

        # Initialize variables c1, c2,
        # c3, c4 to define the status
        # of conditions
        c1 = 0
        c2 = 0
        c3 = 0
        c4 = 0

        # Stores value of each point
        x = arr[i][0]
        y = arr[i][1]

        # Check the conditions for
        # each point by generating
        # all possible pairs
        for j in range(N):

            # If arr[j][0] > x and
            # arr[j][1] == y
            if (arr[j][0] > x and arr[j][1] == y):
                c1 = 1

            # If arr[j][0] < x and
            # arr[j][1] == y
            if (arr[j][1] > y and arr[j][0] == x):
                c2 = 1

            # If arr[j][1] > y and
            # arr[j][0] == x
            if (arr[j][0] < x and arr[j][1] == y):
                c3 = 1

            # If arr[j][1] < y and
            # arr[j][0] == x
            if (arr[j][1] < y and arr[j][0] == x):
                c4 = 1

        # If all conditions satisfy
        # then point is central point
        if (c1 + c2 + c3 + c4 == 4):

            # Increment the count by 1
            count += 1

    # Return the count
    return count

# Driver Code
if __name__ == '__main__':

    arr = [ [ 1, 0 ], [ 2, 0 ],
            [ 1, 1 ], [ 1, -1 ] ]
    N = len(arr)

    print(centralPoints(arr, N));

# This code is contributed by SURENDRA_GANGWAR

C#

// C# program for the above approach
using System;

class GFG{

// Function to count the number of
// coordinates from a given set
// that satisfies the given conditions
static int centralPoints(int[,] arr, int N)
{

    // Stores the count of central points
    int count = 0;

    // Store the count of
    // each x and y coordinates
    int c1, c2, c3, c4;

    // Find all possible pairs
    for(int i = 0; i < N; i++)
    {

        // Initialize variables c1, c2,
        // c3, c4 to define the status
        // of conditions
        c1 = 0;
        c2 = 0;
        c3 = 0;
        c4 = 0;

        // Stores value of each point
        int x = arr[i, 0];
        int y = arr[i, 1];

        // Check the conditions for
        // each point by generating
        // all possible pairs
        for(int j = 0; j < N; j++)
        {

            // If arr[j][0] > x and
            // arr[j][1] == y
            if (arr[j, 0] > x && arr[j, 1] == y)
            {
                c1 = 1;
            }

            // If arr[j][0] < x and
            // arr[j][1] == y
            if (arr[j, 1] > y && arr[j, 0] == x)
            {
                c2 = 1;
            }

            // If arr[j][1] > y and
            // arr[j][0] == x
            if (arr[j, 0] < x && arr[j, 1] == y)
            {
                c3 = 1;
            }

            // If arr[j][1] < y and
            // arr[j][0] == x
            if (arr[j, 1] < y && arr[j, 0] == x)
            {
                c4 = 1;
            }
        }

        // If all conditions satisfy
        // then point is central point
        if (c1 + c2 + c3 + c4 == 4)
        {

            // Increment the count by 1
            count++;
        }
    }

    // Return the count
    return count;
}

// Driver Code
public static void Main(string[] args)
{
    int[,] arr = { { 1, 0 }, { 2, 0 },
                   { 1, 1 }, { 1, -1 } };
    int N = arr.GetLength(0);

    Console.WriteLine(centralPoints(arr, N));
}
}

// This code is contributed by ukasp

Javascript

<script>

// Javascript program to implement the
// above approach

    // Function to count the number of
    // coordinates from a given set
    // that satisfies the given conditions
    function centralPoints(arr, N)
    {

        // Stores the count of central points
        let count = 0;

        // Store the count of
        // each x and y coordinates
        let c1, c2, c3, c4;

        // Find all possible pairs
        for (let i = 0; i < N; i++) {

            // Initialize variables c1, c2,
            // c3, c4 to define the status
            // of conditions
            c1 = 0;
            c2 = 0;
            c3 = 0;
            c4 = 0;

            // Stores value of each point
            let x = arr[i][0];
            let y = arr[i][1];

            // Check the conditions for
            // each point by generating
            // all possible pairs
            for (let j = 0; j < N; j++) {

                // If arr[j][0] > x and
                // arr[j][1] == y
                if (arr[j][0] > x && arr[j][1] == y) {
                    c1 = 1;
                }

                // If arr[j][0] < x and
                // arr[j][1] == y
                if (arr[j][1] > y && arr[j][0] == x) {
                    c2 = 1;
                }

                // If arr[j][1] > y and
                // arr[j][0] == x
                if (arr[j][0] < x && arr[j][1] == y) {
                    c3 = 1;
                }

                // If arr[j][1] < y and
                // arr[j][0] == x
                if (arr[j][1] < y && arr[j][0] == x) {
                    c4 = 1;
                }
            }

            // If all conditions satisfy
            // then point is central point
            if (c1 + c2 + c3 + c4 == 4) {

                // Increment the count by 1
                count++;
            }
        }

        // Return the count
        return count;
    }

// Driver Code
    let arr = [[ 1, 0 ], [ 2, 0 ], [ 1, 1 ], [ 1, -1 ]];
    let N = arr.length;
   document.write(centralPoints(arr, N));

 // This code is contributed by splevel62.
</script>

Output:

0

Time Complexity: O(N²)
Auxiliary Space: O(1),  since no extra space has been taken.