0785EasyMathString

Days Between Two Stamped Slips

Tracked in this browser only

Trains the technique from

LeetCode 1360Number of Days Between Two Dates

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

An archivist pulls two paper slips out of a box. Each slip carries the date it was stamped, and the archivist wants to know how far apart in whole days the two stampings were.

A stamp is written as YYYY-MM-DD: four digits for the year, a hyphen, two digits for the month, another hyphen, two digits for the day. 1985-04-07 is the seventh of April, 1985.

Given the two stamps slip_a and slip_b, return how many days one stamping was after the other. The slips come out of the box in no particular order, so slip_a may be the later of the two; the answer is never negative. Two slips stamped on the same day are zero days apart, and two slips stamped on consecutive days are one day apart.

Dates follow the Gregorian calendar. Months hold 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 and 31 days in order, except that the second month holds 29 days in a leap year. A year is a leap year when it is divisible by 4, with one exception: a year divisible by 100 is a leap year only when it is also divisible by 400. So 1900 and 2100 are ordinary years while 1600, 2000 and 2400 are leap years.

Examples

Example 1

Input: slip_a = "2024-02-26", slip_b = "2024-03-05"
Output: 8

2024 is divisible by 4 and not by 100, so its second month runs to the 29th. Stepping from 26 February: 27, 28, 29 February, then 1, 2, 3, 4, 5 March, which is eight days.

Example 2

Input: slip_a = "2100-03-01", slip_b = "2100-01-01"
Output: 59

Here `slip_a` is the later stamp and the count is still reported unsigned. 2100 is divisible by 100 but not by 400, so its second month has 28 days: 31 days in the first month plus 28 in the second gets from 1 January to 1 March.

Example 3

Input: slip_a = "1998-11-30", slip_b = "1998-11-30"
Output: 0

Both slips carry the same stamp, so nothing separates them.

Constraints

slip_a.length == 10
slip_b.length == 10
Each stamp is a valid Gregorian date written as YYYY-MM-DD.
Both years lie between 1971 and 2100 inclusive.

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def days_apart(slip_a: str, slip_b: str) -> int:

Java

public int daysApart(String slipA, String slipB)

The intended approach

Time O(1): both stamps are parsed in fixed width and the serial number is arithmetic on a 12-entry table.Space O(1).

Turn each stamp into a single serial day number and take the absolute difference. The serial number is 365 days per elapsed year, plus one for every leap day that has already happened, plus the days in the completed months of the current year from a fixed table, plus the day of the month. Shifting the year back by one for January and February dates places any 29 February at the end of the shifted year, so the leap count is just the usual divisible-by-4, not-by-100, or-by-400 tally on the shifted year.

Pythonentry point: days_apart

def days_apart(slip_a, slip_b):
    # Map each date to a serial day number, then subtract. Counting the leap days
    # that precede a date is easy once the year is shifted back by one for January
    # and February, because that moves the possible 29 February to the very end of
    # the shifted year and out of the way of the month table.
    # Time O(1), space O(1): fixed parsing plus a 12-entry table.
    before = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334)

    def serial(text):
        year = int(text[0:4])
        month = int(text[5:7])
        day = int(text[8:10])
        shifted = year - 1 if month <= 2 else year
        leaps = shifted // 4 - shifted // 100 + shifted // 400
        return 365 * year + leaps + before[month - 1] + day

    return abs(serial(slip_a) - serial(slip_b))

The obvious version

Put the earlier stamp first, then advance it one calendar day at a time, rolling the day into the next month and the month into the next year, until it equals the later stamp. Report how many single-day advances that took.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_days_apart(slip_a, slip_b):
    def parts(text):
        return [int(text[0:4]), int(text[5:7]), int(text[8:10])]

    def leap(year):
        return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

    lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    here = parts(slip_a)
    there = parts(slip_b)
    if here > there:
        here, there = there, here
    walked = 0
    while here != there:
        span = lengths[here[1] - 1]
        if here[1] == 2 and leap(here[0]):
            span += 1
        here[2] += 1
        if here[2] > span:
            here[2] = 1
            here[1] += 1
            if here[1] > 12:
                here[1] = 1
                here[0] += 1
        walked += 1
    return walked

How this problem was checked

Reference solution executed against 15 test cases — 15 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in