Arranging Coin Problem in Java

Problem Statement

Given a number n representing n coins, we need to form a staircase with these coins. The i-th row of the staircase contains exactly i coins. The goal is to determine the total number of complete rows that can be formed with n coins.

Approach to the Problem

1. Mathematical Approach

The problem essentially involves finding the largest integer k such that the sum of the first k natural numbers is less than or equal to n.
The sum of the first k natural numbers is given by the formula: Sum(k)=(k×(k+1))/2
We need to find the largest k such that: (k×(k+1))/2≤n.

File Name: ArrangingCoins.java

public class ArrangingCoins {
    public static int arrangeCoinsIterative(int n) {
        int k = 0;
        int sum = 0;
        while (sum <= n) {
            k++;
            sum += k;
        }
        // k was incremented one extra time when sum exceeded n
        return k - 1;
    }
    public static void main(String[] args) {
        int n = 10; // Example value
        int result = arrangeCoinsIterative(n);
        System.out.println("The number of complete rows with " + n + " coins is: " + result);
    }
}

Output:

 
The number of complete rows with 10 coins is: 4

Explanation

In this approach it increments k and adds it to sum until sum exceeds n. It returns k - 1, the largest number of complete rows that fit within n coins. This method ensures each step increases sum gradually until it surpasses n, ensuring an accurate count of complete rows.

Time Complexity:

The while loop runs until the sum exceeds n. The sum of the first k natural numbers is (k×(k+1))/2
In the worst case, we have to check up to the point where (k×(k+1))/2 ≤ n.
This means that k is approximately O(sqrt(n)) because solving k^2 ≤2n gives k≈sqrt(2n).
Thus, the time complexity is O(sqrt(n)).

Space Complexity:

The space complexity is O(1) since we are only using a few integer variables (k and sum) regardless of the input size.

2. Binary Search Approach

This problem can be solved efficiently using binary search because the sum formula is monotonically increasing.
By applying binary search, we can find the maximum k for which the sum is less than or equal to n.

File Name: ArrangingCoins.java

public class ArrangingCoins {
    public static int arrangeCoinsBinarySearch(int n) {
        if (n == 0) return 0;
        int left = 1, right = n;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long sum = (long) mid * (mid + 1) / 2; // Use long to avoid overflow
            if (sum == n) {
                return mid;
            } else if (sum < n) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        // The right pointer will be at the largest k for which sum(k) <= n
        return right;
    }
    public static void main(String[] args) {
        int n = 10; // Example value
        int result = arrangeCoinsBinarySearch(n);
        System.out.println("The number of complete rows with " + n + " coins is: " + result);
    }
}

Output:

 
The number of complete rows with 10 coins is: 4

Explanation

In this approach efficiently finds the largest k using binary search on the range [1, n]. It calculates the sum of the first k natural numbers and adjusts the search range based on this sum. This method optimizes the search by halving the range with each step, ensuring quick determination of the maximum complete rows possible within n coins.

Time Complexity:

The binary search approach uses a logarithmic search to find the largest k such that the sum of the first k natural numbers is less than or equal to n.
Binary search on the range from 1 to n takes O(logn) time because we are dividing the search interval in half with each iteration.
Each check within the binary search involves a constant-time arithmetic operation.
Thus, the time complexity is O(logn).

Space Complexity:

The space complexity is O(1) since we only use a few integer variables (left, right, mid, and sum) regardless of the input size.

Conclusion

The problem of arranging coins to form a staircase where each row contains an increasing number of coins can be efficiently tackled using iterative or binary search approaches. Both methods provide clear strategies to find the maximum number of complete rows that can be formed with a given number of coins n. Whether through iterative incrementation or binary search optimization, these approaches ensure accurate determination of the staircase's height, meeting the problem's requirements effectively

Next TopicBeautiful-path-code-in-java

← prev next →