# Find the position of box which occupies the given ball

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `?> `

Output:

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Discovering ways to develop a plane for soaring career goals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.