Computing Idempotent Slices for Code Optimization

🚀𝐃𝐚𝐲 28 / 50 - 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐫𝐨𝐠𝐫𝐞𝐬𝐬 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: 25. Reverse Nodes in k-Group 𝘋𝘪𝘧𝘧𝘪𝘤𝘶𝘭𝘵𝘺: Hard🔴 https://lnkd.in/dP7kh685 We are given the 𝐡𝐞𝐚𝐝 of a linked list and an integer 𝐤. The task is to 𝐫𝐞𝐯𝐞𝐫𝐬𝐞 𝐭𝐡𝐞 𝐧𝐨𝐝𝐞𝐬 𝐨𝐟 𝐭𝐡𝐞 𝐥𝐢𝐬𝐭 𝐢𝐧 𝐠𝐫𝐨𝐮𝐩𝐬 𝐨𝐟 𝐤 and return the modified linked list. Constraint is that we cannot modify the values inside the nodes. Instead, we must rearrange the nodes themselves by changing their pointers within the list. 𝐇𝐨𝐰 𝐈 𝐬𝐨𝐥𝐯𝐞𝐝 𝐢𝐭: I rearranged the nodes by updating their next pointers. I also created a dummy node that points to the head of the list so reconnecting different parts of the list becomes easier. Before reversing any group, I first check whether there are 𝐚𝐭 𝐥𝐞𝐚𝐬𝐭 𝐤 𝐧𝐨𝐝𝐞𝐬 𝐫𝐞𝐦𝐚𝐢𝐧𝐢𝐧𝐠. If fewer than k nodes are left, I stop the process because the last incomplete group should stay as it is. For each valid group, I reverse the nodes using the 𝐭𝐡𝐫𝐞𝐞-𝐩𝐨𝐢𝐧𝐭𝐞𝐫 𝐭𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 and then reconnect the reversed group back to the list. 𝐒𝐭𝐞𝐩𝐬: • Create a dummy node pointing to the head. • Check if the next k nodes exist. • Reverse the k nodes using pointer manipulation. • Reconnect the reversed group with the previous part of the list. • Move forward and repeat for the next group. In the end, the head of the modified list is available at dummy.next, which we return as the final result. 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: O(n) - Linear 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: O(1) - Constant 💻𝐂𝐨𝐝𝐞: https://lnkd.in/diiWz_nR #LeetCode #DSA #ProblemSolving

Day 48/150 LeetCode 912: Sort an Array 🧠 Problem: Given an array of integers nums, sort the array in ascending order. You must solve it without using built-in sort functions and achieve O(n log n) time complexity. 💡 Optimal Idea (Heap Sort): Step 1️⃣ Build a Max Heap from the array. In a max heap, the largest element is always at the root. Step 2️⃣ Swap the root (largest element) with the last element of the heap. Step 3️⃣ Reduce the heap size by 1 and apply heapify to maintain the max heap property. Step 4️⃣ Repeat the process until the heap size becomes 1. 📌 Why This Works? The heap ensures the largest element is always extracted first, placing elements in their correct position from the end of the array. Example: nums = [5,2,3,1] Sorted → [1,2,3,5] ⚡ Time Complexity: O(n log n) ⚡ Space Complexity: O(1) (in-place) Status: Accepted ✅ Runtime: 40 ms #LeetCode #HeapSort #DSA #Algorithms #LeetCode150

public class Test {   public static void main(String[] args) {     final int x;     x = 10;     x = 20;     System.out.println(x);   } } Options: A. 10 B. 20 C. Compilation Error D. Runtime Exception

🚀 LeetCode — Day 13 Solved: LRU Cache Today’s problem was about implementing an LRU (Least Recently Used) Cache with O(1) operations. Key idea: To achieve constant time for both get and put, the solution combines: • Hash Map → quick access to nodes by key • Doubly Linked List → maintain usage order Approach: Most recently used items are moved to the front Least recently used items stay near the tail When capacity is exceeded → remove the tail node Operations handled in O(1): • Access → move node to front • Insert → add to front • Evict → remove from tail This problem is a great example of combining data structures to meet strict time complexity requirements. Day 13. Still showing up. 🔁🔥 #LeetCode #Day13 #DSA #LRUCache #SystemDesignBasics #ProblemSolving #Consistency #Cpp #CodingJourney

Code Is an Information Network | A clip from my Substack post, Using Graph Theory to Understand Software Complexity. Watch it here: https://lnkd.in/eX6PPQGQ

𝐖𝐡𝐚𝐭’𝐬 𝐰𝐫𝐨𝐧𝐠 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐜𝐨𝐝𝐞? Take a look at this simple code: #include <iostream> void allocate(int* ptr) {   ptr = new int(99); } int main() {   int* p = nullptr;   allocate(p);   std::cout << *p;   delete p; } At first glance, it looks like allocate() initializes the pointer p, but deleting the pointer in main() still leads to undefined behavior (likely a crash). But here’s the catch: C++ passes arguments by value by default So inside allocate(), you're modifying a copy of the pointer - not the original. As a result: p in main() remains nullptr How to fix it? Solution is Reference to pointer void allocate(int*& ptr) { ptr = new int(99); } Now p gets updated correctly.

🤔 When analyzing a binary, the Import Address Table (IAT) is one of the first structures typically investigated. It tells you a lot about the program through the libraries and APIs it uses. But even when an import table appears lean, it's still telling you a story—the author may be attempting to be stealthy by performing runtime-linking. In the final video of this series, we take a look at the basics of runtime-linking using the APIs LoadLibrary and GetProcAddress. We’ll dive into: 🛠️ Building an import table on the fly. 🕵️♂️ How this technique intentionally complicates triage-level analysis. 🔍 How string obfuscation goes hand-in-hand with this technique 🧠 https://lnkd.in/gsHMqXnw

public class Test {   public static void main(String[] args) {     List<Integer> list = Arrays.asList(1, 2, 3, 4);     list.stream().filter(i -> i % 2 == 0).map(i -> i * 2);     System.out.println(list);   } } Options: A. [2, 4, 6, 8] B. [1, 2, 3, 4] C. Compilation Error D. Runtime Exception

public class Test {   static {     System.out.print("Static ");   }   public static void main(String[] args) {     System.out.print("Main");   } } Options: A. Main Static B. Static Main C. Compilation Error D. Runtime Exception

public class Test {   public static void main(String[] args) {     for (int i = 0; i < 5; i--) {       System.out.print(i + " ");     }   } } Options: A. 0 1 2 3 4 B. Infinite Loop C. Compilation Error D. Runtime Exception