Add datetime tricky card!

Author: Anass Rach

datetime.md

@@ -254,6 +254,93 @@ dates.stream()
 
 ---
 
+## 🃏 Daylight Saving Time "Fall Back" Calculations
+
+**Rule:** When DST ends ("fall back"), the **same local time occurs twice**, creating a 25-hour day where time calculations must account for the repeated hour.
+
+**Timeline Visualization for November 5, 2023 DST End in America/Chicago:**
+
+```
+Regular Timeline:          DST "Fall Back" Timeline:
+12:00 AM ──────────────►   12:00 AM ──────────────►
+01:00 AM ──────────────►   01:00 AM ──────────────►
+02:00 AM ──────────────►   02:00 AM (first occurrence) ──┐
+03:00 AM ──────────────►                                  │ Clock jumps back
+04:00 AM ──────────────►   01:00 AM (after fall back) ──┘
+                           02:00 AM (second occurrence) ──►
+                           03:00 AM ──────────────►
+```
+
+**The Problem:** When calculating time between 3:00 AM and 1:00 AM on DST end day:
+
+```java
+import java.time.*;
+import java.time.temporal.ChronoUnit;
+
+// DST ends November 5, 2023 at 2:00 AM in America/Chicago
+// Clock "falls back" from 2:00 AM to 1:00 AM
+
+LocalDateTime morning = LocalDateTime.of(2023, Month.NOVEMBER, 5, 3, 0);    // 3:00 AM
+ZonedDateTime chicagoMorning = ZonedDateTime.of(morning, ZoneId.of("America/Chicago"));
+
+LocalDateTime early = LocalDateTime.of(2023, Month.NOVEMBER, 5, 1, 0);      // 1:00 AM  
+ZonedDateTime chicagoEarly = ZonedDateTime.of(early, ZoneId.of("America/Chicago"));
+
+long hoursBetween = ChronoUnit.HOURS.between(chicagoMorning, chicagoEarly);
+System.out.println("Hours from 3:00 AM to 1:00 AM: " + hoursBetween);  // -2
+```
+
+**Why the result is -2:**
+
+**Step-by-step timeline:**
+1. **3:00 AM** (starting point)
+2. Go back 1 hour → **2:00 AM** (second occurrence, after fall back)
+3. Go back 1 more hour → **1:00 AM** (after the repeated hour)
+
+**Total:** 2 hours backward = **-2**
+
+**The Key Insight:** 
+- From 3:00 AM to 1:00 AM normally would be -2 hours
+- On DST "fall back" day, there's an extra hour (1:00-2:00 AM occurs twice)
+- ZonedDateTime automatically picks the **later occurrence** (after fall back)
+- So we still need -2 hours to go from 3:00 AM to the 1:00 AM that comes after the time change
+
+**Extended example with different times:**
+```java
+// DST ends March 26, 2023 at 3:00 AM in Europe/Berlin (falls back to 2:00 AM)
+LocalDateTime breakfast = LocalDateTime.of(2023, Month.MARCH, 26, 4, 30);   // 4:30 AM
+ZonedDateTime berlinBreakfast = ZonedDateTime.of(breakfast, ZoneId.of("Europe/Berlin"));
+
+LocalDateTime midnight = LocalDateTime.of(2023, Month.MARCH, 26, 2, 15);    // 2:15 AM
+ZonedDateTime berlinMidnight = ZonedDateTime.of(midnight, ZoneId.of("Europe/Berlin"));
+
+long minutesDiff = ChronoUnit.MINUTES.between(berlinBreakfast, berlinMidnight);
+System.out.println("Minutes from 4:30 AM to 2:15 AM: " + minutesDiff);    // -195
+
+// Breakdown: 4:30 AM → 2:15 AM = -2 hours 15 minutes = -135 minutes
+// But DST adds an extra hour, so -135 - 60 = -195 minutes
+```
+
+**Visual Timeline for the Calculation:**
+```
+DST End Day (25-hour day):
+├─ 12:00 AM
+├─ 01:00 AM  
+├─ 02:00 AM (first time) ──┐
+├─ 02:00 AM (repeated)    ──┘ ← Extra hour here!
+├─ 02:15 AM (our target) ────────┐
+├─ 03:00 AM                      │
+├─ 04:00 AM                      │ 195 minutes difference
+└─ 04:30 AM (our start) ────────┘
+```
+
+**💡 Learning Tip:** Remember "FALL BACK = EXTRA HOUR" - When DST ends, one hour is repeated (1:00-2:00 AM happens twice), making time calculations longer than expected.
+
+**Q:** On DST end day, if you calculate hours between 4:00 AM and 2:00 AM, why might the result be -3 instead of -2?  
+**A:** Because the 2:00 AM hour occurs twice on DST end day. Going from 4:00 AM to 2:00 AM crosses the repeated hour, requiring an extra hour: 4→3→2(first)→2(repeated) = 3 hours backward = -3.
+
+---
+
 ## 🃏 Localization - Locale and Resource Bundles
 
 **Rule:** Localization uses **Locale** for region/language and **ResourceBundle** for externalized text.