3280. Convert Date to Binary

EasyMathString

Problem Description

Given a string date representing a Gregorian calendar date in the yyyy-mm-dd format, the task is to convert this date into its binary representation. Each component of the date (year, month, and day) should be converted to its binary format without any leading zeroes. The final result should be a string that concatenates the binary representations of the year, month, and day, separated by hyphens.

Intuition

To solve the problem, we start by splitting the date string date into its individual components: year, month, and day. This is done using the split("-") function, which conveniently divides the string into segments based on the hyphen separator. Next, each component is converted from a string to an integer. Once the integer value is obtained, it's transformed into its binary representation using the bin() function, which is further formatted to remove the '0b' prefix using string formatting (f"{int(s):b}"). Finally, the binary strings for the year, month, and day are joined together with hyphens to create the final output in the required year-month-day binary format.

Learn more about Math patterns.

Solution Approach

The solution employs a straightforward simulation approach to convert the date into its binary format. Here's a detailed walk-through of the steps:

Splitting the Date String: Start by splitting the input string date using the hyphen - as the delimiter. This separates the string into three components: year, month, and day.
```
date.split("-")
```
Conversion to Binary: Iterate over each part of the split string. Convert each segment (year, month, and day) from a string to an integer and then to its binary representation. This is done using the formula f"{int(s):b}", which employs Python's formatted string literal to convert the integer to a binary string without the 0b prefix.
```
f"{int(s):b}" for s in date.split("-")
```
Joining the Parts: Concatenate the binary representations of year, month, and day with hyphens as separators using the join function. This results in a final string output that matches the required format.
```
"-".join(f"{int(s):b}" for s in date.split("-"))
```

Each step is efficiently executed with constant space usage since we are only manipulating a few strings and integers, making this approach both simple and effective for the problem at hand.

Ready to land your dream job?

Unlock your dream job with a 2-minute evaluator for a personalized learning plan!

Start Evaluator

Example Walkthrough

Let's walk through an example using the date 2023-09-21.

Splitting the Date String: The input date string 2023-09-21 is split using the hyphen - as the delimiter. This results in three parts:

Year: "2023"
Month: "09"
Day: "21"

parts = date.split("-")  # parts becomes ['2023', '09', '21']

Conversion to Binary: Each component (year, month, and day) is converted from a string to an integer. Then, it is transformed into binary:

Convert and format the year:

year_binary = f"{int(parts[0]):b}"  # year_binary becomes '11111100111'

Convert and format the month:

month_binary = f"{int(parts[1]):b}"  # month_binary becomes '1001'

Convert and format the day:

day_binary = f"{int(parts[2]):b}"  # day_binary becomes '10101'

Joining the Parts: Concatenate the binary representations with hyphens to form the final output string:

result = "-".join([year_binary, month_binary, day_binary])  # result becomes '11111100111-1001-10101'

Thus, the binary representation of the date 2023-09-21 is 11111100111-1001-10101.

Solution Implementation

1class Solution:
2    def convertDateToBinary(self, date: str) -> str:
3        # Split the date string into three components: year, month, day.
4        date_parts = date.split("-")
5      
6        # Convert each component to an integer and then to a binary string.
7        # Use a generator expression to iterate over each part.
8        binary_parts = (f"{int(part):b}" for part in date_parts)
9      
10        # Join the binary strings with a hyphen to create the final result.
11        binary_date = "-".join(binary_parts)
12      
13        # Return the binary date string.
14        return binary_date
15

1import java.util.ArrayList;
2import java.util.List;
3
4class Solution {
5    // Method to convert date in "yyyy-mm-dd" format to binary representation
6    public String convertDateToBinary(String date) {
7        // Create a list to store the binary strings
8        List<String> binaryParts = new ArrayList<>();
9      
10        // Split the date string by "-"
11        for (String part : date.split("-")) {
12            // Parse each part of the date string into an integer
13            int number = Integer.parseInt(part);
14            // Convert the integer to its binary representation as a string
15            binaryParts.add(Integer.toBinaryString(number));
16        }
17      
18        // Join the binary parts with "-" and return the result
19        return String.join("-", binaryParts);
20    }
21}
22

1#include <string>
2#include <bitset>
3
4class Solution {
5public:
6    // Convert the given date string in the format YYYY-MM-DD to binary representation.
7    std::string convertDateToBinary(std::string date) {
8        // Lambda function to convert part of the date to binary.
9        auto convertToBinary = [](std::string s) -> std::string {
10            // Convert the string to an integer and then to a 32-bit binary string.
11            std::string binaryString = std::bitset<32>(std::stoi(s)).to_string();
12            // Trim leading zeros to get the compact binary representation.
13            return binaryString.substr(binaryString.find('1'));
14        };
15
16        // Convert the year, month, and day separately to binary and concatenate with hyphens.
17        std::string yearBinary = convertToBinary(date.substr(0, 4));
18        std::string monthBinary = convertToBinary(date.substr(5, 2));
19        std::string dayBinary = convertToBinary(date.substr(8, 2));
20
21        // Return the full binary date in YYYY-MM-DD format.
22        return yearBinary + "-" + monthBinary + "-" + dayBinary;
23    }
24};
25

1/**
2 * Converts a date in 'yyyy-mm-dd' format to a binary string.
3 * Each date component (year, month, day) is converted to a binary representation.
4 * Components are then joined with a dash ('-').
5 * 
6 * @param date - The date string in 'yyyy-mm-dd' format.
7 * @returns The converted date as a binary string.
8 */
9function convertDateToBinary(date: string): string {
10    // Split the date string into its components using '-' as a delimiter.
11    // Convert each component to a number and then to binary using .toString(2)
12    // Join the binary components with '-' and return the result.
13    return date
14        .split('-')
15        .map(datePart => Number(datePart).toString(2))
16        .join('-');
17}
18
19// Example usage:
20// const binaryDate = convertDateToBinary('2023-04-15');
21// console.log(binaryDate); // Sample output: "11111100111-100-1111"
22

Time and Space Complexity

The time complexity is O(n), and the space complexity is O(n). Here, n is the length of the string date.

Learn more about how to find time and space complexity quickly.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:

Question 1 out of 10

Which algorithm should you use to find a node that is close to the root of the tree?

Depth First Search

Breadth First Search

I don’t know