# Find the position of box which occupies the given ball

• Last Updated : 08 Jun, 2022

Given two array A[] and B[]. Where size of A[] represent the number of rows and A[i] represent the number of boxes in the ith row. Array B[] represents an array of balls where B[i] represents a number on the ball. Given that ball i (having value B[i]) will be placed in a box whose position from beginning is B[i] (row-major). The task is to find the row and column of the boxes corresponding to each B[i]
Examples:

Input: A[] = {2, 3, 4, 5}, B[] = {1, 4, 6, 3}
Output:
1, 1
2, 2
3, 1
2, 1
B = 1, hence Box position will be 1st row, 1st column
B = 4, hence Box position will be 2nd row, 2nd column
B = 6, hence Box position will be 3rd row, 1st column
B = 3, hence Box position will be 2nd row, 1st column
Input: A[] = {2, 2, 2, 2}, B[] = {1, 2, 3, 4}
Output:
1, 1
1, 2
2, 1
2, 2

Approach: As per problem statement, in 1st row A number of boxes are placed similarly in 2nd row A number of boxes are there. So, in case a ball is to be placed in any box of the second row, its value must be greater than A. So, for finding the actual position of box where a ball B[i] is going to be placed first of all find the cumulative sum of array A[] and then find the position of element in cumulative sum array which is just greater than B[i], that will be the row number and for finding the box number in that particular row find the value of B[i] – value in cumulative array which is just smaller than B[i].
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the position of each boxes``// where a ball has to be placed``void` `printPosition(``int` `A[], ``int` `B[], ``int` `sizeOfA, ``int` `sizeOfB)``{` `    ``// Find the cumulative sum of array A[]``    ``for` `(``int` `i = 1; i < sizeOfA; i++)``        ``A[i] += A[i - 1];` `    ``// Find the position of box for each ball``    ``for` `(``int` `i = 0; i < sizeOfB; i++) {` `        ``// Row number``        ``int` `row = lower_bound(A, A + sizeOfA, B[i]) - A;` `        ``// Column (position of box in particular row)``        ``int` `boxNumber = (row >= 1) ? B[i] - A[row - 1] : B[i];` `        ``// Row + 1 denotes row if indexing of array start from 1``        ``cout << row + 1 << ``", "` `<< boxNumber << ``"\n"``;``    ``}``}` `// Driver code``int` `main()``{` `    ``int` `A[] = { 2, 2, 2, 2 };``    ``int` `B[] = { 1, 2, 3, 4 };``    ``int` `sizeOfA = ``sizeof``(A) / ``sizeof``(A);``    ``int` `sizeOfB = ``sizeof``(B) / ``sizeof``(B);``    ``printPosition(A, B, sizeOfA, sizeOfB);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `class` `GFG``{` `    ``// Function to print the position of each boxes``    ``// where a ball has to be placed``    ``static` `void` `printPosition(``int` `A[], ``int` `B[],``                        ``int` `sizeOfA, ``int` `sizeOfB)``    ``{` `        ``// Find the cumulative sum of array A[]``        ``for` `(``int` `i = ``1``; i < sizeOfA; i++)``        ``{``            ``A[i] += A[i - ``1``];``        ``}` `        ``// Find the position of box for each ball``        ``for` `(``int` `i = ``0``; i < sizeOfB; i++)``        ``{` `            ``// Row number``            ``int` `row = lower_bound(A, ``0``, A.length, B[i]);` `            ``// Column (position of box in particular row)``            ``int` `boxNumber = (row >= ``1``) ? B[i] - A[row - ``1``] : B[i];` `            ``// Row + 1 denotes row if indexing of array start from 1``            ``System.out.print(row + ``1` `+ ``", "` `+ boxNumber + ``"\n"``);``        ``}``    ``}` `    ``private` `static` `int` `lower_bound(``int``[] a, ``int` `low, ``int` `high, ``int` `element)``    ``{``        ``while` `(low < high)``        ``{``            ``int` `middle = low + (high - low) / ``2``;``            ``if` `(element > a[middle])``            ``{``                ``low = middle + ``1``;``            ``}``            ``else``            ``{``                ``high = middle;``            ``}``        ``}``        ``return` `low;``    ``}``    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = {``2``, ``2``, ``2``, ``2``};``        ``int` `B[] = {``1``, ``2``, ``3``, ``4``};``        ``int` `sizeOfA = A.length;``        ``int` `sizeOfB = B.length;``        ``printPosition(A, B, sizeOfA, sizeOfB);` `    ``}``}` `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach``import` `bisect` `# Function to print the position of each boxes``# where a ball has to be placed``def` `printPosition(A, B, sizeOfA, sizeOfB):` `    ``# Find the cumulative sum of array A[]``    ``for` `i ``in` `range``(``1``, sizeOfA):``        ``A[i] ``+``=` `A[i ``-` `1``]` `    ``# Find the position of box for each ball``    ``for` `i ``in` `range``(sizeOfB):` `        ``# Row number``        ``row ``=` `bisect.bisect_left(A, B[i])` `        ``# Column (position of box in particular row)``        ``if` `row >``=` `1``:``            ``boxNumber ``=` `B[i] ``-` `A[row ``-` `1``]``        ``else``:``            ``boxNumber ``=` `B[i]` `        ``# Row + 1 denotes row``        ``# if indexing of array start from 1``        ``print``(row ``+` `1``, ``","``, boxNumber)` `# Driver code``A ``=` `[``2``, ``2``, ``2``, ``2``]``B ``=` `[``1``, ``2``, ``3``, ``4``]``sizeOfA ``=` `len``(A)``sizeOfB ``=` `len``(B)``printPosition(A, B, sizeOfA, sizeOfB)` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ``// Function to print the position of each boxes``    ``// where a ball has to be placed``    ``static` `void` `printPosition(``int` `[]A, ``int` `[]B,``                        ``int` `sizeOfA, ``int` `sizeOfB)``    ``{` `        ``// Find the cumulative sum of array A[]``        ``for` `(``int` `i = 1; i < sizeOfA; i++)``        ``{``            ``A[i] += A[i - 1];``        ``}` `        ``// Find the position of box for each ball``        ``for` `(``int` `i = 0; i < sizeOfB; i++)``        ``{` `            ``// Row number``            ``int` `row = lower_bound(A, 0, A.Length, B[i]);` `            ``// Column (position of box in particular row)``            ``int` `boxNumber = (row >= 1) ? B[i] - A[row - 1] : B[i];` `            ``// Row + 1 denotes row if indexing of array start from 1``            ``Console.WriteLine(row + 1 + ``", "` `+ boxNumber + ``"\n"``);``        ``}``    ``}` `    ``private` `static` `int` `lower_bound(``int``[] a, ``int` `low,``                                    ``int` `high, ``int` `element)``    ``{``        ``while` `(low < high)``        ``{``            ``int` `middle = low + (high - low) / 2;``            ``if` `(element > a[middle])``            ``{``                ``low = middle + 1;``            ``}``            ``else``            ``{``                ``high = middle;``            ``}``        ``}``        ``return` `low;``    ``}``    ` `    ``// Driver code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `[]A = {2, 2, 2, 2};``        ``int` `[]B = {1, 2, 3, 4};``        ``int` `sizeOfA = A.Length;``        ``int` `sizeOfB = B.Length;``        ``printPosition(A, B, sizeOfA, sizeOfB);` `    ``}``}` `// This code has been contributed by Tushil.`

## PHP

 ```\$value``)``    ``{``        ``if``(``\$valueTosearch` `<= ``\$value``)``            ``return` `\$row``;``        ``\$row``++;``    ``}``    ``return` `\$row``+1;``}` `// Function to print the position of each boxes``// where a ball has to be placed``function` `printPosition(``\$A``, ``\$B``, ``\$sizeOfA``, ``\$sizeOfB``)``{` `    ``// Find the cumulative sum of array A[]``    ``for` `(``\$i` `= 1; ``\$i` `<``\$sizeOfA``; ``\$i``++)``        ``\$A``[``\$i``] += ``\$A``[``\$i` `- 1];` `    ``// Find the position of box for each ball``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$sizeOfB``; ``\$i``++)``    ``{` `        ``// Row number``        ``\$row` `= lower_bound(``\$A``, ``\$B``[``\$i``]) ;` `        ``// Column (position of box in particular row)``        ``\$boxNumber` `= (``\$row` `>= 1) ? ``\$B``[``\$i``] - ``\$A``[``\$row` `- 1] : ``\$B``[``\$i``];` `        ``// Row + 1 denotes row if indexing of array start from 1``        ``print_r(``\$row``+1 .``", "``.``\$boxNumber``);``        ``echo` `"\n"``;``    ``}``}` `    ``// Driver code``    ``\$A` `= ``array``(2, 2, 2, 2 );``    ``\$B` `= ``array``( 1, 2, 3, 4 );``    ``\$sizeOfA` `=``count``(``\$A``);``    ``\$sizeOfB` `= ``count``(``\$B``);``    ``printPosition(``\$A``, ``\$B``, ``\$sizeOfA``, ``\$sizeOfB``);``    ` `    ``// This code is contributed by Shivam.Pradhan``?>`

## Javascript

 ``

Output:

```1, 1
1, 2
2, 1
2, 2```

Time Complexity: O(sizeOfA + sizeOfB)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up