 Open in App
Not now

# Minimum Cost To set Digital Clock Timer with given movement and push cost

• Difficulty Level : Expert
• Last Updated : 02 Mar, 2022

Given integers A, B and N. The task is to minimize the cost to set N seconds in a digital clock where time is represented in the following format:

• at most 99 minutes and 99 seconds
• at least 1 second
• The first two digits represent minutes and the last two minutes represent seconds.
• It prepends 0 if less than 4 digits are pressed to set time

A is the cost to get a new digit that is already not pressed to set time and B is the cost for pressing any digit to set time.

Examples:

Input: A = 1, B = 5, N = 300
Output: 17
Explanation: The following possible clock settings can be: 05:00, 5:00, 04:60, 4:60.
since 4 minutes, 60 seconds is equivalent to 5 minutes.
If the clock is set as 5:00 it will require 1 + 5 to set 5, then 1 + 5 to set a zero, then 5 to set the last zero,
since the same button is pressed again, no requirement of adding A.
So minimum cost = 1 + 5 + 1+ 5 + 5 = 17
The other option of 4:60 gives cost = 1 + 5 + 1 + 5 + 1 + 5 = 18

Input: A = 2, B = 1, N = 1
Output: 3

Approach: This problem is implementation based. Find out the possible two representations (may have only one possible representation) and the minimum cost among those two. Follow the steps mentioned below:

• The first observation should be that there is no need of pressing 0s which would be prepended by the clock automatically.
• So, find the two clock timings: (x/60, x%60) and (x/60 -1, 60 + x%60) no other combination is possible.
• Try to find the best answer between these two timings only.

Below is the implementation of the above approach.

## C++14

 `// C++ program to implement the above approach``#include ``using` `namespace` `std;` `// Function to get the minimum time``int` `minCostTime(``int` `moveCost, ``int` `pushCost,``                ``int` `targetSeconds)``{``    ``// Setting startAt to -1 as``    ``// nothing is pressed earlier``    ``// This variable shows last pressed button``    ``int` `startAt = -1;` `    ``// Its the first timing which can be set``    ``int` `target_minute = targetSeconds / 60;``    ``int` `target_sec = targetSeconds % 60;` `    ``// If time is greater than 99 min``    ``// and 60 sec then first time would come``    ``// somewhere in 100 min``    ``// which would actually be wrong.``    ``// as max min can be 99 only.``    ``if` `(target_minute > 99) {``        ``target_minute = target_minute - 1;``        ``target_sec = 60 + target_sec;``    ``}` `    ``// Its the variables for``    ``// second timing possible``    ``int` `target_sec2 = 0;``    ``int` `target_minute2 = target_minute - 1;` `    ``// Second timing is only possible``    ``// if first timing minute is``    ``// greater than zero and second``    ``// is less than 40 because``    ``// x mins and y seconds will be converted``    ``// to x-1 mins and 60 + y secs``    ``// and max seconds can be 99``    ``if` `(target_sec < 40``        ``&& target_minute != 0) {``        ``target_minute2 = target_minute - 1;``        ``target_sec2 = 60 + target_sec;``    ``}` `    ``// Convert 1st minute to optimal string``    ``string s = ``""``;` `    ``// Append  min only if min > 0``    ``// else, will be prepended automatically.``    ``if` `(target_minute > 0)``        ``s += to_string(target_minute);` `    ``// If seconds is 1 digit number``    ``// then a 0 needs to be added before it``    ``if` `(target_sec < 10``        ``&& target_minute != 0) {``        ``s += ``'0'``;``    ``}``    ``s += to_string(target_sec);` `    ``// Calculate cost for 1st TIME.``    ``int` `temp = startAt;``    ``int` `ans = 0;``    ``for` `(``int` `i = 0; i < s.length(); i++) {``        ``int` `x = s[i] - ``'0'``;``        ``if` `(x != temp) {``            ``ans += moveCost;``            ``ans += pushCost;``            ``temp = x;``        ``}``        ``else` `{``            ``ans += pushCost;``            ``temp = x;``        ``}``    ``}``    ``if` `(target_sec >= 40``        ``|| target_minute == 0) {``        ``return` `ans;``    ``}` `    ``// Find cost for 2nd TIME. */``    ``string s2 = ``""``;``    ``if` `(target_minute2 != 0)``        ``s2 += to_string(target_minute2);``    ``if` `(target_sec2 < 10``        ``&& target_minute2 != 0) {``        ``s2 += ``'0'``;``    ``}``    ``s2 += to_string(target_sec2);``    ``int` `temp2 = startAt;``    ``int` `ans2 = 0;``    ``for` `(``int` `i = 0; i < s2.size(); i++) {``        ``int` `x = s2[i] - ``'0'``;` `        ``if` `(x != temp2) {``            ``ans2 += moveCost;``            ``ans2 += pushCost;``            ``temp2 = x;``        ``}``        ``else` `{``            ``ans2 += pushCost;``            ``temp2 = x;``        ``}``    ``}` `    ``// Returning the minimum of the two cost.``    ``return` `min(ans, ans2);``}` `// Driver code``int` `main()``{``    ``int` `A = 1, B = 5, N = 300;` `    ``// Function call``    ``int` `ans = minCostTime(A, B, N);``    ``cout << ans;``    ``return` `0;``}`

## Java

 `import` `java.util.*;``class` `GFG``{` `  ``// Function to get the minimum time``  ``public` `static` `int` `minCostTime(``int` `moveCost,``                                ``int` `pushCost,``                                ``int` `targetSeconds)``  ``{``    ``// Setting startAt to -1 as``    ``// nothing is pressed earlier``    ``// This variable shows last pressed button``    ``int` `startAt = -``1``;` `    ``// Its the first timing which can be set``    ``int` `target_minute = targetSeconds / ``60``;``    ``int` `target_sec = targetSeconds % ``60``;` `    ``// If time is greater than 99 min``    ``// and 60 sec then first time would come``    ``// somewhere in 100 min``    ``// which would actually be wrong.``    ``// as max min can be 99 only.``    ``if` `(target_minute > ``99``) {``      ``target_minute = target_minute - ``1``;``      ``target_sec = ``60` `+ target_sec;``    ``}` `    ``// Its the variables for``    ``// second timing possible``    ``int` `target_sec2 = ``0``;``    ``int` `target_minute2 = target_minute - ``1``;` `    ``// Second timing is only possible``    ``// if first timing minute is``    ``// greater than zero and second``    ``// is less than 40 because``    ``// x mins and y seconds will be converted``    ``// to x-1 mins and 60 + y secs``    ``// and max seconds can be 99``    ``if` `(target_sec < ``40` `&& target_minute != ``0``) {``      ``target_minute2 = target_minute - ``1``;``      ``target_sec2 = ``60` `+ target_sec;``    ``}` `    ``// Convert 1st minute to optimal string``    ``String s = ``""``;` `    ``// Append min only if min > 0``    ``// else, will be prepended automatically.``    ``if` `(target_minute > ``0``)``      ``s += Integer.toString(target_minute);` `    ``// If seconds is 1 digit number``    ``// then a 0 needs to be added before it``    ``if` `(target_sec < ``10` `&& target_minute != ``0``) {``      ``s += ``'0'``;``    ``}``    ``s += Integer.toString(target_sec);` `    ``// Calculate cost for 1st TIME.``    ``int` `temp = startAt;``    ``int` `ans = ``0``;``    ``for` `(``int` `i = ``0``; i < s.length(); i++) {``      ``int` `x = s.charAt(i);``      ``if` `(x != temp) {``        ``ans += moveCost;``        ``ans += pushCost;``        ``temp = x;``      ``}``      ``else` `{``        ``ans += pushCost;``        ``temp = x;``      ``}``    ``}``    ``if` `(target_sec >= ``40` `|| target_minute == ``0``) {``      ``return` `ans;``    ``}``    ``// Find cost for 2nd TIME. */``    ``String s2 = ``""``;``    ``if` `(target_minute2 != ``0``)``      ``s2 += Integer.toString(target_minute2);``    ``if` `(target_sec2 < ``10` `&& target_minute2 != ``0``) {``      ``s2 += ``'0'``;``    ``}``    ``s2 += Integer.toString(target_sec2);``    ``int` `temp2 = startAt;``    ``int` `ans2 = ``0``;``    ``for` `(``int` `i = ``0``; i < s2.length(); i++) {``      ``int` `x = s2.charAt(i);``      ``if` `(x != temp2) {``        ``ans2 += moveCost;``        ``ans2 += pushCost;``        ``temp2 = x;``      ``}``      ``else` `{``        ``ans2 += pushCost;``        ``temp2 = x;``      ``}``    ``}` `    ``// Returning the minimum of the two cost.``    ``return` `Math.min(ans, ans2);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `A = ``1``, B = ``5``, N = ``300``;` `    ``// Function call``    ``int` `ans = minCostTime(A, B, N);``    ``System.out.print(ans);``  ``}``}` `// This code is contributed by Taranpreet`

## Python3

 `# Python program to implement the above approach` `# Function to get the minimum time``def` `minCostTime(moveCost, pushCost, targetSeconds):` `    ``# Setting startAt to -1 as``    ``# nothing is pressed earlier``    ``# This variable shows last pressed button``    ``startAt ``=` `-``1` `    ``# Its the first timing which can be set``    ``target_minute ``=` `targetSeconds ``/``/` `60``    ``target_sec ``=` `targetSeconds ``%` `60` `    ``# If time is greater than 99 min``    ``# and 60 sec then first time would come``    ``# somewhere in 100 min``    ``# which would actually be wrong.``    ``# as max min can be 99 only.``    ``if` `(target_minute > ``99``):``        ``target_minute ``=` `target_minute ``-` `1``        ``target_sec ``=` `60` `+` `target_sec` `    ``# Its the variables for``    ``# second timing possible``    ``target_sec2 ``=` `0``    ``target_minute2 ``=` `target_minute ``-` `1` `    ``# Second timing is only possible``    ``# if first timing minute is``    ``# greater than zero and second``    ``# is less than 40 because``    ``# x mins and y seconds will be converted``    ``# to x-1 mins and 60 + y secs``    ``# and max seconds can be 99``    ``if` `(target_sec < ``40` `and` `target_minute !``=` `0``):``        ``target_minute2 ``=` `target_minute ``-` `1``        ``target_sec2 ``=` `60` `+` `target_sec` `    ``# Convert 1st minute to optimal string``    ``s ``=` `""` `    ``# Append  min only if min > 0``    ``# else, will be prepended automatically.``    ``if` `(target_minute > ``0``):``        ``s ``=` `s ``+` `str``(target_minute)` `    ``# If seconds is 1 digit number``    ``# then a 0 needs to be added before it``    ``if` `(target_sec < ``10` `and` `target_minute !``=` `0``):``        ``s ``=` `s ``+` `'0'` `    ``s ``=` `s ``+` `str``(target_sec)` `    ``# Calculate cost for 1st TIME.``    ``temp ``=` `startAt``    ``ans ``=` `0``    ``for` `i ``in` `range``(``0``, ``len``(s)):``        ``x ``=` `ord``(s[i])``        ``if` `(x !``=` `temp):``            ``ans ``=` `ans ``+` `moveCost``            ``ans ``=` `ans ``+` `pushCost``            ``temp ``=` `x` `        ``else``:``            ``ans ``=` `ans ``+` `pushCost``            ``temp ``=` `x` `    ``if` `(target_sec >``=` `40` `or` `target_minute ``=``=` `0``):``        ``return` `ans` `    ``# Find cost for 2nd TIME. */``    ``s2 ``=` `""``    ``if` `(target_minute2 !``=` `0``):``        ``s2 ``=` `s2 ``+` `str``(target_minute2)``    ``if` `(target_sec2 < ``10` `and` `target_minute2 !``=` `0``):``        ``s2 ``=` `s2 ``+` `'0'` `    ``s2 ``=` `s2 ``+` `str``(target_sec2)``    ``temp2 ``=` `startAt``    ``ans2 ``=` `0``    ``for` `i ``in` `range``(``0``, ``len``(s2)):``        ``x ``=` `ord``(s2[i])` `        ``if` `(x !``=` `temp2):``            ``ans2 ``=` `ans2 ``+` `moveCost``            ``ans2 ``=` `ans2 ``+` `pushCost``            ``temp2 ``=` `x` `        ``else``:``            ``ans2 ``=` `ans2 ``+` `pushCost``            ``temp2 ``=` `x` `    ``# Returning the minimum of the two cost.``    ``return` `min``(ans, ans2)` `# Driver code``A ``=` `1``B ``=` `5``N ``=` `300` `# Function call``ans ``=` `minCostTime(A, B, N)``print``(ans)` `# This code is contributed by Taranpreet`

## C#

 `using` `System;``class` `GFG``{` `  ``// Function to get the minimum time``  ``static` `int` `minCostTime(``int` `moveCost,``                         ``int` `pushCost,``                         ``int` `targetSeconds)``  ``{` `    ``// Setting startAt to -1 as``    ``// nothing is pressed earlier``    ``// This variable shows last pressed button``    ``int` `startAt = -1;` `    ``// Its the first timing which can be set``    ``int` `target_minute = targetSeconds / 60;``    ``int` `target_sec = targetSeconds % 60;` `    ``// If time is greater than 99 min``    ``// and 60 sec then first time would come``    ``// somewhere in 100 min``    ``// which would actually be wrong.``    ``// as max min can be 99 only.``    ``if` `(target_minute > 99) {``      ``target_minute = target_minute - 1;``      ``target_sec = 60 + target_sec;``    ``}` `    ``// Its the variables for``    ``// second timing possible``    ``int` `target_sec2 = 0;``    ``int` `target_minute2 = target_minute - 1;` `    ``// Second timing is only possible``    ``// if first timing minute is``    ``// greater than zero and second``    ``// is less than 40 because``    ``// x mins and y seconds will be converted``    ``// to x-1 mins and 60 + y secs``    ``// and max seconds can be 99``    ``if` `(target_sec < 40 && target_minute != 0) {``      ``target_minute2 = target_minute - 1;``      ``target_sec2 = 60 + target_sec;``    ``}` `    ``// Convert 1st minute to optimal string``    ``string` `s = ``""``;` `    ``// Append min only if min > 0``    ``// else, will be prepended automatically.``    ``if` `(target_minute > 0)``      ``s += target_minute.ToString();;` `    ``// If seconds is 1 digit number``    ``// then a 0 needs to be added before it``    ``if` `(target_sec < 10 && target_minute != 0) {``      ``s += ``'0'``;``    ``}``    ``s += target_sec.ToString();;` `    ``// Calculate cost for 1st TIME.``    ``int` `temp = startAt;``    ``int` `ans = 0;``    ``for` `(``int` `i = 0; i < s.Length; i++) {``      ``int` `x = s[i];``      ``if` `(x != temp) {``        ``ans += moveCost;``        ``ans += pushCost;``        ``temp = x;``      ``}``      ``else` `{``        ``ans += pushCost;``        ``temp = x;``      ``}``    ``}``    ``if` `(target_sec >= 40 || target_minute == 0) {``      ``return` `ans;``    ``}` `    ``// Find cost for 2nd TIME. */``    ``string` `s2 = ``""``;``    ``if` `(target_minute2 != 0)``      ``s2 += target_minute2.ToString();;``    ``if` `(target_sec2 < 10 && target_minute2 != 0) {``      ``s2 += ``'0'``;``    ``}``    ``s2 += target_sec2.ToString();;``    ``int` `temp2 = startAt;``    ``int` `ans2 = 0;``    ``for` `(``int` `i = 0; i < s2.Length; i++) {``      ``int` `x = s2[i];``      ``if` `(x != temp2) {``        ``ans2 += moveCost;``        ``ans2 += pushCost;``        ``temp2 = x;``      ``}``      ``else` `{``        ``ans2 += pushCost;``        ``temp2 = x;``      ``}``    ``}` `    ``// Returning the minimum of the two cost.``    ``return` `Math.Min(ans, ans2);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `A = 1, B = 5, N = 300;` `    ``// Function call``    ``int` `ans = minCostTime(A, B, N);``    ``Console.Write(ans);``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`17`

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

My Personal Notes arrow_drop_up