 GFG App
Open App Browser
Continue

# Count how many times the given digital clock shows identical digits

Given a generic digital clock, having h number of hours and m number of minutes, the task is to find how many times the clock shows identical time. A specific time is said to be identical if every digit in the hours and minutes is same i.e. the time is of type D:D, D:DD, DD:D or DD:DD
Note that the time is written on the digital clock without any leading zeros and the clock shows time between 0 to h – 1 hours and 0 to m – 1 minutes. Few examples of identical times are:

• 1:1
• 22:22
• 3:33
• 11:1

Examples:

Input: hours = 24, minutes = 60
Output: 19
The clock has 24 hours and 60 minutes.
So the identical times will be:
Single digit hours and single digit minutes -> 0:0, 1:1, 2:2, …., 9:9
Single digit hours and double digit minutes -> 1:11, 2:22, 3:33, 4:44 and 5:55
Double digit hours and single digit minutes -> 11:1 and 22:2
Double digit hours and double digit minutes -> 11:11, 22:22
Total = 10 + 5 + 2 + 2 = 19
Input: hours = 34, minutes = 50
Output: 20

Approach: As we can see in the explained example, we have to first count the single-digit (of hours) identical times and then double-digit hours. During each of these counts, we need to consider single-digit minutes as well as double-digit minutes.
There will be two loops. First loop deals with single-digit hours. And the second deals with double-digit hours. In each of the loops, there should be two conditions. First, if the iterator variable is less than total minutes, then increment the counter. Second, if (iterator variable + iterator variable * 10) is less than total minutes, increment the counter. In the end, we will have the total identical times that clock shows.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to return the count of` `// identical times the clock shows` `int` `countIdentical(``int` `hours, ``int` `minutes)` `{`   `    ``// To store the count of identical times` `    ``// Initialized to 1 because of 0:0` `    ``int` `i, count = 1;`   `    ``// For single digit hour` `    ``for` `(i = 1; i <= 9 && i < hours; i++) {`   `        ``// Single digit minute` `        ``if` `(i < minutes)` `            ``count++;`   `        ``// Double digit minutes` `        ``if` `((i * 10 + i) < minutes)` `            ``count++;` `    ``}`   `    ``// For double digit hours` `    ``for` `(i = 11; i <= 99 && i < hours; i = i + 11) {`   `        ``// Single digit minute` `        ``if` `((i % 10) < minutes)` `            ``count++;`   `        ``// Double digit minutes` `        ``if` `(i < minutes)` `            ``count++;` `    ``}`   `    ``// Return the required count` `    ``return` `count;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `hours = 24;` `    ``int` `minutes = 60;` `  `  `      ``// Function Call` `    ``cout << countIdentical(hours, minutes);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach` `class` `GFG {`   `    ``// Function to return the count of` `    ``// identical times the clock shows` `    ``static` `int` `countIdentical(``int` `hours, ``int` `minutes)` `    ``{`   `        ``// To store the count of identical times` `        ``// Initialized to 1 because of 0:0` `        ``int` `i, count = ``1``;`   `        ``// For single digit hour` `        ``for` `(i = ``1``; i <= ``9` `&& i < hours; i++) {`   `            ``// Single digit minute` `            ``if` `(i < minutes) {` `                ``count++;` `            ``}`   `            ``// Double digit minutes` `            ``if` `((i * ``10` `+ i) < minutes) {` `                ``count++;` `            ``}` `        ``}`   `        ``// For double digit hours` `        ``for` `(i = ``11``; i <= ``99` `&& i < hours; i = i + ``11``) {`   `            ``// Double digit minutes` `            ``if` `(i < minutes) {` `                ``count++;` `            ``}`   `            ``// Single digit minute` `            ``if` `((i % ``10``) < minutes) {` `                ``count++;` `            ``}` `        ``}`   `        ``// Return the required count` `        ``return` `count;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `hours = ``24``;` `        ``int` `minutes = ``60``;` `      `  `        ``// Function Call` `        ``System.out.println(countIdentical(hours, minutes));` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python 3 implementation of the approach`   `# Function to return the count of` `# identical times the clock shows`     `def` `countIdentical(hours, minutes):`   `    ``# To store the count of identical times` `    ``# Initialized to 1 because of 0:0` `    ``count ``=` `1` `    ``i ``=` `1`   `    ``# For single digit hour` `    ``while``(i <``=` `9` `and` `i < hours):`   `        ``# Single digit minute` `        ``if` `(i < minutes):` `            ``count ``+``=` `1`   `        ``# Double digit minutes` `        ``if` `((i ``*` `10` `+` `i) < minutes):` `            ``count ``+``=` `1`   `        ``i ``+``=` `1`   `    ``# For double digit hours` `    ``i ``=` `11` `    ``while``(i <``=` `99` `and` `i < hours):`   `         ``# Double digit minutes` `        ``if` `(i < minutes):` `            ``count ``+``=` `1`   `        ``# Single digit minute` `        ``if` `((i ``%` `10``) < minutes):` `            ``count ``+``=` `1`   `        ``i ``+``=` `11`   `    ``# Return the required count` `    ``return` `count`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``hours ``=` `24` `    ``minutes ``=` `60` `    `  `    ``# Function Call` `    ``print``(countIdentical(hours, minutes))`   `# This code is contributed by` `# Surendra_Gangwar`

## C#

 `// C# implementation of the above approach` `using` `System;`   `class` `GFG {`   `    ``// Function to return the count of` `    ``// identical times the clock shows` `    ``static` `int` `countIdentical(``int` `hours, ``int` `minutes)` `    ``{`   `        ``// To store the count of identical times` `        ``// Initialized to 1 because of 0:0` `        ``int` `i, count = 1;`   `        ``// For single digit hour` `        ``for` `(i = 1; i <= 9 && i < hours; i++) {`   `            ``// Single digit minute` `            ``if` `(i < minutes) {` `                ``count++;` `            ``}`   `            ``// Double digit minutes` `            ``if` `((i * 10 + i) < minutes) {` `                ``count++;` `            ``}` `        ``}`   `        ``// For double digit hours` `        ``for` `(i = 11; i <= 99 && i < hours; i = i + 11) {`   `            ``// Double digit minutes` `            ``if` `(i < minutes) {` `                ``count++;` `            ``}`   `            ``// Single digit minute` `            ``if` `((i % 10) < minutes) {` `                ``count++;` `            ``}` `        ``}`   `        ``// Return the required count` `        ``return` `count;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int` `hours = 24;` `        ``int` `minutes = 60;` `      `  `        ``// Function Call` `        ``Console.WriteLine(countIdentical(hours, minutes));` `    ``}` `}`   `// This code has been contributed by 29AjayKumar`

## PHP

 ``

## Javascript

 ``

Output

`19`

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

My Personal Notes arrow_drop_up