Finding the Largest Multiple of Three

Problem Statement

We are provided with an array of digits, and our task is to determine the largest multiple of three that can be created by concatenating some or all of these digits in any order. If it's not possible to form a valid multiple of three, return an empty string. To handle potential size issues, the result should be returned as a string, avoiding unnecessary leading zeros.

Java Implementation

Java Approach 1

import java. util.Arrays;
import java. util.Scanner; 
public class LargestMultipleOfThree {
    public static String largestMultipleOfThree(int[] digits) {
Arrays.sort(digits);
        String[] dp = new String[]{"", "", ""};
        int[] len = new int[3]; 
        for (int d: digits) {
            if (d % 3 == 0) {
                for (int i = 0; i < 3; ++i)         
dp[i] = d + dp[i]; 
continue;
            }

            String[] dp2 = Arrays.copyOf(dp, 3);
            int[] nextLen = Arrays.copyOf(len, 3);

            for (int i = 0; i < 3; ++i) {
                int j = ((len[i] == 0 ? 0 : i) + d) % 3;
                String cand = d + dp[i];
                if (nextLen[j] <= len[i] + 1) {
                   
nextLen[j] = len[i] + 1;
                   
dp2[j] = cand;
                }
            }

            len = Arrays.copyOf(nextLen, 3);
            dp = Arrays.copyOf(dp2, 3);
        }

        if (dp[0].isEmpty()) return "";
        int i = 0;

        for (char c : dp[0].toCharArray())
            if (c == '0') i++;
            else break;

        return i == dp[0].length() ? "0" : dp[0].substring(i);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Input: Array of digits
       
System.out.print("Enter the array of digits separated by space: ");
        String[] digitsStr = scanner.nextLine().split(" ");
        int[] digits = Arrays.stream(digitsStr).mapToInt(Integer::parseInt).toArray();

        // Calculate and output the largest multiple of three
        String result = largestMultipleOfThree(digits);
        System. out.println("The largest multiple of three is: " + result);

        // Close the scanner
       
scanner.close();
    }
}

Output:

Code Explanation:

The Java code implements an algorithm to find the largest multiple of three from an array of digits. The core idea is to maintain an array of strings dp, representing the largest multiple of three for each residue modulo 3.
The algorithm iterates through the array of digits, updating the dp array accordingly. It considers three cases: the current digit is divisible by 3, the current digit plus the residue forms a multiple of three, or the current digit contributes to a new largest multiple of three.
The len array keeps track of the length of each residue's largest multiple. The result is then obtained by concatenating the dp[0] string, removing any leading zeros. The algorithm efficiently handles different scenarios for constructing the largest multiple of three, leveraging dynamic programming.

Time Complexity:

The dominant factor contributing to the time complexity is the sorting operation applied to the array of digits at the beginning using Arrays.sort(). The sorting operation has a time complexity of O(N log N), where N is the length of the input array.

Space Complexity:

The space complexity is constant because the additional space used remains the same regardless of the input size. The primary data structures employed, such as arrays and strings, do not scale with the input size.

Drawbacks:

The drawback of the provided solution is its reliance on sorting, which contributes to a time complexity of O(N log N). This sorting operation could be considered excessive for certain scenarios, particularly when the array of digits is already sorted or nearly sorted.
In such cases, the algorithm's efficiency could be improved by leveraging the inherent order of the input. Additionally, the algorithm uses dynamic programming with arrays, which might lead to increased space usage for larger inputs, impacting its scalability.

Java Approach 2

import java.util.Scanner; 
public class LargestMultipleOfThreeScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        // Input: Length of the array and elements
        String[] digitsStr = scanner.nextLine().split(" ");
        int[] digits = new int[digitsStr.length];
        for (int i = 0; i < digitsStr.length; i++) {
            digits[i] = Integer.parseInt(digitsStr[i]);
        }
        // Calculate and output the largest multiple of three
        Solution solution = new Solution();
        String result = solution.largestMultipleOfThree(digits); 
        System.out.println("The largest multiple of three is: " + result); 
        // Close the scanner
        scanner.close();
    }
}
class Solution {
    public String largestMultipleOfThree(int[] digits) {
        StringBuilder sb = new StringBuilder();
        if (digits.length == 1) {
            if (digits[0] % 3 == 0) {
                return Integer.toString(digits[0]);
            } else {
                return "";
            }
        }
        int remainderOfSum = 0;
        int[] counter = new int[10];

        for (int i : digits) {
            counter[i]++;
            remainderOfSum = remainderOfSum + i;
        }
        int remainderOf1 = counter[1] + counter[4] + counter[7];
        int remainderOf2 = counter[2] + counter[5] + counter[8]; 
        remainderOfSum = remainderOfSum % 3;

        if (remainderOfSum == 1) {
            if (remainderOf1 > 0) {
                remainderOf1--;
            } else {
                remainderOf2 = remainderOf2 - 2;
            }
        }
        if (remainderOfSum == 2) {
            if (remainderOf2 > 0) {
                remainderOf2--;
            } else {
                remainderOf1 = remainderOf1 - 2;
            }
        }
        for (int i = 9; i >= 0; i--) {
            if (i % 3 == 0) {
                while (counter[i] > 0) {
                    sb.append(i);
                    counter[i]--;
                }
            }
            if (i % 3 == 1) {
                while (counter[i] > 0 && remainderOf1 > 0) {
                    sb.append(i);
                    counter[i]--;
                    remainderOf1--;
                }
            }
            if (i % 3 == 2) {
                while (counter[i] > 0 && remainderOf2 > 0) {
                    sb.append(i);
                    counter[i]--;
                    remainderOf2--;
                }
            }
        }
        if (sb.length() == 0) {
            return "";
        } else {
            if (sb.charAt(0) == '0') {
                return "0";
            } else {
                return sb.toString();
            }
        }
    }
} }

Output:

Code Explanation:

The Java code aims to find the largest multiple of three from an array of digits. It takes user input, parses the comma-separated digits, and then calls the largestMultipleOfThree method to compute the result. The algorithm, encapsulated within the largestMultipleOfThree method, employs a dynamic programming approach.
It iterates through the array of digits, updating the largest multiple of three for each residue modulo 3. The result is obtained by concatenating the dynamic programming array's elements.

Time Complexity:

The time complexity of the algorithm is O(N+M) where is N is the number of digits in the input array; and is M is the number of unique digits. In the first iteration of the algorithm, the digital frequency counts is executed while in the second time it constructs the result.

Space Complexity:

The space complexity is O(M), where M is the number of unique digits. The algorithm uses an array (counter) to store the frequency of each digit, and the size of this array is constant (10 elements) regardless of the input size.

Drawbacks:

The drawback of this solution is that it uses a greedy approach to adjust the digits to form the largest multiple of three. While this approach works in many cases, it might not guarantee the global optimum. There can be scenarios where making a local optimum choice at one step leads to a suboptimal overall solution.
A more exhaustive search or dynamic programming approach might be required for a globally optimal solution in all cases.

Java Approach 3

import java. util.Scanner; 
public class LargestMultipleOfThree {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        // Input: Array of digits
System.out.print("Enter the array of digits separated by space: ");
        String[] digitsStr = scanner.nextLine().split(" ");
        int[] digits = new int[digitsStr.length];
        for (int i = 0; i < digitsStr.length; i++) {
            digits[i] = Integer.parseInt(digitsStr[i]);
        }
        // Calculate and output the largest multiple of three
        String result = largestMultipleOfThree(digits);
       
System.out.println("The largest multiple of three is: " + result);

        // Close the scanner
       
scanner.close();
    }
    public static String largestMultipleOfThree(int[] digits) {
        StringBuilder ans = new StringBuilder();
        int[] mod1 = new int[]{1, 4, 7, 2, 5, 8};
        int[] mod2 = new int[]{2, 5, 8, 1, 4, 7};
        int[] count = new int[10];
        int sum = 0; 
        for (int digit: digits) {
++count[digit];
            sum += digit;
        }

        while (sum % 3 != 0)
            for (int i : sum % 3 == 1 ? mod1 : mod2)
                if (count[i] > 0) {
                   
--count[i];
                   
sum -= i;
                   
break;
                }

        for (int digit = 9; digit >= 0; --digit)
           
ans.append(Character.toString('0' + digit).repeat(count[digit]));

        return ans.length() > 0 && ans.charAt(0) == '0' ? "0" : ans.toString();
    }
}

Output:

Time Complexity:

The Time complexity of the algorithm depends on the number of iterations of the loops aimed at finding minimal digit and removing it.
The worse situation occurs whereby several cycles are required, in order to transform the sum into a multiple of three For this problem,
The order of magnitude for the execution time will be about O(N), where N stands for the number of digits in a given input array.

Space Complexity:

The space complexity is O(1), as the additional space used is constant regardless of the input size. The arrays mod1, mod2, and count have fixed sizes (10 integers each), and the StringBuilder ans grows linearly with the number of digits in the input.

Next TopicFlatten a binary tree into linked list

← prev next →