GeeksforGeeks App
Open App
Browser
Continue

# Minimum comparisons required to find the only heavier ball from N balls

Given N (N > 1) number of balls and a weight balancing machine. There are N-1 balls of the same weight and one ball heavier than the others. The task is to find out the minimum number of times weighing is required to find the heavier ball where any number of balls can be weighted each time.

Note: The weight balancing machine can tell relative weights not absolute weights i.e. weight of one ball with respect to another.

Examples:

Input: N = 5
Output: 2
Explanation: Divide the balls into 2+2+1 parts. Weigh the groups with 2 balls.
If they weigh the same the other is having a different weight.
Otherwise, take the group with greater weight(as it has the required ball) and
measure them one vs one(2 times measuring case).

Input: N = 9
Output: 2

Naive Approach: The solution is based on the following observation.

• Any number of balls (N) can be divided into 3 groups having nearly equal number of balls and two of them can be weighted at a time.
• Now if any one of them is heavier than other then the heavier ball is in that group.
• Otherwise, it is in the group which is not weighted.
• Now again that group can be further divided into 3 subgroups and this goes on.
• So this gives a recursive function.

So use a recursive function where N is divided by 3 in each step and the recursion is called on ceiling value of N/3 now.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement above approach``#include ``using` `namespace` `std;` `// Recursive function to find``// minimum number of weighing required``int` `solve(``int` `N)``{``    ``if` `(N == 0)``        ``return` `0;``    ``if` `(N == 1)``        ``return` `0;``    ``float` `rec = N;``    ``return` `(solve(``ceil``(rec / 3.0)) + 1);``}` `// Driver code``int` `main()``{``    ``int` `N = 5;``    ``cout << solve(N);``    ``return` `0;``}`

## Java

 `// Java code to implement above approach``class` `GFG``{``  ` `  ``// Recursive function to find``  ``// minimum number of weighing required``  ``public` `static` `int` `solve(``int` `N) {``    ``if` `(N == ``0``)``      ``return` `0``;``    ``if` `(N == ``1``)``      ``return` `0``;``    ``float` `rec = N;``    ``return` `(solve((``int``)Math.ceil(rec / ``3.0``)) + ``1``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String args[]) {``    ``int` `N = ``5``;``    ``System.out.println(solve(N));``  ``}``}` `// This code is contributed by gfgking.`

## Python3

 `# Python code to implement above approach``import` `math;` `# Recursive function to find``# minimum number of weighing required``def` `solve(N):``    ``if` `(N ``=``=` `0``):``        ``return` `0``;``    ``if` `(N ``=``=` `1``):``        ``return` `0``;``    ``rec ``=` `N;``    ``return` `(solve(math.ceil(rec ``/` `3.0``)) ``+` `1``);` `# Driver code``N ``=` `5``;``print``(solve(N));` `# This code is contributed by gfgking.`

## Javascript

 ``

## C#

 `using` `System;` `public` `class` `GFG {` `    ``// Recursive function to find``    ``// minimum number of weighing required``    ``public` `static` `int` `solve(``int` `N)``    ``{``        ``if` `(N == 0)``            ``return` `0;``        ``if` `(N == 1)``            ``return` `0;``        ``float` `rec = N;``        ``return` `(solve((``int``)Math.Ceiling(rec / 3.0)) + 1);``    ``}` `    ``// Driver code``    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``int` `N = 5;``        ``Console.Write(solve(N));``    ``}``}``// This code is contributed by Potta lokesh`

Output

`2`

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

Efficient Approach: From the above approach it can be clearly seen that it is similar to finding the exponent of 3 which is equal to or greater than N. Which can be calculated using logarithm.

## C++

 `// C++ code to implement above approach``#include ``using` `namespace` `std;` `// Functions to find the minimum``// number of weighing required``int` `solve(``int` `N)``{``    ``int` `mini = ``ceil``(``log``(N) / ``log``(3));``    ``return` `mini;``}` `// Driver code``int` `main()``{``    ``int` `N = 5;``    ``cout << solve(N);``    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.util.*;` `class` `GFG{` `  ``// Functions to find the minimum``  ``// number of weighing required``  ``static` `int` `solve(``int` `N)``  ``{``    ``int` `mini = (``int``)Math.ceil(Math.log(N) / Math.log(``3``));``    ``return` `mini;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``5``;``    ``System.out.print(solve(N));``  ``}``}` `// This code is contributed by code_hunt.`

## Python

 `# Python code to implement above approach``import` `math` `# Functions to find the minimum``# number of weighing required``def` `solve(N):` `    ``mini ``=` `math.ceil(math.log(N) ``/` `math.log(``3``))``    ``return` `mini` `# Driver code``N ``=` `5``print``(solve(N))` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# code for the above approach``using` `System;` `public` `class` `GFG{` `  ``// Functions to find the minimum``  ``// number of weighing required``  ``static` `int` `solve(``int` `N)``  ``{``    ``int` `mini = (``int``)Math.Ceiling(Math.Log(N) / Math.Log(3));``    ``return` `mini;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `N = 5;``    ``Console.Write(solve(N));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`2`

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

My Personal Notes arrow_drop_up