GFG App
Open App
Browser
Continue

# Check if empty spaces of Array can be filled maintaining given relations of adjacent

Given two arrays, array A[] of size N and array B[] of size N-1, array A has all the positive elements and -1 for the empty values and array B has 3 characters {‘>’, ‘=’, ‘<‘} which indicates the following:

1. >‘ means A[i] > A[i+1]
2. =‘ means A[i] = A[i+1]
3. <‘ means A[i] < A[i+1]

The task is to find if we can fill -1(empty values) of A with some positive values that also satisfy the relations between the adjacents mentioned in array B.

Examples:

Input: N = 6, A = {8, 6, -1, -1, -1, 11}, B = {‘>’, ‘>’, ‘=’, ‘<‘, ‘>’}
Output: Yes
Explanation: Consider, A becomes {8, 6, 5, 5, 12, 11},
It satisfies B, so the answer will be ‘Yes’.

Input: N = 5, A = {4, 1, -1, -1, 7}, B = {‘<‘, ‘<‘, ‘<‘, ‘<‘}
Output: No

Approach: The problem can be solved based on the following mathematical idea:

Use range to compare whether we can have a valid solution for a particular index and change the range accordingly.

Initially, the left range is 0 and the right range is INT_MAX.

• If ‘<‘ operator is encountered, then the valid range for A[i+1] is left = A[i]+1 and right = INT_MAX.
• If ‘>’ operator is encountered, then the valid range for A[i+1] is left = 0 and right = A[i] – 1.
• If ‘=’ operator is encountered, then the valid range for A[i+1] is left = A[i] and right = A[i]
• Values of ranges are changed when A[i] is given, but when A[i] = -1 ranges are compared and changed according to the above-mentioned conditions
• If left ≤ right and left ≥ 0 and right ≥ 0 is satisfied for each index position, then ‘Yes’ is returned, otherwise ‘No’ is returned.

Below is the implementation of the above approach.

## C++

```// C++ code for this approach
#include <bits/stdc++.h>
using namespace std;

// Function to check whether array A
// can be made such that all operator
// of array B holds true for each index i
string checkComparisons(int N, vector<int> A,
vector<char> B)
{
// Declaring initial ranges as 0 to Infinity
int left = 0, right = INT_MAX, index = 0;
bool valid = 1;
for (int i = 0; i < N - 1; i++, index++) {

// If current element is not empty
if (A[i] != -1) {

// Compare normal elements
// (non empty i.e. != -1) based on B
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (A[i] <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if (A[i] != A[i + 1])
return "No";
}
if (B[index] == '<') {
if (A[i] >= A[i + 1])
return "No";
}
}

// Compare and update ranges
// for empty spaces
else {
if (B[index] == '>') {
left = 0;
right = A[i] - 1;
}
if (B[index] == '=') {
left = A[i];
right = A[i];
}
if (B[index] == '<') {
left = A[i] + 1;
right = INT_MAX;
}
}
}

// If current element is empty
else {

// Compare and update ranges if
// next element is not empty
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (right <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if ((left > A[i + 1])
|| (right < A[i + 1]))
return "No";
}
if (B[index] == '<') {
if (left >= A[i + 1])
return "No";
}
}

// Compare and update ranges if
// next element is empty based on
// previous ranges
else {
if (B[index] == '>') {
left = 0;
right--;
}
if (B[index] == '<') {
left++;
right = INT_MAX;
}
}
}
if (left > right)
return "No";
if (right < 0)
return "No";
if (left < 0)
return "No";
}
return "Yes";
}

// Driver Code
int main()
{
int N = 6;
vector<int> A{ 8, 6, -1, -1, -1, 11 };
vector<char> B{ '>', '>', '=', '<', '>' };

// Function call
cout << checkComparisons(N, A, B);
return 0;
}```

## Java

```// Java code for this approach
import java.io.*;

class GFG {
// Function to check whether array A
// can be made such that all operator
// of array B holds true for each index i
public static String checkComparisons(int N, int A[],
char B[])
{
// Declaring initial ranges as 0 to Infinity
int left = 0, right = Integer.MAX_VALUE, index = 0;
boolean valid = true;
for (int i = 0; i < N - 1; i++, index++) {

// If current element is not empty
if (A[i] != -1) {

// Compare normal elements
// (non empty i.e. != -1) based on B
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (A[i] <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if (A[i] != A[i + 1])
return "No";
}
if (B[index] == '<') {
if (A[i] >= A[i + 1])
return "No";
}
}

// Compare and update ranges
// for empty spaces
else {
if (B[index] == '>') {
left = 0;
right = A[i] - 1;
}
if (B[index] == '=') {
left = A[i];
right = A[i];
}
if (B[index] == '<') {
left = A[i] + 1;
right = Integer.MAX_VALUE;
}
}
}

// If current element is empty
else {

// Compare and update ranges if
// next element is not empty
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (right <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if ((left > A[i + 1])
|| (right < A[i + 1]))
return "No";
}
if (B[index] == '<') {
if (left >= A[i + 1])
return "No";
}
}

// Compare and update ranges if
// next element is empty based on
// previous ranges
else {
if (B[index] == '>') {
left = 0;
right--;
}
if (B[index] == '<') {
left++;
right = Integer.MAX_VALUE;
}
}
}
if (left > right)
return "No";
if (right < 0)
return "No";
if (left < 0)
return "No";
}
return "Yes";
}

// Driver Code
public static void main(String[] args)
{
int N = 6;
int A[] = { 8, 6, -1, -1, -1, 11 };
char B[] = { '>', '>', '=', '<', '>' };

// Function call
System.out.print(checkComparisons(N, A, B));
}
}

// This code is contributed by Rohit Pradhan```

## Python3

```# Python code for this approach
# Function to check whether array A
# can be made such that all operator
# of array B holds true for each index i
import sys
def checkComparisons(N, A, B):

# Declaring initial ranges as 0 to Infinity
left = 0
right = -sys.maxsize-1
index = 0;
valid = 1;
for i in range (N-1):
i = i + 1
index = index + 1

# If current element is not empty
if (A[i] != -1):

# Compare normal elements
# (non empty i.e. != -1) based on B
if (A[i + 1] != -1):
if (B[index] == '>'):
if (A[i] <= A[i + 1]):
return "No"
if (B[index] == '='):
if (A[i] != A[i + 1]):
return "No"
if (B[index] == '<'):
if (A[i] >= A[i + 1]):
return "No"

# Compare and update ranges
# for empty spaces
else:
if (B[index] == '>'):
left = 0
right = A[i] - 1
if (B[index] == '='):
left = A[i]
right = A[i]
if (B[index] == '<'):
left = A[i] + 1
right = -sys.maxsize - 1

# If current element is empty
else:

# Compare and update ranges if
# next element is not empty
if (A[i + 1] != -1):
if (B[index] == '>'):
if (right <= A[i + 1]):
return "No"
if (B[index] == '='):
if ((left > A[i + 1]) or (right < A[i + 1])):
return "No"
if (B[index] == '<'):
if (left >= A[i + 1]):
return "No"
# Compare and update ranges if
# next element is empty based on
# previous ranges
else:
if (B[index] == '>'):
left = 0
right=right-1
if (B[index] == '<'):
left=left+1
right = -sys.maxsize-1
if (left > right):
return "No"
if (right < 0):
return "No"
if (left < 0):
return "No"
return "Yes"

# Driver Code
N = 6
A = [8, 6, -1, -1, -1, 11]
B = [ '>', '>', '=', '<', '>' ]

# Function call
print(checkComparisons(N, A, B))

# This code is contributed by Atul_kumar_Shrivastava```

## C#

```// C# implementation of above approach
using System;
using System.Collections.Generic;

class GFG {

// Function to check whether array A
// can be made such that all operator
// of array B holds true for each index i
public static String checkComparisons(int N, int[] A,
char[] B)
{
// Declaring initial ranges as 0 to Infinity
int left = 0, right = Int32.MaxValue, index = 0;
bool valid = true;
for (int i = 0; i < N - 1; i++, index++) {

// If current element is not empty
if (A[i] != -1) {

// Compare normal elements
// (non empty i.e. != -1) based on B
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (A[i] <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if (A[i] != A[i + 1])
return "No";
}
if (B[index] == '<') {
if (A[i] >= A[i + 1])
return "No";
}
}

// Compare and update ranges
// for empty spaces
else {
if (B[index] == '>') {
left = 0;
right = A[i] - 1;
}
if (B[index] == '=') {
left = A[i];
right = A[i];
}
if (B[index] == '<') {
left = A[i] + 1;
right = Int32.MaxValue;
}
}
}

// If current element is empty
else {

// Compare and update ranges if
// next element is not empty
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (right <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if ((left > A[i + 1])
|| (right < A[i + 1]))
return "No";
}
if (B[index] == '<') {
if (left >= A[i + 1])
return "No";
}
}

// Compare and update ranges if
// next element is empty based on
// previous ranges
else {
if (B[index] == '>') {
left = 0;
right--;
}
if (B[index] == '<') {
left++;
right = Int32.MaxValue;
}
}
}
if (left > right)
return "No";
if (right < 0)
return "No";
if (left < 0)
return "No";
}
return "Yes";
}

// Driver Code
public static void Main()
{
int N = 6;
int[] A = { 8, 6, -1, -1, -1, 11 };
char[] B = { '>', '>', '=', '<', '>' };

// Function call
Console.WriteLine(checkComparisons(N, A, B));
}
}

// This code is contributed by sanjoy_62.```

## Javascript

```    <script>
// JavaScript code for this approach

const INT_MAX = 2147483647;
// Function to check whether array A
// can be made such that all operator
// of array B holds true for each index i
const checkComparisons = (N, A, B) => {
// Declaring initial ranges as 0 to Infinity
let left = 0, right = INT_MAX, index = 0;
let valid = 1;
for (let i = 0; i < N - 1; i++, index++) {

// If current element is not empty
if (A[i] != -1) {

// Compare normal elements
// (non empty i.e. != -1) based on B
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (A[i] <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if (A[i] != A[i + 1])
return "No";
}
if (B[index] == '<') {
if (A[i] >= A[i + 1])
return "No";
}
}

// Compare and update ranges
// for empty spaces
else {
if (B[index] == '>') {
left = 0;
right = A[i] - 1;
}
if (B[index] == '=') {
left = A[i];
right = A[i];
}
if (B[index] == '<') {
left = A[i] + 1;
right = INT_MAX;
}
}
}

// If current element is empty
else {

// Compare and update ranges if
// next element is not empty
if (A[i + 1] != -1) {
if (B[index] == '>') {
if (right <= A[i + 1])
return "No";
}
if (B[index] == '=') {
if ((left > A[i + 1])
|| (right < A[i + 1]))
return "No";
}
if (B[index] == '<') {
if (left >= A[i + 1])
return "No";
}
}

// Compare and update ranges if
// next element is empty based on
// previous ranges
else {
if (B[index] == '>') {
left = 0;
right--;
}
if (B[index] == '<') {
left++;
right = INT_MAX;
}
}
}
if (left > right)
return "No";
if (right < 0)
return "No";
if (left < 0)
return "No";
}
return "Yes";
}

// Driver Code

let N = 6;
let A = [8, 6, -1, -1, -1, 11];
let B = ['>', '>', '=', '<', '>'];

// Function call
document.write(checkComparisons(N, A, B));

// This code is contributed by rakeshsahni

</script>```
Output

`Yes`

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

My Personal Notes arrow_drop_up