Problem Description

This problem asks you to convert a date from one format to another.

You're given a date string in the format Day Month Year, where:

• Day is a number with an ordinal suffix like "1st", "2nd", "3rd", "4th", "5th", ..., "30th", "31st"
• Month is a three-letter abbreviation: "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", or "Dec"
• Year is a 4-digit number between 1900 and 2100

Your task is to convert this date string into the ISO format YYYY-MM-DD, where:

• YYYY is the 4-digit year
• MM is the 2-digit month (with leading zero if needed, like "01" for January)
• DD is the 2-digit day (with leading zero if needed, like "05" for the 5th)

For example:

• Input: "20th Oct 2052" → Output: "2052-10-20"
• Input: "6th Jun 1933" → Output: "1933-06-06"
• Input: "26th May 1960" → Output: "1960-05-26"

The solution works by:

1. Splitting the input string into its three components
2. Reversing the order to get [Year, Month, Day]
3. Converting the month abbreviation to its numeric value (Jan=01, Feb=02, etc.) using string indexing
4. Removing the ordinal suffix from the day (like "20th" → "20") and padding with zeros if needed
5. Joining the components with hyphens to form the final date string

Intuition

The key insight is that we need to transform three pieces of information from one format to another. The input format is human-readable but inconsistent (ordinal numbers, month names), while the output format is standardized and sortable (numeric values with fixed widths).

We can break down the transformation into three independent conversions:

1. The year is already in the correct format - we just need to reposition it
2. The month needs to be mapped from text to a number
3. The day needs its suffix removed and zero-padding added

Since the output format is YYYY-MM-DD and the input is Day Month Year, we notice the order is reversed. This suggests we can split the string, reverse the components, and then process each part.

For the month conversion, instead of using a dictionary or multiple if-statements, we can leverage a clever string indexing technique. By creating a string " JanFebMarAprMayJunJulAugSepOctNovDec" where each month abbreviation occupies exactly 3 characters, we can find any month's position using index() and divide by 3 to get its month number. The leading space ensures January maps to index 3, which divided by 3 gives us 0, so adding 1 gives us month 1.

For the day, we observe that all ordinal suffixes ("st", "nd", "rd", "th") are exactly 2 characters long. So we can simply slice off the last 2 characters using [:-2] to get the numeric part.

The zfill() method elegantly handles the zero-padding requirement for both month and day, ensuring single-digit values become two digits (e.g., "6" becomes "06").

Solution Approach

Let's walk through the implementation step by step:

1. Split the input string: We use date.split() to break the input into three components. For example, "20th Oct 2052" becomes ["20th", "Oct", "2052"].

2. Reverse the array: Since we need to output YYYY-MM-DD but receive Day Month Year, we reverse the array using s.reverse(). Our array ["20th", "Oct", "2052"] becomes ["2052", "Oct", "20th"].

3. Convert month to number: We create a lookup string months = " JanFebMarAprMayJunJulAugSepOctNovDec". Each month abbreviation occupies exactly 3 characters in this string:

   • The space at the beginning is crucial for proper indexing
   • s[1] contains the month abbreviation (e.g., "Oct")
   • months.index(s[1]) finds the starting position of the month (e.g., "Oct" is at index 27)
   • Dividing by 3 gives us the month's zero-based index: 27 // 3 = 9
   • Adding 1 converts to 1-based month numbering: 9 + 1 = 10
   • zfill(2) ensures two digits: "10" stays "10", but "6" becomes "06"

4. Process the day:

   • s[2] contains the day with its ordinal suffix (e.g., "20th")
   • s[2][:-2] removes the last 2 characters to get just the number ("20")
   • zfill(2) adds a leading zero if needed ("5" becomes "05")

5. Join with hyphens: Finally, "-".join(s) combines the three components with hyphens as separators, producing the desired format "2052-10-20".

The entire solution is elegant and concise, avoiding complex conditionals or mappings by using string manipulation techniques effectively.

Example Walkthrough

Let's trace through the solution with the input "6th Jun 1933":

Step 1: Split the input string

• Input: "6th Jun 1933"
• After splitting: ["6th", "Jun", "1933"]

Step 2: Reverse the array

• Before: ["6th", "Jun", "1933"]
• After reversing: ["1933", "Jun", "6th"]
• Now we have: s[0] = "1933", s[1] = "Jun", s[2] = "6th"

Step 3: Process the year (s[0])

• The year "1933" is already in the correct 4-digit format
• No conversion needed

Step 4: Convert month to number (s[1])

• We have the lookup string: " JanFebMarAprMayJunJulAugSepOctNovDec"
• Find "Jun" in this string: it starts at index 15
  • Position 0: " " (space)
  • Position 1-3: "Jan"
  • Position 4-6: "Feb"
  • Position 7-9: "Mar"
  • Position 10-12: "Apr"
  • Position 13-15: "May"
  • Position 16-18: "Jun" ← Found at index 15
• Calculate month number: 15 // 3 = 5, then add 1 → month = 6
• Apply zfill(2): "6" becomes "06"
• Replace s[1] with "06"

Step 5: Process the day (s[2])

• Start with "6th"
• Remove last 2 characters: "6th"[:-2] = "6"
• Apply zfill(2): "6" becomes "06"
• Replace s[2] with "06"

Step 6: Join with hyphens

• Array is now: ["1933", "06", "06"]
• Join with "-": "1933-06-06"

Final Output: "1933-06-06"

Solution Implementation

Time and Space Complexity

Time Complexity: O(1)

The time complexity is constant because:

• date.split() splits the string into exactly 3 parts (day, month, year), which takes O(1) time since the input format is fixed
• s.reverse() reverses a list of 3 elements, which is O(1)
• months.index(s[1]) searches for a month abbreviation in a fixed-size string of 36 characters, which is O(1)
• Integer division, addition, and str() conversion are all O(1) operations
• zfill(2) pads strings to at most 2 characters, which is O(1)
• String slicing s[2][:-2] removes the last 2 characters from a fixed-length string, which is O(1)
• "-".join(s) joins exactly 3 strings, which is O(1)

Space Complexity: O(1)

The space complexity is constant because:

• s is a list containing exactly 3 string elements regardless of input
• The months string is a fixed constant of 36 characters
• Temporary strings created during operations (str(), zfill(), slicing) are all bounded by constant size
• The final joined string has a fixed format "YYYY-MM-DD" with constant length

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

Common Pitfalls

1. Incorrect Month Index Calculation

A common mistake is forgetting why the space at the beginning of the month lookup string is necessary. Without it, the index calculation breaks:

Incorrect:

month_lookup = "JanFebMarAprMayJunJulAugSepOctNovDec"  # No leading space
month_index = month_lookup.index(date_parts[1])
month_number = month_index // 3 + 1  # Wrong calculation!

For "Jan", the index would be 0, giving 0 // 3 + 1 = 1 (correct by chance), but for "Feb", the index would be 3, giving 3 // 3 + 1 = 2 (correct), but "Mar" at index 6 gives 6 // 3 + 1 = 3 (should be 3, correct). However, without proper alignment, later months fail.

Correct approach: Include the leading space so each month starts at a position divisible by 3.

2. Assuming Fixed Day Suffix Length

The code uses [:-2] to remove the suffix, which works for "st", "nd", "rd", "th". However, if you accidentally try to handle the suffix differently or forget that all suffixes are exactly 2 characters, you might write:

Incorrect:

# Trying to be clever with suffix detection
if date_parts[2].endswith("st"):
    day_number = date_parts[2][:-2]
elif date_parts[2].endswith("nd"):
    day_number = date_parts[2][:-2]
# ... unnecessary complexity

Better: Simply use [:-2] since all ordinal suffixes in this problem are exactly 2 characters long.

3. Forgetting to Pad Single-Digit Values

Without zfill(2), single-digit days and months won't have leading zeros:

Incorrect:

date_parts[1] = str(month_number)  # "6" instead of "06"
date_parts[2] = date_parts[2][:-2]  # "5" instead of "05"

This would produce "1933-6-6" instead of "1933-06-06".

Solution: Always use zfill(2) to ensure two-digit formatting for both month and day.

4. Using Dictionary When String Indexing Suffices

While a dictionary works, it's overkill for this problem:

Overcomplicated:

month_map = {"Jan": "01", "Feb": "02", "Mar": "03", ...}
date_parts[1] = month_map[date_parts[1]]

Better: The string indexing approach is more elegant and requires less code, though the dictionary approach is arguably more readable for some developers.