fix(collatz): correct step cache corruption in Collatz Conjecture

The memoization cache (steps_cache) was corrupting values due to
including the terminal element (n=1 or a cached value) in the
cache-update loop. This caused double-counting and incorrect step
counts on successive runs.

Fix: use path[:-1] in the cache update loop to exclude the
last path element, which is either 1 (already at cache[1]=0) or
a previously cached value. This keeps cache entries correct.

Fixes: steam-bell-92#835

Author: Siddh2024

math/Collatz-Conjecture/Collatz-Conjecture.py

@@ -6,7 +6,60 @@
 print("  - Continue until you reach 1\n")
 
 MAX_STEPS = 100000
+MAX_VALUE = 10**18
 MAX_INPUT = 10**12
+steps_cache = {1: 0}
+
+
+def collatz_next(n):
+    return n // 2 if n % 2 == 0 else 3 * n + 1
+
+
+def get_remaining_sequence(n):
+    seq = []
+    while n != 1:
+        n = collatz_next(n)
+        seq.append(n)
+    return seq
+
+
+def collatz_sequence(start):
+    if start in steps_cache:
+        n = start
+        yield n
+        while n != 1:
+            n = collatz_next(n)
+            yield n
+        return
+
+    n = start
+    path = [n]
+    steps = 0
+
+    yield n
+
+    while n != 1 and steps < MAX_STEPS:
+        n = collatz_next(n)
+        steps += 1
+
+        if n > MAX_VALUE:
+            print("\n\n⚠ Computation stopped: safety limit reached")
+            break
+
+        yield n
+        path.append(n)
+
+        if n in steps_cache:
+            for remaining in get_remaining_sequence(n):
+                yield remaining
+            steps += steps_cache[n]
+            break
+
+    total = steps_cache.get(n, 0)
+    for value in reversed(path[:-1]):
+        total += 1
+        steps_cache[value] = total
+
 
 while True:
     try:
@@ -22,27 +75,25 @@
         continue
 
     original_number = number
-    sequence = [number]
-    steps = 0
-    max_value = number
 
     print(f"\n🚀 Starting with: {number}")
     print("📊 Sequence:")
-    print(number, end="")
-
-    while number != 1 and steps < MAX_STEPS:
-        if number % 2 == 0:
-            number = number // 2
-        else:
-            number = 3 * number + 1
-            
+
+    sequence = []
+    steps = 0
+    max_value = number
+
+    gen = collatz_sequence(number)
+
+    first = next(gen)
+    print(first, end="")
+    sequence.append(first)
+
+    for num in gen:
+        sequence.append(num)
         steps += 1
-        sequence.append(number)
-        
-        if number > max_value:
-            max_value = number
-            
-        print(f" ➡️ {number}", end="")
+        max_value = max(max_value, num)
+        print(f" ➡️ {num}", end="")
         if steps % 10 == 0:
             print()
 
@@ -65,7 +116,7 @@
                     print(f"  Step {i + 1}: {current} is odd ➡️ ({current} × 3) + 1 = {next_num}")
 
     print("\n🎉 The sequence reached 1 as expected!")
-    
+
     again = input("\n🔄 Do you want to test another number? (y/n): ").strip().lower()
     if again != 'y':
         print("\n👋 Thanks for exploring the Collatz Conjecture! Goodbye!\n")