LeetCode Day 65: Maximum Value After Rotating Array

🚀 #LeetCode Day Problem Solving 🚀 Day-45 📌 Problem: Given an array nums[] 🎯 Define rotation function: 👉 Rotate array k times → arrₖ 👉 Compute: F(k) = 0*arrₖ[0] + 1*arrₖ[1] + ... + (n-1)*arrₖ[n-1] 🎯 Goal: Find the maximum value among all F(k) 🧠 Example: Input: nums = [4,3,2,6] ✅ Output: 26 💡 Key Insight (Most Important 🔥): ✔ Brute force rotation = ❌ O(n²) (too slow) 👉 Instead, use relation between consecutive rotations ⚡ Core Formula: F(k) = F(k-1) + sum(nums) - n \cdot nums[n-k] 🔥 Meaning: ✔ We can compute next rotation using previous one ✔ No need to recompute from scratch ⚡ Approach: 1️⃣ Compute: sum = total sum of array F(0) 2️⃣ Iterate k = 1 → n-1: Use formula to compute F(k) 3️⃣ Track maximum value ⚡ Why it works? ✔ Each rotation shifts elements ✔ Contribution changes in a predictable way 👉 That’s why recurrence works 🚀 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 🧠 What I Learned: ✔ Turning brute force → optimized using math ✔ Rotation problems often have hidden patterns ✔ Importance of deriving recurrence relations ✅ Day 45 Completed 🚀 Leveling up in Array + Mathematical Optimization 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

💡 LeetCode Daily — Problem Solved: Rotate Function (Medium). Today’s problem looked mathematical at first glance… but the real trick was pattern recognition + optimization. At face value, rotating the array and recalculating the function every time feels natural. But that leads straight into an O(n²) trap — not scalable. So I stepped back and asked: 👉 What actually changes when we rotate the array? 🔍 Key Insight (Simple Visualization). Instead of recomputing everything: Each rotation shifts elements, but the total sum stays constant. Only the weight contribution of elements changes. That leads to a powerful relation: Next rotation value can be derived from the previous one using a formula — no need to rebuild from scratch. ⚙️ My Approach Compute initial value F(0) using a loop. Use accumulate() (STL) to get total sum efficiently. Derive next values using a rolling formula. Track maximum along the way. This reduces complexity to O(n) — clean and efficient. 📊 Consistency Snapshot Total active days on LeetCode: 75 Max streak: 68 days 🧠 What I Took Away This problem wasn’t about rotations. It was about: Breaking brute-force thinking. Finding relationships between consecutive states. Trusting math over simulation. Sometimes, optimization isn’t about writing better code — it’s about seeing the problem differently. Still learning. Still refining how I think. #LeetCode #DSA #ProblemSolving #CPP #STL #DailyCoding #Consistency

🚀 LeetCode Day Problem Solving 🚀 Day-89 📌 Problem: Given a binary string s, determine whether you can reach the last index starting from index 0. 👉 You can jump from index i to any index j such that: ✔ i + minJump <= j <= i + maxJump ✔ s[j] == '0' 🧠 Example 1: Input: s = "011010" minJump = 2 maxJump = 3 ✅ Output: true 🔄 Possible Path: 0 → 3 → 5 ✔ Both positions contain '0' 🧠 Example 2: Input: s = "01101110" minJump = 2 maxJump = 3 ❌ Output: false ✔ No valid sequence of jumps can reach the last index. 💡 Key Insight (Very Important 🔥): 👉 From each index, checking every possible jump directly would be too slow ❌ Because: ⚠ Worst case becomes O(n²) ⚡ Optimization Idea: ✔ Use BFS + Sliding Window Instead of repeatedly checking the same range: ✅ Maintain how far we have already processed. This avoids duplicate work. ⚡ Core Idea: For every reachable index i: ✔ Explore indices in range: [i + minJump , i + maxJump] ✔ Only visit positions containing '0' ✔ Avoid revisiting indices 🔥 Why Sliding Window Helps? Without optimization: 👉 Same indices get scanned many times. With sliding window: ✅ Every index is processed only once. So complexity becomes linear. ⚡ Algorithm: 1️⃣ Start BFS from index 0 2️⃣ For every current index: ✔ Compute jump range 3️⃣ Traverse only unvisited positions 4️⃣ If last index is reached → return true 5️⃣ If BFS ends → return false 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ BFS on arrays ✔ Sliding window optimization ✔ Efficient range traversal ✔ Avoiding repeated computations ✅ Day 89 Completed 🚀 Improving in Graphs + BFS + Sliding Window 💪 #Leetcode #coding #learning #CodingChallenge #ProblemSolving #DSA #BFS #SlidingWindow #Graphs #Optimization #MilanSahoo 🚀

🚀 #LeetCode Day Problem Solving 🚀 Day-68 📌 Problem: Given a binary string s, determine whether you can reach the last index starting from index 0. 👉 You can jump from index i to any index j such that: ✔ i + minJump <= j <= i + maxJump ✔ s[j] == '0' 🧠 Example 1: Input: s = "011010" minJump = 2 maxJump = 3 ✅ Output: true 🔄 Possible Path: 0 → 3 → 5 ✔ Both positions contain '0' 🧠 Example 2: Input: s = "01101110" minJump = 2 maxJump = 3 ❌ Output: false ✔ No valid sequence of jumps can reach the last index. 💡 Key Insight (Very Important 🔥): 👉 From each index, checking every possible jump directly would be too slow ❌ Because: ⚠ Worst case becomes O(n²) ⚡ Optimization Idea: ✔ Use BFS + Sliding Window Instead of repeatedly checking the same range: ✅ Maintain how far we have already processed. This avoids duplicate work. ⚡ Core Idea: For every reachable index i: ✔ Explore indices in range: [i + minJump , i + maxJump] ✔ Only visit positions containing '0' ✔ Avoid revisiting indices 🔥 Why Sliding Window Helps? Without optimization: 👉 Same indices get scanned many times. With sliding window: ✅ Every index is processed only once. So complexity becomes linear. ⚡ Algorithm: 1️⃣ Start BFS from index 0 2️⃣ For every current index: ✔ Compute jump range 3️⃣ Traverse only unvisited positions 4️⃣ If last index is reached → return true 5️⃣ If BFS ends → return false 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ BFS on arrays ✔ Sliding window optimization ✔ Efficient range traversal ✔ Avoiding repeated computations ✅ Day 68 Completed 🚀 Improving in Graphs + BFS + Sliding Window 💪 #Leetcode #coding #learning #CodingChallenge #ProblemSolving #DSA #BFS #SlidingWindow #Graphs #Optimization

🚀 #LeetCode Day Problem Solving 🚀 Day-67 📌 Problem: Given an array arr[] and an integer d. From index i, you can jump: 👉 Left or Right up to distance d But only if: ✔ arr[i] > arr[j] ✔ Every element between i and j is also smaller than arr[i] Find the maximum number of indices you can visit. 🧠 Example: Input: arr = [6,4,14,6,8,13,9,7,10,6,12] d = 2 ✅ Output: 4 💡 Key Insight (Very Important 🔥): 👉 From every index, we try all valid jumps But many paths repeat again and again ❌ So we use: ✔ DFS ✔ Memoization (DP) to store already computed answers. ⚡ Core Idea: Let: dp[i] = maximum indices visitable starting from index i For every index: ✔ Try jumping left ✔ Try jumping right ✔ Stop when: distance exceeds d a higher/equal element blocks the path 🔥 Important Observation: You can jump only to strictly smaller values. And once a larger/equal value appears in between: ❌ further jumping in that direction is impossible. ⚡ How DFS Works: From each index: 1️⃣ Explore all valid left jumps 2️⃣ Explore all valid right jumps 3️⃣ Take maximum path length among them 4️⃣ Store result in DP array 🧠 Example Flow: Starting from index 10 → value 12 Possible path: 10 → 8 → 6 → 7 Values: 12 → 10 → 9 → 7 Total visited indices = 4 ⚡ Why Memoization Helps? Without memoization: ❌ Same states recomputed many times With memoization: ✔ Each index solved once only Huge optimization 🚀 📊 Complexity Analysis: ⏱ Time Complexity: O(n × d) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ DFS + DP optimization ✔ Recursive state caching ✔ Valid jump constraints handling ✔ Breaking conditions in traversal ✔ Graph-style thinking on arrays ✅ Day 67 Completed 🚀 Improving in Dynamic Programming & DFS Problems 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🔬 Hamming's Error-Correcting Code (Coding Theory) ✨ Consider how the most powerful tools we rely on began as simple riddles you could pose to a curious mind. Hamming’s query shifted the discipline from merely counting bits to grasping the underlying structure of information, turning error detection into a geometric insight. ✓ 🧮 Richard Hamming asked how many redundant bits are needed to correct a single-bit error in transmitted data. ✓ 📏 He introduced Hamming distance and parity‑check matrices, establishing a systematic binary code correcting single errors. ✓ ♾️ Coding theory now underpins digital communications, data storage, CDs, deep‑space telemetry, and modern error‑correcting protocols. 🟢 Do you enjoy tackling abstract puzzles in your everyday projects? #CodingTheory #ErrorCorrection #DataIntegrity #DigitalCommunication #MathInnovation

🔬 Hamming's Error-Correcting Code (Coding Theory) ✨ Consider how the most powerful tools we rely on began as simple riddles you could pose to a curious mind. Hamming’s query shifted the discipline from merely counting bits to grasping the underlying structure of information, turning error detection into a geometric insight. ✓ 🧮 Richard Hamming asked how many redundant bits are needed to correct a single-bit error in transmitted data. ✓ 📏 He introduced Hamming distance and parity‑check matrices, establishing a systematic binary code correcting single errors. ✓ ♾️ Coding theory now underpins digital communications, data storage, CDs, deep‑space telemetry, and modern error‑correcting protocols. 🟢 Do you enjoy tackling abstract puzzles in your everyday projects? #CodingTheory #ErrorCorrection #DataIntegrity #DigitalCommunication #MathInnovation

🔬 Hamming's Error-Correcting Code (Coding Theory) ✨ Consider how the most powerful tools we rely on began as simple riddles you could pose to a curious mind. Hamming’s query shifted the discipline from merely counting bits to grasping the underlying structure of information, turning error detection into a geometric insight. ✓ 🧮 Richard Hamming asked how many redundant bits are needed to correct a single-bit error in transmitted data. ✓ 📏 He introduced Hamming distance and parity‑check matrices, establishing a systematic binary code correcting single errors. ✓ ♾️ Coding theory now underpins digital communications, data storage, CDs, deep‑space telemetry, and modern error‑correcting protocols. 🟢 Do you enjoy tackling abstract puzzles in your everyday projects? #CodingTheory #ErrorCorrection #DataIntegrity #DigitalCommunication #MathInnovation

🚀 LeetCode Day Problem Solving 🚀 Day-78 📌 Problem: Determine whether the given array is a good array 🔥 A good array must be a permutation of: [base[n] = [1,2,3,...,n-1,n,n]] 👉 Numbers 1 to n-1 appear exactly once 👉 Number n appears exactly twice 🧠 Example: Input: nums = [1,3,3,2] ✅ Output: true Because it is a permutation of: [ [1,2,3,3] ] 💡 Key Insight (Very Important 🔥): 👉 The maximum element determines n If: [max(nums)=n] then array must contain exactly: ✔ numbers 1 → n-1 once ✔ number n twice ⚡ Important Conditions: For a valid good array: 1️⃣ Length must be: [n+1] because base array contains: 👉 n-1 unique numbers 👉 plus two ns 2️⃣ Frequency Rules:** ✔ n occurs exactly 2 times ✔ Every number from 1 to n-1 occurs exactly once ✔ No extra/missing numbers allowed 🔥 Core Idea: 👉 Use frequency counting / hashmap Check all required conditions efficiently ⚡ Algorithm: 1️⃣ Find maximum element n 2️⃣ Check array length == n + 1 3️⃣ Count frequencies 4️⃣ Verify: ✔ freq[n] == 2 ✔ For every 1 → n-1 : [freq[i] = 1] 5️⃣ If all valid → true Else → false 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ Frequency-based validation ✔ Permutation property checking ✔ Simple mathematical observation tricks 🔥 Day 78 Completed! Sometimes easy-looking problems depend entirely on correct observation 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀

🚀 LeetCode Day Problem Solving 🚀 Day-83 📌 Problem: Find the smallest common element present in both sorted arrays 🔥 If no common element exists → return -1 🧠 Example: Input: nums1 = [1,2,3] nums2 = [2,4] ✅ Output: 2 💡 Why? Common elements are: [[2]] Smallest common element = 2 ✅ 💡 Key Insight (Very Important 🔥): 👉 Both arrays are already SORTED ⚡ So instead of brute force checking every pair ❌ We can use: #️⃣ Two Pointer Technique 🚀 ⚡ Core Idea: Maintain pointers: ✔ i for nums1 ✔ j for nums2 Case 1️⃣: If: [nums1[i] = nums2[j]] ✅ Found smallest common element immediately because arrays are sorted 🔥 Case 2️⃣: If: [nums1[i] < nums2[j]] 👉 Move i forward because smaller value cannot match future larger values Case 3️⃣: If: [nums1[i] > nums2[j]] 👉 Move j forward 🧠 Why This Works? Since arrays are sorted: ✔ Once a smaller value is skipped, it can never become useful later So we eliminate unnecessary comparisons efficiently ⚡ ⚡ Algorithm: 1️⃣ Initialize: ✔ i = 0 ✔ j = 0 2️⃣ Traverse both arrays: ✔ If equal → return value ✔ Else move pointer with smaller value 3️⃣ If traversal ends → return -1 🔥 Example Walkthrough: nums1 = [1,2,3,6] nums2 = [2,3,4,5] Step 1: Compare: [1 \text{ and } 2] 1 < 2 👉 Move first pointer Step 2: Compare: [2 \text{ and } 2] ✅ Match found Answer = 2 📊 Complexity Analysis: ⏱ Time Complexity: [O(n+m)] where n and m are array sizes 📦 Space Complexity: O(1) 🧠 What I Learned: ✔ Two Pointer Technique ✔ Efficient traversal of sorted arrays ✔ Avoiding brute force comparisons 🔥 Day 83 Completed! Sorted arrays often unlock elegant linear-time solutions 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀