GeeksforGeeks App
Open App
Browser
Continue

# Maximum possible time that can be formed from four digits | (Recursive Approach)

Given an array arr[] with 4 integers. The task is to return the maximum 24 hour time that can be formed using the digits from the array. Note that the minimum time in 24-hour format is 00:00, and the maximum is 23:59. If a valid time cannot be formed then return an empty string.
Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 23:41
Explanation: 23:41 is the maximum time possible in 24-hour format

Input: arr[] = {5, 5, 6, 6}
Output: “”
Explanation: No valid time can be formed from the given digits

HashMap Approach:- One approach to this problem is already discussed  https://www.geeksforgeeks.org/maximum-possible-time-that-can-be-formed-from-four-digits/

Recursive Approach: The task can also be solved using recursion. Try generating all possible permutations using recursion and then discard the invalid permutation and return the permutation with the largest possible value, after sorting all the permutations. If no valid permutation exists, return an empty string. Condition for the valid permutation.

• The first digit of hours must be from the range [0, 2].
• The second digit of hours must be from the range [0, 3] if the first digit was chosen as 2 else [0, 9].
• The first digit of minutes must be from the range [0, 5] and the second digit of minutes must be from the range [0, 9]

Below is the implementation of the above code:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// Stores all the permutations``vector res;` `// Function to generate valid permutations``void` `getMax(``int` `idx, vector<``int``>& nums, string per)``{``    ``// All the digits are used``    ``if` `(idx == nums.size()) {` `        ``// If first digit is``        ``// not 0, 1 or 2 then it is``        ``// invalid, return``        ``if` `(per[0] != ``'0'``            ``&& per[0] != ``'1'``            ``&& per[0] != ``'2'``)``            ``return``;` `        ``// Second digit must be less than 7``        ``if` `(per[2] >= ``'6'``)``            ``return``;` `        ``// If first digit is 2``        ``// then second digit must be``        ``// smaller than 5``        ``if` `(per[0] == ``'2'``            ``and per[1] >= ``'4'``)``            ``return``;` `        ``// Push the valid``        ``// permutation in result``        ``res.push_back(per);``        ``return``;``    ``}` `    ``for` `(``int` `i = idx; i < nums.size(); i++) {` `        ``// add num to res``        ``per += nums[i] + ``'0'``;` `        ``// swap and solve``        ``// for further permutation``        ``swap(nums[idx], nums[i]);` `        ``// Recur``        ``getMax(idx + 1, nums, per);` `        ``// Backtrack``        ``per.pop_back();` `        ``swap(nums[i], nums[idx]);``    ``}``}` `// Function to return maximum time``// possible in 24-hour format``string getMaxtime(vector<``int``>& arr)``{``    ``string per = ``""``;``    ``getMax(0, arr, per);` `    ``// No valid permutation``    ``// can be generated``    ``if` `(res.empty())``        ``return` `""``;` `    ``// Sort all valid permutations``    ``sort(res.begin(), res.end());` `    ``// Largest valid permutation``    ``string ans = res[res.size() - 1];` `    ``// Resultant string``    ``string result``        ``= ans.substr(0, 2)``          ``+ ``":"``          ``+ ans.substr(2, 2);``    ``return` `result;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 1, 2, 3, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);``    ``cout << (getMaxtime(arr));``    ``return` `0;``}`

## Java

 `// Java implementation of the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `  ``// Stores all the permutations``  ``public` `static` `ArrayList res = ``new` `ArrayList<>();` `  ``// Function to generate valid permutations``  ``public` `static` `void` `getMax(``int` `idx, ``int``[] nums, String per)``  ``{``    ``// All the digits are used``    ``if` `(idx == nums.length) {` `      ``// If first digit is``      ``// not 0, 1 or 2 then it is``      ``// invalid, return``      ``if` `(per.charAt(``0``) != ``'0'`  `&&``          ``per.charAt(``0``) != ``'1'` `&&``          ``per.charAt(``0``) != ``'2'``)``        ``return``;` `      ``// Second digit must be less than 7``      ``if` `(per.charAt(``2``) >= ``'6'``)``        ``return``;` `      ``// If first digit is 2``      ``// then second digit must be``      ``// smaller than 5``      ``if` `(per.charAt(``0``) == ``'2'` `&& per.charAt(``1``) >= ``'4'``)``        ``return``;` `      ``// Push the valid``      ``// permutation in result``      ``res.add(per);` `      ``return``;``    ``}` `    ``for` `(``int` `i = idx; i < nums.length; i++) {` `      ``// add num to res``      ``per += String.valueOf(nums[i]);` `      ``// swap and solve``      ``// for further permutation``      ``int` `temp = nums[idx];``      ``nums[idx] = nums[i];``      ``nums[i] = temp;` `      ``// Recur``      ``getMax(idx + ``1``, nums, per);` `      ``// Backtrack``      ``per = per.substring(``0``, per.length() - ``1``);` `      ``temp = nums[i];``      ``nums[i] = nums[idx];``      ``nums[idx] = temp;``    ``}``  ``}` `  ``// Function to return maximum time``  ``// possible in 24-hour format``  ``public` `static` `String getMaxtime(``int``[] arr)``  ``{``    ``String per = ``""``;``    ``getMax(``0``, arr, per);` `    ``// No valid permutation``    ``// can be generated``    ``if` `(res.isEmpty())``      ``return` `""``;` `    ``// Sort all valid permutations``    ``Collections.sort(res);` `    ``// Largest valid permutation``    ``String ans = res.get(res.size() - ``1``);`  `    ``// Resultant String``    ``String result``      ``= ans.substring(``0``, ``2``)``      ``+ ``":"``      ``+ ans.substring(``2``, ``4``);``    ``return` `result;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``int``[] arr = { ``1``, ``2``, ``3``, ``4` `};``    ``int` `n = arr.length;``    ``System.out.println(getMaxtime(arr));``  ``}``}` `// This code is contributed by Shubham Singh`

## Python3

 `# Python implementation of the above approach` `# Stores all the permutations``res``=``[];` `# Function to generate valid permutations``def` `getMax(idx, nums, per):``    ``# All the digits are used``    ``if` `(idx ``=``=` `len``(nums)) :` `        ``# If first digit is``        ``# not 0, 1 or 2 then it is``        ``# invalid, return``        ``if` `(per[``0``] !``=` `'0'` `and` `per[``0``] !``=` `'1'` `and` `per[``0``] !``=` `'2'``):``            ``return``;` `        ``# Second digit must be less than 7``        ``if` `(per[``2``] >``=` `'6'``):``            ``return``;` `        ``# If first digit is 2``        ``# then second digit must be``        ``# smaller than 5``        ``if` `(per[``0``] ``=``=` `'2'``and` `per[``1``] >``=` `'4'``):``            ``return``;` `        ``# Push the valid``        ``# permutation in result``        ``res.append(per);``        ``return``;` `    ``for` `i ``in` `range``(idx, ``len``(nums)):` `        ``# add num to res``        ``per ``+``=` `str``(nums[i]) ;` `        ``# swap and solve``        ``# for further permutation``        ``nums[idx], nums[i]``=``nums[i], nums[idx];` `        ``# Recur``        ``getMax(idx ``+` `1``, nums, per);` `        ``# Backtrack``        ``#per.pop();``        ``per``=``per[:``-``1``];` `        ``nums[i], nums[idx]``=``nums[idx], nums[i];``  ` `# Function to return maximum time``# possible in 24-hour format``def` `getMaxtime(arr):``    ``per ``=` `"";``    ``getMax(``0``, arr, per);` `    ``# No valid permutation``    ``# can be generated``    ``if` `(``len``(res)``=``=``0``):``        ``return` `"";` `    ``# Sort all valid permutations``    ``res.sort();``    ` `    ``# Largest valid permutation``    ``ans ``=` `res[``len``(res) ``-` `1``];` `    ``# Resultant string``    ``result``=` `ans[``0``: ``2``]``+` `":"``+` `ans[``2``:``4``];``    ``return` `result;` `# Driver Code``arr ``=` `[ ``1``, ``2``, ``3``, ``4` `];``n ``=` `len``(arr);``print``(getMaxtime(arr));`

## C#

 `// C# code to delete middle of a stack``using` `System;``using` `System.Collections.Generic;``class` `GFG {``  ``public` `static` `List<``string``> res = ``new` `List<``string``>();` `  ``public` `static` `void` `getMax(``int` `idx, ``ref` `int``[] nums, ``string` `per)``  ``{` `    ``// all the digits are used``    ``if``(idx == nums.Length)``    ``{` `      ``// if first digit is``      ``// not 0,1 or 2 then it is``      ``// invalid, return``      ``if``(per[0] != ``'0'` `&& per[0] != ``'1'` `&& per[0] != ``'2'``) ``return``;` `      ``// second digit musch be less than 7``      ``if``(per[2] >= ``'6'``) ``return``;` `      ``// if first digit is 2``      ``// then second digit must be``      ``// smaller than 5``      ``if``(per[0] == ``'2'` `&& per[1] >= ``'4'``) ``return``;` `      ``// push the valid``      ``// permutation in result``      ``res.Add(per);``      ``return``;``    ``}``    ``for``(``int` `i = idx; i

## Javascript

 `// Javascript implementation of the above approach` `// Stores all the permutations``let res = []` `// Function to generate valid permutations``function` `getMax(idx, nums, per) {``    ``// All the digits are used``    ``if` `(idx ==nums.length) {``        ``// If first digit is``        ``// not 0, 1 or 2 then it is``        ``// invalid, return``        ``if` `(per[0] != ``'0'` `&& per[0] != ``'1'` `&& per[0] !=``'2'``) {``            ``return``;``        ``}``        ``// Second digit must be less than 7``        ``if` `(per[2] >= ``'6'``) {``            ``return``;``        ``}``        ``// If first digit is 2``        ``// then second digit must be``        ``// smaller than 5``        ``if` `(per[0] === ``'2'` `&& per[1] >= ``'4'``) {``            ``return``;``        ``}``        ``// Push the valid``        ``// permutation in result``        ``res.push(per);``        ``return``;``    ``}``    ``for` `(let i = idx; i < nums.length; i++) {``        ``// add num to res``        ``per += nums[i].toString();` `        ``// swap and solve``        ``// for further permutation``        ``[nums[idx], nums[i]] = [nums[i], nums[idx]]` `        ``// Recur``        ``getMax(idx + 1, nums, per);` `        ``// Backtrack``        ``per = per.substring(0, per.length - 1);` `        ``[nums[i], nums[idx]] = [nums[idx], nums[i]]``    ``}``}` `// Function to return maximum time``// possible in 24-hour format``function` `getMaxtime(arr) {``    ``let per = ``""``;``    ``getMax(0, arr, per);` `    ``// No valid permutation``    ``// can be generated``    ``if` `(res.length === 0) {``        ``return` `""``;``    ``}` `    ``// Sort all valid permutations``    ``res.sort();` `    ``// Largest valid permutation``    ``let ans = res[res.length - 1];` `    ``// Resultant string``    ``let result = ans.substring(0, 2) + ``":"` `+ ans.substring(2, 4);``    ``return` `result;``}` `// Driver Code``let arr = [1, 2, 3, 4];``document.write(getMaxtime(arr));`

Output

`23:41`

Time Complexity: O(N! * log(N!))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up