# 401 Binary Watch

### Problem:

A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59). ![](/files/HFsXDDACGEUSRx97V0X3) Each LED represents a zero or one, with the least significant bit on the right.

For example, the above binary watch reads "3:25".

Given a non-negative integer n which represents the number of LEDs that are currently on, return all possible times the watch could represent.

Example:

```
Input: n = 1
Return: ["1:00", "2:00", "4:00", "8:00", "0:01", "0:02", "0:04", "0:08", "0:16", "0:32"]
```

Note:

* The order of output does not matter.
* The hour must not contain a leading zero, for example "01:00" is not valid, it should be "1:00".
* The minute must be consist of two digits and may contain a leading zero, for example "10:2" is not valid, it should be "10:02".

### Solutions:

```java
public class Solution {
    public List<String> readBinaryWatch(int num) {
        boolean[] watch = new boolean[10];
        int[] vals = new int[]{8, 4, 2, 1, 32, 16, 8, 4, 2, 1};
        List<String> result = new LinkedList<String>();
        process(num, 0, watch, vals, result);
        return result;
    }
    private void process(int left, int start, boolean[] watch, int[] vals, List<String> result) {
        if (left == 0) {
            int hour = 0;
            for (int i = 0; i < 4; i ++) {
                if (watch[i] == true) {
                    hour += vals[i];
                }
            }
            if (hour >= 12) {
                return;
            }
            int min = 0;
            for (int i = 4; i < 10; i ++) {
                if (watch[i] == true) {
                    min += vals[i];
                }
            }
            if (min >= 60) {
                return;
            }
            String time = hour + ":";
            if (min < 10) {
                time += "0";
            }
            time +=min;
            result.add(0, time);
            return;
        }
        for (int i = start; i< watch.length; i ++) {
            watch[i] = true;
            process(left - 1, i + 1, watch, vals, result);
            watch[i] = false;
        }
    }
}
```

```java
public class Solution {
    public List<String> readBinaryWatch(int num) {
        List<String> result = new ArrayList<String>();
     
        for(int i=0; i<12; i++){
            for(int j=0; j<60; j++){
                int total = countDigits(i)+countDigits(j);
                if(total==num){
                    String s="";
                    s+=i+":";
     
                    if(j<10){
                        s+="0"+j;
                    }else{
                        s+=j;
                    }
     
                    result.add(s);
                }
            }
        }
 
        return result;
    }
     
    public int countDigits(int num){
        int result=0;
     
        while(num>0){
            if((num&1)==1){
                result++;
            }
     
            num>>=1;
        }
     
        return result;
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ugopireddy.gitbook.io/leet-code-solutions/solutions-401-450/401-binary-watch.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.