Queries to answer the number of ones and zero to the left of given index
Last Updated :
21 Jun, 2022
Given a binary array and Q queries. Every query consists of a number K, the task is to print the number of ones and zeros to the left of the index K.
Examples:
Input: arr[] = {1, 1, 1, 0, 0, 1, 0, 1, 1}, Q[] = {0, 1, 2, 4}
Output:
0 ones 0 zeros
1 ones 0 zeros
2 ones 0 zeros
3 ones 1 zeros
Input: arr[] = {1, 0, 1, 0, 1, 1}, Q[] = {2, 3}
Output:
1 ones 1 zeros
2 ones 1 zeros
Approach: The following steps can be followed to solve the above problem:
- Declare an array of pairs(say left[]) which will be used to pre-calculate the number of ones and zeros to the left.
- Iterate on the array and in every step initialize left[i] with the number of ones and zeros to the left.
- The number of ones for every query will be left[k].first and number of zeros will be left[k].second
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void preCalculate( int binary[], int n, pair< int , int > left[])
{
int count1 = 0, count0 = 0;
for ( int i = 0; i < n; i++) {
left[i].first = count1;
left[i].second = count0;
if (binary[i])
count1++;
else
count0++;
}
}
int main()
{
int binary[] = { 1, 1, 1, 0, 0, 1, 0, 1, 1 };
int n = sizeof (binary) / sizeof (binary[0]);
pair< int , int > left[n];
preCalculate(binary, n, left);
int queries[] = { 0, 1, 2, 4 };
int q = sizeof (queries) / sizeof (queries[0]);
for ( int i = 0; i < q; i++)
cout << left[queries[i]].first << " ones "
<< left[queries[i]].second << " zeros\n" ;
return 0;
}
|
Java
class GFG {
static class pair {
int first, second;
pair( int a, int b)
{
first = a;
second = b;
}
}
static void preCalculate( int binary[], int n,
pair left[])
{
int count1 = 0 , count0 = 0 ;
for ( int i = 0 ; i < n; i++) {
left[i].first = count1;
left[i].second = count0;
if (binary[i] != 0 )
count1++;
else
count0++;
}
}
public static void main(String args[])
{
int binary[] = { 1 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 1 };
int n = binary.length;
pair left[] = new pair[n];
for ( int i = 0 ; i < n; i++)
left[i] = new pair( 0 , 0 );
preCalculate(binary, n, left);
int queries[] = { 0 , 1 , 2 , 4 };
int q = queries.length;
for ( int i = 0 ; i < q; i++)
System.out.println(left[queries[i]].first + " ones "
+ left[queries[i]].second + " zeros\n" );
}
}
|
Python3
def preCalculate(binary, n, left):
count1, count0 = 0 , 0
for i in range (n):
left[i][ 0 ] = count1
left[i][ 1 ] = count0
if (binary[i]):
count1 + = 1
else :
count0 + = 1
binary = [ 1 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 1 ]
n = len (binary)
left = [[ 0 for i in range ( 2 )]
for i in range (n)]
preCalculate(binary, n, left)
queries = [ 0 , 1 , 2 , 4 ]
q = len (queries)
for i in range (q):
print (left[queries[i]][ 0 ], "ones" ,
left[queries[i]][ 1 ], "zeros" )
|
C#
using System;
class GFG {
public class pair {
public int first, second;
public pair( int a, int b)
{
first = a;
second = b;
}
}
static void preCalculate( int [] binary, int n,
pair[] left)
{
int count1 = 0, count0 = 0;
for ( int i = 0; i < n; i++) {
left[i].first = count1;
left[i].second = count0;
if (binary[i] != 0)
count1++;
else
count0++;
}
}
public static void Main(String[] args)
{
int [] binary = { 1, 1, 1, 0, 0, 1, 0, 1, 1 };
int n = binary.Length;
pair[] left = new pair[n];
for ( int i = 0; i < n; i++)
left[i] = new pair(0, 0);
preCalculate(binary, n, left);
int [] queries = { 0, 1, 2, 4 };
int q = queries.Length;
for ( int i = 0; i < q; i++)
Console.WriteLine(left[queries[i]].first + " ones "
+ left[queries[i]].second + " zeros\n" );
}
}
|
PHP
<?php
function preCalculate( $binary , $n )
{
$left = array ();
$count1 = 0; $count0 = 0;
for ( $i = 0; $i < $n ; $i ++)
{
$left [ $i ] = array ( $count1 ,
$count0 );
if ( $binary [ $i ])
$count1 ++;
else
$count0 ++;
}
return $left ;
}
$binary = array ( 1, 1, 1, 0, 0, 1, 0, 1, 1 );
$n = count ( $binary );
$left = preCalculate( $binary , $n );
$queries = array ( 0, 1, 2, 4 );
$q = count ( $queries );
for ( $i = 0; $i < $q ; $i ++)
echo $left [ $queries [ $i ]][0], " ones " ,
$left [ $queries [ $i ]][1], " zeros\n" ;
?>
|
Javascript
<script>
function preCalculate(binary,n,left)
{
let count1 = 0, count0 = 0;
for (let i = 0; i < n; i++) {
left[i][0] = count1;
left[i][1] = count0;
if (binary[i] != 0)
count1++;
else
count0++;
}
}
let binary=[1, 1, 1, 0, 0, 1, 0, 1, 1];
let n = binary.length;
let left= new Array(n);
for (let i = 0; i < n; i++)
left[i] = [0, 0];
preCalculate(binary, n, left);
let queries = [ 0, 1, 2, 4 ];
let q = queries.length;
for (let i = 0; i < q; i++)
document.write(left[queries[i]][0] + " ones "
+ left[queries[i]][1] + " zeros<br>" );
</script>
|
Output:
0 ones 0 zeros
1 ones 0 zeros
2 ones 0 zeros
3 ones 1 zeros
Time Complexity: O(N+q), as for pre-computation will take O(N) time because we are using a loop to traverse N times and O(1) for every query so total time will be O(q).
Auxiliary Space: O(N), as we are using extra space for the array left.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...