DEV Community: 睡觉

Remove Element (Easy) | LeetCodePractice #8

睡觉 — Wed, 29 Jul 2026 03:16:27 +0000

Remove Element (LeetCode 27)

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Then return the number of elements k in nums which are not equal to val.

Python

####Pop Elements (Runtime: 0ms, Memory: 12.5MB)
    #DECLARE nums: ARRAY of INTEGER
    #DECLARE val: INTEGER
class Solution(object):
    def removeElement(self, nums, val):
        i = 0
        while i < len(nums):
            if nums[i] == val:
                nums.pop(i)
            else:
                i += 1
        return len(nums)



####Insert to Head (Runtime: 0ms, Memory: 12.4MB)
    #DECLARE nums: ARRAY of INTEGER
    #DECLARE val: INTEGER
class Solution(object):
    def removeElement(self, nums, val):
        head_index = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[head_index] = nums[i]
                head_index += 1
        return head_index

Thoughts

This is basically copy and paste from LeetCode 26!!! Bruh...

Removing Duplicates from a integer list (Easy) | LeetCodePractice #7

睡觉 — Sun, 19 Jul 2026 12:56:21 +0000

Remove Duplicates From Sorted Array (LeetCode 26)

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same. Consider the number of unique elements in nums to be k. After removing duplicates, return the number of unique elements k.

The first k elements of nums should contain the unique numbers in sorted order. The remaining elements beyond index k - 1 can be ignored.

Python

####Pop Elements(Runtime: 57ms, Memory: 13MB)
    #DECLARE nums: ARRAY of INTEGER
class Solution(object):
    def removeDuplicates(self, nums):
        i = 1
        while i < len(nums):
            if nums[i] == nums[i-1]:
                nums.pop(i)
            else:
                i += 1
        return len(nums)



####Insert to Head(Runtime: 7ms, Memory: 13.7MB)
    #DECLARE nums: ARRAY of INTEGER
class Solution(object):
    def removeDuplicates(self, nums):
        head_pointer = 1
        for i in range(1, len(nums)):
            if nums[i] != nums[i-1]:
                nums[head_pointer] = nums[i]
                head_pointer += 1
        return head_pointer

Thoughts

The question is simple. The only catch: we need to accept that the array can become messy, because after moving the unique elements to the front, anything after index k will be unorganized. However, since the question already states that "anything beyond index k-1 will not be considered", I think LeetCode is hinting at this approach.

Merge Two Link Lists (Easy) | LeetCodePractice #6

睡觉 — Tue, 14 Jul 2026 06:12:15 +0000

Merge Two Sorted Lists (LeetCode 21)

You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list. Both lists are sorted in non-decreasing order. Return the merged linked list.

The linked list is implemented through the class ListNode, which has default attributes val = 0 and next = None. Note that the attribute next stores a node rather than its index.

Python

####Sort as Whole (Runtime: 0ms, Memory: 12.5MB)
    #DECLARE ListNode: Class(val: 0, next: None)
    #DECLARE list1: ARRAY of ListNode
    #DECLARE list2: ARRAY of ListNode
class Solution(object):
    def mergeTwoLists(self, list1, list2):
        whole_link = ListNode(0)
        current = whole_link
        while list1 and list2:
            if list1.val < list2.val:
                current.next = list1
                list1 = list1.next
            else:
                current.next = list2
                list2 = list2.next
            current = current.next
        if list1:
            current.next = list1
        else:
            current.next = list2
        return whole_link.next

Thoughts

I had a rough time with this question. I think the description on LeetCode was quite vague, especially for beginners like me. In the past, I always assumed that the "next" attribute stored an index and worked together with a list. However, it turns out that people simply stuff the whole thing in it.

Valid Parentheses and Stack (Easy) | LeetCodePractice #5

睡觉 — Tue, 14 Jul 2026 04:13:20 +0000

Valid Parentheses (LeetCode 20)

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if: open brackets must be closed by the same type of brackets; open brackets must be closed in the correct order; every close bracket has a corresponding open bracket of the same type.

Python

####Replace Function (Runtime: 225ms, Memory: 12.4MB)
    #DECLARE s: STRING
class Solution(object):
    def isValid(self, s):
        while "()" in s or "[]" in s or "{}" in s:
            s = s.replace("()", "")
            s = s.replace("[]", "")
            s = s.replace("{}", "")
        if len(s) == 0:
            return True
        return False



####Stack (Runtime: 7ms, Memory: 12.4MB)
    #DECLARE s: STRING
class Solution(object):
    def isValid(self, s):
        pair_map = {")": "(", "]": "[", "}": "{"}
        stack = []
        for char in s:
            if not stack or stack[-1] != pair_map.get(char):
                stack.append(char)
            else:
                stack.pop()
        if len(stack) == 0:
            return True
        return False



####Recursion (Runtime: 579ms, Memory: 416MB)
    #DECLARE s: STRING
class Solution(object):
    def isValid(self, s):
        self.pair_map = {"(": ")", "[": "]", "{": "}"}
        arr = list(s)
        return self.recursionMethod(1, arr)

    def recursionMethod(self, scan_index, arr):
        if len(arr) == 0:
            return True
        for i in range(scan_index, len(arr)):
            if arr[i] == self.pair_map.get(arr[i-1]):
                arr.pop(i)
                arr.pop(i-1)
                scan_index = max(1, i-2)
                return self.recursionMethod(scan_index, arr)
        return False

Thoughts

Not going to lie, but the first method that came to my mind was Recursion. I actually looked forward to using Recursion, but the data slapped me hard in the face. The question is meant to be solved using Stack methods, and it's hard to work around that.

Longest Common Prefix (Easy) | LeetCodePractice #4

睡觉 — Sun, 12 Jul 2026 14:56:02 +0000

Longest Common Prefix (LeetCode 14)

Write a function to find the longest common prefix string amongst an array of strings strs. Assume that strs only consists of lowercase English letters if it is non-empty. If there is no common prefix, return an empty string "".

Python

####Horizontal Scanning (Runtime: 5ms, Memory: 12.4MB)
    #DECLARE strs: ARRAY of STRING
class Solution(object):
    def longestCommonPrefix(self, strs):
        prefix = strs[0]
        for i in range(1, len(strs)):
            s = strs[i]
            j = 0
            while j < len(s) and j < len(prefix) and s[j] == prefix[j]:
                j += 1
            prefix = prefix[:j]
        return prefix



####Vertical Scanning (Runtime: 0ms, Memory: 12.5MB)
    #DECLARE strs: ARRAY of STRING
class Solution(object):
    def longestCommonPrefix(self, strs):
        max_length = min(len(s) for s in strs)
        i = 0
        while i < max_length:
            test_char = strs[0][i]
            for j in range(1, len(strs)):
                if strs[j][i] != test_char:
                    return strs[0][:i]
            i += 1
        return strs[0][:i]



####Sorting (Runtime: 0ms, Memory: 12.4MB)
    #DECLARE strs: ARRAY of STRING
class Solution(object):
    def longestCommonPrefix(self, strs):
        strs.sort()
        i = 0
        x = strs[0]
        y = strs[-1]
        while i < len(x) and i < len(y):
            if x[i] == y[i]:
                i += 1
            else:
                break
        return x[0:i]

Thoughts

Sorry, guys. I actually did a pretty terrible job on this one. I spent two days trying to figure out the iteration process in Method 2 (Oh my gosh, my head is full of marshmallows!!!). On the other hand, to be honest, I still haven’t fully mastered Timsort yet. It felt pretty bad to slack off and just use a built-in function instead of coming up with my own solution. But yeah… my brain is just peanut butter right now. Gotta go and get some sleep.

Converting Roman Numbers into integers (Easy) | LeetCodePractice #3

睡觉 — Fri, 10 Jul 2026 14:58:24 +0000

Roman To Integer (LeetCode 13)

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M. Given a roman numeral, convert it to an integer.

(I can be placed before V and X to make 4 and 9. X can be placed before L and C to make 40 and 90. C can be placed before D and M to make 400 and 900.)

Python

####Forward Pointer (Runtime: 0ms, Memory: 12.3MB)
    #DECLARE s: STRING
class Solution(object):
    def romanToInt(self, s):
        roman_map = {
            "I": 1, "V": 5, "X": 10, "L": 50,
            "C": 100, "D": 500, "M": 1000
        }
        total = 0
        i = 0
        while i < len(s)-1:
            current = roman_map[s[i]]
            following = roman_map[s[i+1]]
            if current < following:
                total -= current
            else:
                total += current
            i += 1
        total += roman_map[s[-1]]
        return total



####Subtraction Method (Runtime: 5ms, Memory: 12.5MB)
    #DECLARE s: STRING
class Solution(object):
    def romanToInt(self, s):
        roman_map = {
            "I": 1, "V": 5, "X": 10, "L": 50,
            "C": 100, "D": 500, "M": 1000
        }
        last = roman_map[s[0]]
        total = last
        for i in range(1, len(s)):
            current = roman_map[s[i]]
            if current > last:
                total -= 2 * last
            total += current
            last = current
        return total



####Dictionary Matching (Runtime: 8ms, Memory: 12.4MB)
    #DECLARE s: STRING
class Solution(object):
    def romanToInt(self, s):
        roman_map = {
            "I": 1, "IV": 4, "V": 5, "IX": 9,
            "X": 10, "XL": 40, "L": 50, "XC": 90,
            "C": 100, "CD": 400, "D": 500,
            "CM": 900, "M": 1000
        }
        total = 0
        i = 0
        while i < len(s):
            if s[i:(i+2)] in roman_map:
                total += roman_map[s[i:(i+2)]]
                i += 2
            else:
                total += roman_map[s[i]]
                i += 1
        return total

Thoughts

I also tried a Recursion for this one, but in the end, it just didn't feel appropriate. Recursion only made the code much longer, so I wouldn't recommend using it. Overall, the question is nice and simple.

Five simple ways to tackle Palindrome Number (Easy) | LeetCodePractice #2

睡觉 — Fri, 10 Jul 2026 09:30:48 +0000

Palindrome Number (LeetCode 9)

Given an integer x, return true if x is a palindrome, and false otherwise.

Python

####Two Pointer (Runtime: 10ms, Memory: 12.4MB)
    #DECLARE x: INTEGER
class Solution:
    def isPalindrome(self, x):
        y = str(x)
        head = 0
        tail = len(y) - 1
        while head < tail:
            if y[head] != y[tail]:
                return False
            head += 1
            tail -= 1
        return True



####Recursion (Runtime: 12ms, Memory: 12.3MB)
    #DECLARE x: INTEGER
class Solution:
    def isPalindrome(self, x):
        y = str(x)
        if y[0] != y[-1]:
            return False
        if len(y) <= 2:
            return True
        return self.isPalindrome(y[1:-1])



####Slicing with Radius Check (Runtime: 0ms, Memory: 12.3MB)
    #DECLARE x: INTEGER
class Solution:
    def isPalindrome(self, x):
        y = str(x)
        radius = len(y) // 2
        return y[:radius] == y[::-1][:radius]



####Mathematical Calculation (Runtime: 16ms, Memory: 12.4MB)
    #DECLARE x: INTEGER
class Solution:
    def isPalindrome(self, x):
        if x < 0:
            return False
        reverse_num = 0
        y = x
        while y > 0:
            reverse_num = reverse_num * 10 + (y%10)
            y = y // 10
        return x == reverse_num



####Calculation and Half Reverse (Runtime: 3ms, Memory: 12.3MB)
    #DECLARE x: INTEGER
class Solution:
    def isPalindrome(self, x):
        if x < 0 or (x%10==0 and x!=0):
            return False
        y = x
        reverse_num = 0
        while y > reverse_num:
            reverse_num = reverse_num * 10 + (y%10)
            y = y // 10
        if y == reverse_num or y == (reverse_num//10):
            return True
        return False

Thoughts

Well, the last one definitely gave me a headache. I'm not really sensitive to numbers, and failing to consider that "zeros can't be at the front" didn't help either. So, there's a lesson for me: get rid of difficult cases at the start so that you don't need to make more adjustments afterward.

Two Sum and the use of Dictionary (Easy) | LeetCodePractice #1

睡觉 — Fri, 10 Jul 2026 09:23:30 +0000

Two Sum (LeetCode 1)

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Python

####Double Loops (Runtime: 2441ms, Memory: 13.4MB)
    #DECLARE nums: ARRAY of INTEGER
    #DECLARE target: INTEGER
class Solution:
    def twoSum(self, nums, target):
        length = len(nums)
        for i in range(length-1):
            for j in range((i+1), length):
                if nums[i] + nums[j] == target:
                    return i, j
        return None



####Hashing Algorithm (Runtime: 0ms, Memory: 12.8MB)
    #DECLARE nums: ARRAY of INTEGER
    #DECLARE target: INTEGER
class Solution:
    def twoSum(self, nums, target):
        seen_map = {}
        for i, value in enumerate(nums):
            if (target-value) in seen_map:
                return seen_map[target-value], i
            seen_map[value] = i
        return None

Thoughts

I think the most important thing that the Two Sum question teaches is how to use Dictionaries effectively. It helps you understand that using Direct Access is much faster than looping through all the elements. Personally, it made me step back and think more about improving performance rather than simply solving the problem.