727 - LeetCode Sorting on 嗡嗡的隨手筆記

【Leetcode】python - [621] Task Scheduler 個人解法筆記

Fri, 17 Jun 2022 17:19:38 +0800

題目出處

621. Task Scheduler

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        counter = Counter(tasks)
        collect_counts = sorted(counter.values(), reverse = True)

        # same_max_length + (max_count-1) * (1+n)
        same_max_length = collect_counts.count(collect_counts[0])
        max_length = same_max_length + (collect_counts[0] - 1) * (n + 1)

        return max(max_length, len(tasks)) # min length

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

這題的答案可以直接用數學公式導出來，個人認為對面試準備的幫助比較不大。

分析答案的分佈，我們可以知道「最大數量對於結果有一定程度的影響」，
而繼續往下推，我們可以知道最小長度等於 = 「同樣的最大數量」+ 「(n+1) * (最大數量 -1)」

不懂在說什麼的話，就看下圖吧：

input handling

Boundary conditions

直接數學運算出來

Reference

任务计划 · Task Scheduler

【Leetcode】python - [846] Hand of Straights 個人解法筆記

Fri, 17 Jun 2022 16:21:35 +0800

題目出處

846. Hand of Straights

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
        if not len(hand) % groupSize == 0:
            return False

        counter = Counter(hand)
        # print(counter.items())
        for key in sorted(counter.keys()):
            if counter[key] == 0:
                continue
            if counter[key] > 0:
                num_of_cards = counter[key]
                for delta_i in range(groupSize):
                    # print(key + delta_i)
                    counter[key + delta_i] -= num_of_cards
                    if counter[key + delta_i] < 0:
                        return False

        return True

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

先處理不整除的狀況，直接 return False

如果是整除的情況，我們先進行排序，
從小的卡片開始，往後「扣除最小卡片的數量」，

搜尋卡片的過程中，我們順便判斷剩餘的卡片數量是否大於 0，
等於 0 表示沒有剩餘，我們採取 continue 的動作。

input handling

先處理不整除的狀況，直接 return False

Boundary conditions

用 for 控制搜尋範圍

Reference

一手顺子 · Hand of Straights

【Leetcode】python - [692] Top K Frequent Words 個人解法筆記 | 內含自定義排序 key function 的使用方法

Fri, 10 Jun 2022 02:00:44 +0800

題目出處

692. Top K Frequent Words

難度

medium

題目分類

Array, Hash Table, String, Trie, Sorting, Heap (Priority Queue), Bucket Sort, Counting

2022-06-10 一刷

個人範例程式碼 - 單 hashtable + 自定義排序 key function

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

        word_list = [(word, cnt) for word, cnt in word_to_counter.items()]
        word_list.sort(key = self.key_function)

        return [word_list[i][0] for i in range(k)]

    def key_function(self, word_tuple):
        # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)         
        # second compare: word alphabetically first (lexicographical)
        word, cnt = word_tuple
        return (-cnt, word)

return 那行使用的 list comprehension，同義於下方程式碼

return 那行優化後，我才寫成上面一行的形式，
原本的內容長下面那樣，
基本上面試時，建議以自己較能掌握的穩定寫法為主。

ans = []
for i in range(k):    
    ans.append(word_list[i][0])

return ans

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

另外一個方法是我們一樣用 hashtable 先把所有數量都數出來，
可以想像做我們把所有的 word 變成 (word, count) 的形式，
再來我們要使用自定義排序，排成我們要的順序。

自定義排序 key function

一般來說，sort 都是幫我們單純直接照「數字大小排序」或是「照字母大小排序」，
但在這題目當中，我們需要同時「先考慮數字大小，再考慮字母順序」，
因此這樣的情況我們需要去特別定義排序的規則。

我們可以自己寫一個 key_fuction 給 key 去使用，
回傳一個 tuple 給 key 參考，
依照 tuple 的順序，就是我們比較的順序。

依照題目要的，數量越大的排序要越前面，因此我們排序結果應該要是
「5,4,3,2,1」(反序)，再來「照字母順序 a,b,c 排」(升序)
相對簡單的處理方式是，我們就直接讓數字前面加一個「負號」，
這樣「-5,-4,-3,-2,-1」就是升序的排列了!

因此我們回傳 (-cnt, word) 作為我們排序的依據。

word_list.sort(key = self.key_function)

def key_function(self, word_tuple):
    # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)
    # second compare: word alphabetically first (lexicographical)
    word, cnt = word_tuple
    return (-cnt, word)

input handling

Boundary conditions

用 for 來控制範圍

個人範例程式碼 - 雙 hashtable 紀錄 word_to_counter, counter_to_word

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

            current_word_count = word_to_counter[word]
            if current_word_count > 1: # existed word
                counter_to_word[current_word_count-1].remove(word)
            counter_to_word[current_word_count].append(word)

        # O(nlogN)
        counter_keys = sorted(counter_to_word.keys(), reverse=True)

        ans = []
        cnt = 0

        for key in counter_keys:
            if cnt >= k:
                break
            ans += sorted(counter_to_word[key])
            cnt += len(counter_to_word[key])

        return ans[:k]

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

第一次看到這題目，想說都要計數了，然後還要排序，直覺就想說用兩個 hashtable，
分別存 word_to_counter, counter_to_word，
當存到 k 個的時候，就輸出結果。

排序算是純以"數字"為最優先儲存，再處理字母順序。

但我們要注意，這題目有特別說明，取前 k 的時候，「有可能同數量，這時候我們就照字母順序取」

input handling

Boundary conditions

用 for 來控制範圍

Reference

最高频的K个单词 · Top K Frequent Words

【Leetcode】python - [347] Top K Frequent Elements 個人解法筆記

Mon, 06 Jun 2022 04:15:49 +0800

題目出處

347. Top K Frequent Elements

難度

medium

題目分類

Array, Hash Table, Divide and Conquer, Sorting, Heap (Priority Queue), Bucket Sort, Counting, Quickselect

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        if not nums:
            return nums

        # O(N)
        counter = Counter(nums)
        freq_counter = defaultdict(list)

        # O(N)
        for key, value in counter.items():
            freq_counter[value].append(key)

        ans = []
        # O(NlogN)
        for key in sorted(freq_counter.keys(), reverse=True):
            ans += freq_counter[key]
            k -= len(freq_counter[key])
            if k <= 0:
                break

        return ans

直接使用 dict.items() + sorted tuple 排序

更俐落一點的寫法，直接把 dict.items() 轉作 tuple 來看後，直接排序
如果用法不熟，用上面方法即可。

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        if not nums:
            return nums

        # O(N)
        counter = Counter(nums) # key: freq

        # O(NlogN)
        sorted_tuple_by_freq = sorted(counter.items(), key=lambda x: x[1], reverse=True)

        # print(sorted_tuple_by_freq)

        ans = []
        for i in range(k):
            ans.append(sorted_tuple_by_freq[i][0])

        return ans

算法說明

我們先計算數字頻率，可以搭配內建函數 counter 快速實現，
再來針對出現次數進行排序，
然後選出前 K 個答案即可。

input handling

如果沒有 nums，return nums

Boundary conditions

用 for 來控制範圍

Reference

前K个高频元素 · Top K Frequent Elements

【Lintcode】python - [919] Meeting Rooms II 個人解法筆記

Mon, 06 Jun 2022 03:22:51 +0800

題目出處

919 · Meeting Rooms II

難度

medium

題目分類

Array, Two Pointers, Greedy, Sorting, Heap (Priority Queue), Prefix Sum

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = []
        for interval in intervals:
            time_table.append((interval.start, +1))
            time_table.append((interval.end, -1))

        time_table.sort(key=lambda x: x[0])

        ans = 0
        booked_room = 0
        for time, room_used in time_table:
            booked_room += room_used
            ans = max(ans, booked_room)

        return ans

或者，我們也可以用 hashtable 來記錄 (概念相同)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = collections.defaultdict(int)
        for interval in intervals:
            time_table[interval.start] += 1
            time_table[interval.end] -= 1


        # print(time_table)

        ans = 0
        used_room = 0
        for time in sorted(time_table.keys()):
            used_room += time_table[time]
            ans = max(ans, used_room)

        return ans

算法說明

這題目有前一題單純只判斷有沒有重複會議室，而這題是要直接計算所需要的會議室數量，上一題可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-920/

現在要安排需要的會議室數量，
我們可以直接把所有的時間點 (start, end) 都存入一個 table 裡面，排序後就可以得到我們要的答案。

儲存的方式為 (start_time, +1), (end_time, +1)，
最後我們只要將第一個欄位的 time 排序即可。

之後我們可以再使用 +1, -1 去判斷個時段的會議室增減。

input handling

如果沒有 intervals, 回傳 0 (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

会议室 II · Meeting Rooms II

【Lintcode】python - [920] Meeting Rooms 個人解法筆記

Mon, 06 Jun 2022 03:02:02 +0800

題目出處

920 · Meeting Rooms

難度

easy

題目分類

Array, Sorting

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: if a person could attend all meetings
    """
    def can_attend_meetings(self, intervals: List[Interval]) -> bool:
        # Write your code here
        if not intervals:
            return True

        intervals.sort(key = lambda x:x.start)
        end = intervals[0].end
        for i, interval in enumerate(intervals):
            if i > 0:
                if end <= interval.start: # end <= next_start (0,8), (8,10)
                    end = interval.end
                    continue
                else:
                    return False

        return True

算法說明

單純檢查會議室有沒有重疊時間的問題，我們可以先 sort start 時間後，
再檢查是否「上一個 end <= 下一個 start 」的時間點
(題目有說，(0, 8),(8, 10)不算是共用會議室，因此要有「等於」)

當我們發現不符合我們上述的規則時，
直接 return False。

input handling

如果沒有 intervals, 回傳 True (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

会议室 · Meeting Rooms

【Leetcode】python - [332] Reconstruct Itinerary 個人解法筆記

Mon, 23 May 2022 03:00:14 +0800

題目出處

332. Reconstruct Itinerary

難度

Hard

題目分類

Array, String, Depth-First Search, Graph Theory, Sorting, Heap (Priority Queue), Eulerian Circuit

2022-05-23 一刷

個人範例程式碼 - 一刷 (2022/05/23)

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        graph = self.build_graph(tickets)
        self.ans = []
        self.dfs(graph, 'JFK')

        return self.ans[::-1]

    def build_graph(self, tickets):
        graph = collections.defaultdict(list)
        for _from, _to in tickets:
            graph[_from].append(_to)

        for _from in graph:
            graph[_from].sort(reverse = True)
            # dfs get reverse lexical order (since we get ans from end to start)           

        return graph

    def dfs(self, graph, _from):
        # end of recursion, when find no route
        while graph[_from]:
            # define and split
            self.dfs(graph, graph[_from].pop())

        # append ans, from end to start
        self.ans.append(_from)

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

這題要同時考到建構出一個 graph，
並 dfs 找尋路徑。

(這題還沒有靠自己完全寫出來，目前先參考下方 reference 進行仿寫)

反向建立 _to 順序，正向 dfs 搜尋

因為題目希望最後我們能夠照字母大小排序，而我們建立 graph 時，
先把「名稱排序比較後面的，放到前面順位」，
這樣「dfs 搜尋時，就會先 pop()」，
而最後「我們在把 from end to start 的路徑倒過來」。

input handling

Boundary conditions

在 graph 與 bfs 中控制搜尋範圍，搜尋完全部 node 就正常結束。
(沒有全部搜尋完，就沒有結果)

Reference

重新安排行程 · Reconstruct Itinerary

【Leetcode】python - [435] Non-overlapping Intervals 個人解法筆記

Thu, 19 May 2022 16:01:48 +0800

題目出處

435. Non-overlapping Intervals

難度

Medium

題目分類

Array, Dynamic Programming, Greedy, Sorting

2022-05-19 一刷

個人範例程式碼 - 一刷 (2022/05/19)

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x: x[1])

        cnt = 0
        end = float("-inf")

        for i, interval in enumerate(intervals):
            if interval[0] >= end:
                end = interval[1] # update end
            else:
                cnt += 1

        return cnt

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

這題我們使用的是 greedy 的作法，

我們先依照 end 來排序，
依據 greedy 的策略，我們把初始 end 設定為 -inf，

正常情況：如果每一次 start >= 前一個 end (表示無重疊)，且因為我們已經先將 end 排序，因此可以視為得到所有以 end 開頭的區間。
異常情況：start 比前一個 end 小，表示重疊了，此時我們 ans += 1，然後 continue 不理這一組 (視為會被刪掉的組合)

input handling

一同在 for loop 內處理。

Boundary conditions

用 for loop 控制範圍

Reference

无重叠区间 · Non-overlapping Intervals

【Leetcode】python - [2274] Maximum Consecutive Floors Without Special Floors 個人解法筆記 | 293rd LeetCode Weekly Contest

Wed, 18 May 2022 01:14:33 +0800

題目出處

2274. Maximum Consecutive Floors Without Special Floors

難度

medium

題目分類

Array, Sorting

2022-05-18 一刷

個人範例程式碼 - 一刷 (2022/05/18)

class Solution:
    def maxConsecutive(self, bottom: int, top: int, special: List[int]) -> int:
        if bottom >= top:
            return 0

        special.sort()
        max_floor = max(top - special[-1], special[0] - bottom)
        for i, s in enumerate(special):
            if i > 0:
                max_floor = max(special[i] - special[i-1] - 1 , max_floor) 

        return max_floor

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

這題有點像是 interval 的變化版，
幸好題目幫我們把限制設定好 (bottom < special floors < top)，
不然處理上會有更多細節要注意。

input handling

如果 bottom >= top，return 0 (錯誤的 case)

一開始先處理 top 跟 sorting 後的 special[-1]，差了多少 (可能為 0)，
以及 bottom 與 sorting 後的 special[0]，差了多少 (可能為 0)。

這邊真的要幸好題目設定好這些限制，不然處理上真的會麻煩很多…

再來做中間層的處理。

Boundary conditions

for loop 控制範圍

Reference

[Java/C++/Python] Sort

【Leetcode】python - [2273] Find Resultant Array After Removing Anagrams 個人解法筆記 | 293rd LeetCode Weekly Contest

Wed, 18 May 2022 01:07:01 +0800

題目出處

2273. Find Resultant Array After Removing Anagrams

難度

easy

題目分類

Array, Hash Table, String, Sorting

2022-05-18 一刷

個人範例程式碼 - 一刷 (2022/05/18)

class Solution:
    def removeAnagrams(self, words: List[str]) -> List[str]:
        if not words:
            return words

        i = 0
        last_word = ""
        while(i < len(words)):
            sort_word = "".join(sorted(words[i]))
            if sort_word == last_word:
                words.pop(i) # remove, and keep i
            else:
                last_word = sort_word
                i += 1 # go next

        return words

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

讓我們先來理解題目，題目的意思簡單說就是，
我們將每個字都取 counter，如果前後 counter 相同，那我們就去把後面的刪除，

這邊要「特別注意」，題目只有說「前後」，因此「相隔很多的不用刪」，

input handling

如果沒有 input words，return words

Boundary conditions

for loop 控制範圍

特別注意，當 list remove 時，index 要繼續使用原來的 (因為原來位置被刪除，後面補前面)

Reference

【Leetcode】python - [217] Contains Duplicate 個人解法筆記

Wed, 18 May 2022 00:29:33 +0800

題目出處

217. Contains Duplicate

難度

Easy

題目分類

Array, Hash Table, Sorting

2022-05-18 三刷

個人範例程式碼 - 三刷 (2022/05/18)

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        if not nums:
            return False

        record = set()
        for num in nums:
            if num in record:
                return True
            else:
                record.add(num)

        return False

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

找重複，有重複 return True

input handling

如果沒有 input，return False

Boundary conditions

for 迴圈控制範圍

2022-03-03 二刷

個人範例程式碼 - 二刷 (2022/03/03)

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        loopuptable = {}
        for ele in nums:
            if ele in loopuptable.keys():
                return True
            else:
                loopuptable[ele] = True

        return False

說明

dictionary search 的時間只需要 O(1)，
透過建立 dict 可以幫助我們快速查找已經出現的元素。

註：「if ele in loopuptable.keys()」也可以寫成「if ele in loopuptable」
只是寫成前者會更清楚。

2022-02-24 一刷

個人範例程式碼 - 一刷 (2022/02/24)

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        return (len(set(nums)) != len(nums))

說明

這題考的東西很簡單，就是找有沒有重複的東西，
「找重複」非常適合使用 set 來做，我們只需要比較 set 之後的大小是否等於原長度即可。

Reference

One line solution in python

【Leetcode】python - [49] Group Anagrams 個人解法筆記

Thu, 12 May 2022 13:32:16 +0800

題目出處

49. Group Anagrams

難度

medium

題目分類

Array, Hash Table, String, Sorting

2022-05-12 一刷

個人範例程式碼 - 一刷 (2022/05/12)

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        str_dict = {}

        for each_str in strs:
            sorted_each_str = self.sort_alphabetical(each_str)
            if sorted_each_str not in str_dict:
                str_dict[sorted_each_str] = []        
            str_dict[sorted_each_str].append(each_str)

        ans = []
        for key, value in str_dict.items():
            ans.append(value)

        return ans

    def sort_alphabetical(self, s):
        return "".join(sorted(s))

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

另外，最後那段後來發現可以優化為一行表示，不用自己重跑一次 dict，使程式碼更為簡潔：

return list(str_dict.values())

算法說明

其實就是一個整理 set 的題目，原本想要直接用 set() 作為 key，
後來發現 key 不能使用 set 可惜了XD

變通一下，把 key 換成「排序後的字串」，就能夠發揮類似的效果了，
我們要的就是個統一的標準。

input handling

Boundary conditions

for 控制範圍

Reference

错位词分组 · Group Anagrams

【Leetcode】python - [349] Intersection of Two Arrays 個人解法筆記

Thu, 12 May 2022 03:49:37 +0800

題目出處

349. Intersection of Two Arrays

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 一刷

個人範例程式碼 - 一刷 (2022/05/12)

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

一個 set and 就結束了…
好舒服的 easy 題目…

input handling

set and 的過程會幫我們處理掉

Boundary conditions

Reference

【Leetcode】python - [350] Intersection of Two Arrays II 個人解法筆記

Thu, 12 May 2022 02:55:05 +0800

題目出處

350. Intersection of Two Arrays II

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 三刷

個人範例程式碼 - 三刷 (2022/05/12)

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        intersect_counter = (Counter(nums1) & Counter(nums2))

        ans = []
        for key, value in intersect_counter.items():
            for _ in range(value):
                ans.append(key)

        return ans

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

此題目的前一題為不需要進行重複值處理，這題需要處理重複，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-349/

Counter & Counter：可以找到所有重複的數值 & 數量

這裡特別注意：很幸運的，他有幫我們處理掉「“3個重複數” & “2個重複數” = “2個重複數”」的情況，
不然我們預期可能直接因為數量不同就 False，這樣我們就不能使用這個方法了。

input handling

dict and 的過程中會處理掉

Boundary conditions

2022-03-04 二刷

個人範例程式碼 - 2022/3/4 二刷 (set & counter 流)

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = []
        for ele in (set(nums1) & set(nums2)):
            for i in range(min(Counter(nums1)[ele], Counter(nums2)[ele])):
                ans.append(ele)
        return ans

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
不過沒關係，遇到重複了，我們還有 Counter!

先用 set 快速找出有重複的，
再用確定有重複的，計算數量後，取較少的即可得到答案。

corner case 特殊情況處理

記得要找的是兩個集合的 min，而不是「只找單邊」

Boundary conditions/ Edge conditions 邊際情況處理

2022-02-25 一刷

個人範例程式碼 - 2022/2/25 一刷 (two pointer 流)

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        # print(set(nums1) & set(nums2))
        nums1, nums2 = sorted(nums1), sorted(nums2)
        res = []
        pt1, pt2 = 0, 0
        while(pt1 < len(nums1) and pt2 < len(nums2)):
            if nums1[pt1] > nums2[pt2]:
                pt2 += 1
            elif nums1[pt1] < nums2[pt2]:
                pt1 += 1
            else: # nums1[pt1] == nums2[pt2]
                res.append(nums1[pt1])
                pt1 += 1
                pt2 += 1
        return res

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
因為它是允許有 [1,1,2,2] 去交集 [2,2] 的
所以如果我門直接用 set，會把重複的 2 給用掉。
因此這題不能用 set 的作法。

我們採用的是 sort 後並使用兩個 pointer，一個個對照，
只要發現比較小的那側，就往下一個數字前進，
而如果兩者是一樣的，我們就同時一起前進。

邊際情況處理

這題目需要處理的邊際情況為 pointer 什麼時候結束，
我們需要知道，當其中一個 pointer 已經「指完了全部的內容」，
就沒有繼續往下看的必要了。因為另外一個再往下看，也一定找不到一樣的值。

所以我們使用 while 設定範圍在 pt1 < len(nums1) 的範圍內，
就可以處理這個問題。

Reference

【Leetcode】python - [88] Merge Sorted Array 個人解法筆記 | 內含 python while-else 用法說明

Wed, 11 May 2022 02:52:15 +0800

題目出處

88. Merge Sorted Array

難度

Easy

題目分類

Array, Two Pointers, Sorting

2022-05-11 二刷

個人範例程式碼 - 2022/5/11

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        m, n = m-1, n-1 # get last idx
        for idx in range(len(nums1)-1, -1, -1):
            if(m >= 0 and n >= 0):
                if nums1[m] < nums2[n]:
                    nums1[idx] = nums2[n] 
                    n -= 1
                else:
                    nums1[idx] = nums1[m] 
                    m -= 1
            elif m >= 0:
                nums1[idx] = nums1[m] 
                m -= 1   
            elif n >= 0:
                nums1[idx] = nums2[n] 
                n -= 1

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

從尾巴開始往前填，注意一下順序即可

input handling

在 for 迴圈中一起處理

Boundary conditions

for 迴圈控制範圍

2022-02-25 一刷

個人範例程式碼 - 2022/2/25

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        while (m > 0 and n > 0): 
            if(nums1[m-1] >= nums2[n-1]):
                nums1[m+n-1] = nums1[m-1] # put nums1[m] in to the last place of nums1
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
                n -= 1
        else:
            while n > 0: # m = 0
                nums1[m+n-1] = nums2[n-1]
                n -= 1
            # else m > 0, already in nums1

說明

這題我們可以先注意題目的敘述：
最需要思考的部分在於「題目希望最後的結果直接儲存在 nums1 裡面」

雖然這樣的限制會使我們解題更加的「受到限制」，但反過來說，
其實這也是題目給我們「最大的提示」。

題目的 nums1 給的空間為 m+n，所以最後我們都會將所有的值擺入 nums1 中，
而因為我們可以無憂慮去更改的值為最後的 0,0,0… 部分
(因為這個值就算被改消失了，也不影響我們想計算的結果)

所以這邊可以推斷出一定要「從後面開始解」，「從最無痛的 0 開始取代」，

再來我們就可以來思考，什麼時候擺入 nums1的值? 什麼時候擺入 nums2 的值?
我們可以靠著題目所給的 m, n 來進行這樣的操作，透過值不斷擺入，
我們去移動 m, n 作為 index 的座標，即可順利完成此題目。

邊際情況處理

這題要注意的邊際情況為 m=0, n=0 的時候我們要怎麼處理，
而照題目的敘述，

n=0 基本上對我們來說沒差，因為 m 控制的 nums1 即代表我們要的答案

m=0 才是重點，如果還有剩餘的 n，都需要擺入 nums1 中，而位置索幸很好取得，依然可以透過 m+n-1 算出

注意 index 細節，才是這題要考細心的部分

這題有很多 index 細節考驗著作答者的細心度，
包含：

迴圈的範圍僅限於 m, n > 0 時，其他需要進例外處理
m-1, n-1 才是當下座標
要擺入的位置為 m+n-1
處理到 n > 0 就應該停下，而非 n >= 0

python while-else 用法說明

一般來說，我們通常都只會使用到 while，
但其實在 python 中，while 是可以搭配 else 使用的。

邏輯如下：

while(條件成立):
    # 成立時循環
else: # 當不成立時，出現在這
    # 當條件不成立時，開始作這邊的事情

這個寫法，可能很多人覺得好像有沒有 else 似乎不會有太大的影響?
畢竟當 while 條件不成立後，後續的程式碼「本來就會執行」

沒有錯!!!! 但是這個小細節，卻可以讓我們的程式碼邏輯更漂亮!

例如說當我們有無關 while 的相關內容，我們才應該擺在外面，
但有時候是剛結束迴圈時有一些收尾的相關內容要處理，這時候用 else 的寫法就相當漂亮了!

範例

假設我們要把一個 mylist 「純手動」印成 [1,2,3] 的樣子，
最後還要印出一個 finish!

mylist = [1,2,3]
idx = 0
print('[', end = '')
while(idx < len(mylist)):
    print(mylist[idx], ',')
    idx += 1
else:
    print(']')
print('finish!')

這個例子應該就很好懂了，我們集中「把要處理 list 列印的動作」放在 while-else 裡面，
最後比較無關的 finish! 放在 while-else 外面，
這樣看起來程式碼邏輯有沒有比都放在外面更清楚了呢? (當然，見仁見智啦XDDD，我覺得有XD)

特殊用法 - while-else 搭配 break 使用的情況

這也是我近期解題才發現的，當 while - else 搭配 break 使用時，能發揮更好閱讀的效果!

請讀者先想像一下，下面的程式碼會印出什麼呢?

while(True):
    break
else:
    print(1)
print(2)

答案不是 1 2 !!! 而是只有 2 !!!

這樣我們就能夠更進階的使用這個功能了，

「透過 while 迴圈條件結束的，寫在 else 裡面」
「如果是透過 break 結束的，寫在最外面」

使用方式可以看我下面這題的示範：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-142/

Reference

Python easy to understand in-place solution

【Leetcode】python - [56] Merge Intervals 個人解法筆記 | 內含：sorted key 搭配 lambda 的用法範例

Thu, 05 May 2022 21:13:51 +0800

題目出處

56. Merge Intervals

難度

medium

題目分類

Array, Sorting

2022-05-05 一刷

個人範例程式碼 - 一刷 (2022/05/05)

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if not intervals:
            return intervals

        intervals = sorted(intervals, key = lambda x: x[0])

        ans = []
        for i, interval in enumerate(intervals):
            if i == 0:
                prev = interval
                continue

            if prev[1] < interval[0]: # end < start  
                ans.append(prev)
                prev = interval
            else:
                prev[0] = min(prev[0], interval[0])
                prev[1] = max(prev[1], interval[1])

        ans.append(prev) # last
        return ans

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

interval 經典題目，記得必須先經過 sorted 處理。

sorted 搭配 lambda 的用法

針對第一個項目的排序 - lambda 法

intervals = sorted(intervals, key = lambda x: x[0])

針對第二個項目的排序 - function 法

這個是留給萬一臨時忘記 lambda 怎麼寫的人，比較不漂亮，但是可行的替代方案

def sort_key(self, key):
    return key[0]
intervals = sorted(intervals, key = self.sort_key)

完整的程式碼

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if not intervals:
            return intervals

        intervals = sorted(intervals, key = self.sort_key)

        ans = []
        for i, interval in enumerate(intervals):
            if i == 0:
                prev = interval
                continue

            if prev[1] < interval[0]: # end < start  
                ans.append(prev)
                prev = interval
            else:
                prev[0] = min(prev[0], interval[0])
                prev[1] = max(prev[1], interval[1])

        ans.append(prev) # last
        return ans

    def sort_key(self, key):
        return key[0]

input handling

如果沒有 intervals，回傳 intervals

Boundary conditions

for 處理範圍，補上最後一個區間

Reference

合并区间 · Merge Intervals

【Leetcode】python - [268] Missing Number 個人解法筆記

Wed, 04 May 2022 16:31:39 +0800

題目出處

268. Missing Number

難度

easy

題目分類

Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting

2022-05-04 一刷

個人範例程式碼

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        if not nums:
            return 0

        num_set = set(nums)
        n = len(nums) + 1
        for i in range(n):
            if i not in num_set: # O(1)
                return i

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

因為 list 搜尋是 O(N) 時間，
為了加速，先轉成 hashset，搜尋時間變成 O(1)

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

個人範例程式碼 - set

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        if not nums:
            return 0

        num_set = set([x for x in range(len(nums)+1)])
        return (num_set - set(nums)).pop()

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

set - set，找到缺少的內容

set.pop() 可以取得 set 裡面的內容，例如從 {2} 中取得 2

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

Reference

寻找缺失的数 · Missing Number

【Leetcode】python - [242] Valid Anagram 個人解法筆記

Thu, 28 Apr 2022 13:17:18 +0800

題目出處

242. Valid Anagram

難度

easy

題目分類

Hash Table, String, Sorting

2022-04-28 一刷

個人範例程式碼 - 2022/4/28 (與 2022/3/4 解法完全相同)

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        return Counter(s) == Counter(t)

Time Complexity

O(n)

Space Complexity

算法說明

這題目碰到 python Counter，一行再見… python 太強大了。

這題就是計算數量，看有沒有相等，相等就是 True，
而 python collection 內建的 Counter function，
快速幫我們把計算數量的 hash dictionary 完成了。

如果還不知道 python Counter 用法的，「強烈建議」一定要會，寫程式效率會快超級多！！！
可參考我的另外一篇文：
【Python】python counter() 用法整理 – 快速計算資料內容的數量

我們就不用再另外寫 hash table 做 count 的動作了。

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

Reference

【Leetcode】python - [2248] Intersection of Multiple Arrays 個人解法筆記 | 290th LeetCode Weekly Contest

Tue, 26 Apr 2022 14:51:52 +0800

題目出處

2248. Intersection of Multiple Arrays

難度

easy

題目分類

Array, Hash Table, Sorting, Counting

2022-04-26 一刷

個人範例程式碼 - 一刷 (2022/04/26)

class Solution:
    def intersection(self, nums: List[List[int]]) -> List[int]:
        if not nums:
            return nums

        ans = set(nums[0])
        for num in nums:
            ans &= set(num)
        return sorted(list(ans))

算法說明

原本以為是要用 priotity queue 或 pointer 解的題目，
後來發現題目沒有預先排序，那直接暴力解吧，
全部轉 set() 後直接取交集。

得到結果的 set() 之後，記得排序。

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

如果沒有 nums，return nums

Boundary conditions

for loop 控制範圍

Reference

[Python3] - 1 LINE Solution || Simple Explanation

【Leetcode】python - [47] Permutations II 個人解法筆記 #重要題型

Sun, 24 Apr 2022 03:06:44 +0800

題目出處

47. Permutations II

難度

medium

題目分類

Array, Backtracking, Sorting

2022-04-24 一刷

個人範例程式碼 - 一刷 (2022/04/24)

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        if not nums:
            return nums

        nums.sort()
        self.ans = []
        self.dfs(nums, [])
        return self.ans

    def dfs(self, nums, permutations):
        # end of recursion
        if not nums:
            self.ans.append(list(permutations))
            return

        # define and split
        for i, num in enumerate(nums):
            if i > 0 and nums[i] == nums[i-1]: # if duplicate, we only record first time
                continue  

            permutations.append(num)
            self.dfs(nums[:i] + nums[i+1:], permutations)
            permutations.pop() # backtracking

算法說明

此題目的前一題，差別在這題需要多處理重複的元素，可參考：

https://wongwongnotes.com/posts/algorithm-practice/search-algorithms/dfs-permutation/leetcode-python-46/

排列類型的題目，使用 dfs 去搜尋全部的結果

處理順序

另外在處理順序時，我們使用傳入「start[0:i] + start[i+1:]」的方式，暫時移除了 start[i] 的元素，
這樣的操作方式會複製一個新的 list，而不會影響到原本的 list

處理重複

為了處理重複，我們先對 nums 進行排序，我們使用

nums.sort()

另外在處理重複的數字時，我們只採用第一組的結果，後面都 continue 掉，因此：

if i > 0 and nums[i] == nums[i-1]: # if duplicate, we only record first time
    continue

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

當沒有 nums 時，return nums

Boundary conditions

搜尋至 no nums 時，添加結果回傳 (表示元素已使用完畢)

Reference

带重复元素的排列 · Permutations II

【Leetcode】python - [75] Sort Colors 個人解法筆記 #重要題型 #常錯題型

Thu, 14 Apr 2022 19:51:56 +0800

題目出處

75. Sort Colors

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-14 一刷

個人範例程式碼 - 一刷 (2022/04/14)

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # only 0, 1, 2
        self.partition(nums, 2, 0, len(nums)-1)
        return 


    def partition(self, nums, pivot, start, end):
        if pivot == 0:
            return 

        left, right = start, end

        while(left <= right):
            while(left <= right and nums[left] < pivot): # 0, 1
                left += 1
            while(left <= right and nums[right] >= pivot): # 2
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                # check twice
                # left += 1
                # right -= 1
        else: # after left and right cross, all 0, 1 will be left, 2 will be right
            # start, right(0, 1), left(2), end            
            # start, right(0), left(1), end

            self.partition(nums, pivot-1, 0, right)

算法說明

此題是考 partition 的延伸題，也可以單純使用三指標來快速解掉，
不過之後還有一題多顏色的題目，基本上 partition 還是要會解。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

while(left <= right):
    while(left <= right and nums[left] < pivot): # 0, 1
        left += 1
    while(left <= right and nums[right] >= pivot): # 2
        right -= 1
    if(left <= right):
        nums[left], nums[right] = nums[right], nums[left]

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

這題本身較簡單，但其實不需要拆到那麼複雜，
但為了後續的 partition 題目方便，這裡就先用最泛用的方式解

self.partition(nums, pivot-1, 0, right)

遞迴的中止

如果 pivot = 0，return

一樣也是因為這題題目相對單純，因此我們可以這樣寫死。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

Reference

颜色分类 · Sort Colors

【演算法筆記 #3】QuickSort 重點整理筆記，包含 Partition, Pivot 常見錯誤討論 #重要題型

Sun, 10 Apr 2022 03:29:01 +0800

前言

QuickSort 算是面試中或是演算法中經典的問題，非常重要，
而且最容易搞錯「他的範圍」，因此這邊來將自己的常見錯誤做個整理。

先一個正式版本

基本上，要講出 QuickSort 的核心精神，人人幾乎都不太會犯錯，
但程式非常容易寫錯，特別是在區間的控制過程。

QuickSort 的核心精神

QuickSort 的核心精神就是選定一個 pivot (可以頭可以尾)，
將剩下的數字透過 pivot 分成「 < pivot 」與「 > pivot 」兩組。

最容易出錯的地方 - 決定邊界

在撰寫程式的時候，如果沒有仔細思考，或甚至已經仔細思考了都還經常會寫錯。

注意：這邊示範的並「不是」主流的教科書寫法，而是用釐清觀念候「用自己的方式」寫的。

我們的目的如上圖，就是希望在循環結束時，能夠

讓 left 左邊的一切都是 smaller (than pivot)
讓 right 右邊的一切都是 bigger (than pivot)

因此 (以下為說明用的程式碼，並不完整)

while(left <= right):
    while(left <= right and a[left] < pivot):
        left += 1
    while(left <= right and a[right] > pivot):
        right -= 1
    if left <= right:
        a[left], a[right] = a[right], a[left]

注意啦! 光上面這裡有很多細節了!

left <= right

首先是 left <= right，如果寫 left < right 達不到交錯的效果，有可能出迴圈要多做處理

不是不能這樣寫，就是要多做一些處理，沒有什麼不能的寫法

a[left] < pivot, a[right] > pivot

注意這裡不處理等於，原因是處理等於也不一定好，
等於表示與 pivot 相等，用於處理重複的 array，
但如果硬要處理等於的情況，在 [1,1,1,1,1] 類似這樣的 case，
一定會用 worst case 的 O(n) 時間去解，而不是平均的 O(nlogN)。

可以先理解 QuickSort 的 worst case 是什麼情況及為什麼會發生，
這樣更能夠懂為什麼會舉到上面的例子。

此種類的完整的 QuickSort 程式碼

    def partition(self, nums, start, end):
        # recusion end
        if start >= end:
            return 

        # recursion define
        left, right = start+1, end
        pivot = nums[start]

        while(left <= right):
            while(left <= right and nums[left] < pivot):
                left += 1
            while(left <= right and nums[right] > pivot):
                right -= 1
            if left <= right:
                nums[left], nums[right] = nums[right], nums[left]
        else:
            nums[start], nums[right] = nums[right], nums[start]

        print(nums, left, right)

        # recursion split
        self.partition(nums, start, right-1)
        self.partition(nums, left, end)

抓 partition 與 pivot 的重點

我們設計的思想是

一開始： pivot(start) < (left, start+1) < (right, end)

- 結束時，交換前 (注意交錯)：

(start) < start+1 < right < left < end

務必注意交錯的位置的「 right < left 」，這是最最重要的部分。

結束時，交換後 (注意交錯)：

start < right-1 < pivot(right) < left < end

而 start ~ right-1 都比 pivot 小
left < end 都比 pivot 大。

結束迴圈 recursion 「start >= end」

不論是

self.partition(nums, start, right-1)
self.partition(nums, left, end)

right 會越來越逼近 start，直到重疊 start >= end
而 left 也會越來越逼近 end (因為 left 與 right 是交錯，只會更逼近 end)

另外一種寫法

建議先嘗試閱讀以下程式碼，思考一下
(這我寫過的東西，我也想了很久為什麼)

while(left <= right)
    if a[left] < pivot:
        left += 1
    elif a[right] > pivot:
        right -= 1
    else:
        a[left], a[right] = a[right], a[left]
        # left += 1
        # right -= 1

建議想好後再看，這樣才會更印象深刻。

注意 left <= right

一樣要注意的 left <= right，因為一定要交錯。

「left += 1」、「right -= 1」可有可無

其中「left += 1」、「right -= 1」可有可無，
沒有當下處理也會在之後的迴圈被處理掉。

此種類的完整的 QuickSort 程式碼

def partition(self, nums, start, end):
        # recusion end
        if start >= end:
            return 

        # recursion define
        left, right = start+1, end
        pivot = nums[start]

        while(left <= right):
            if nums[left] < pivot:
                left += 1 
            elif nums[right] > pivot:
                right -= 1 
            else:
                nums[left], nums[right] = nums[right], nums[left]
        else:
            nums[start], nums[right] = nums[right], nums[start]

        # recursion split
        self.partition(nums, start, right-1)
        self.partition(nums, left, end)

抓 partition 與 pivot 的重點

我們設計的思想是

一開始： pivot(start) < (left, start+1) < (right, end)

- 結束時，交換前 (注意交錯)：

(start) < start+1 < right < left < end

務必注意交錯的位置的「 right < left 」，這是最最重要的部分。

結束時，交換後 (注意交錯)：

start < right-1 < pivot(right) < left < end

而 start ~ right-1 都比 pivot 小
left < end 都比 pivot 大。

結束迴圈 recursion 「start >= end」

不論是

self.partition(nums, start, right-1)
self.partition(nums, left, end)

right 會越來越逼近 start，直到重疊 start >= end
而 left 也會越來越逼近 end (因為 left 與 right 是交錯，只會更逼近 end)

Reference

【Leetcode】python - [16] 3Sum Closest 個人解法筆記

Fri, 08 Apr 2022 17:35:24 +0800

題目出處

16. 3Sum Closest

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-08 一刷

個人範例程式碼 - 一刷 (2022/04/08)

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        if not nums or len(nums) < 3:
            return -1

        nums.sort()
        ans = float("inf")

        for idx, first_num in enumerate(nums):
            ans = self.two_sum(nums, target, ans, first_num, idx+1, len(nums)-1)    

        return ans

    def two_sum(self, nums, target, ans, first_num, left, right):
        while(left < right):
            if first_num + nums[left] + nums[right] == target:
                return target
            elif first_num + nums[left] + nums[right] < target:
                ans = self.find_closest(ans, first_num + nums[left] + nums[right], target)
                left += 1
            else: # if first_num + nums[left] + nums[right] > target:
                ans = self.find_closest(ans, first_num + nums[left] + nums[right], target)
                right -= 1
        else:
            return ans      

    def find_closest(self, a, b, target):
        if abs(a - target) <= abs(b - target):
            return a
        else:
            return b

算法說明

這題有幾乎相同的類似題，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-533/

前者是 2Sum，這題更難改成 3Sum，但思路與 3Sum 大同小異

https://wongwongnotes.com/posts/algorithm-practice/pointers/two-pointers-start-end/leetcode-python-15/

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

處理 input 為 [] 或 len < 3 的情況，輸出 -1 。(題目沒說，但這邊先預留特殊狀況處理)

Boundary conditions

特別留意 3Sum 的搜尋條件，特別是 a <= b <= c 的處理部分 (可以看 3Sum 的文章)

Reference

【Leetcode】python - [658] Find K Closest Elements 個人解法筆記

Tue, 05 Apr 2022 02:32:16 +0800

題目出處

658. Find K Closest Elements

難度

medium

題目分類

Array, Two Pointers, Binary Search, Sliding Window, Sorting, Heap (Priority Queue)

2022-04-05 一刷

個人範例程式碼 - 一刷 (2022/04/05)

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        start, end = 0, len(arr) - 1
        while(start + 1 < end):
            mid = (start + end) // 2
            if arr[mid] == x: 
                start = mid
            elif arr[mid] < x:
                start = mid
            else: # a[mid] > x
                end = mid
        else:
            return self.find_k_neighbors(arr, x, k, start, end) 


    def find_k_neighbors(self, arr, x, k, start, end):
        # print(start, end)
        ans = []
        while(k > 0):
            if((start >= 0) and (end < len(arr)) and (x - arr[start] <= arr[end] - x)): # smaller first
                ans.append(arr[start])
                start -= 1
            elif((start >= 0) and (end < len(arr)) and (x - arr[start] > arr[end] - x)):
                ans.append(arr[end])
                end += 1
            elif(start < 0):
                ans.append(arr[end])
                end += 1
            else: # end >= len(a)
                ans.append(arr[start])
                start -= 1
            k -= 1
            # print(ans)

        return sorted(ans)

算法說明

方法是一樣 binary search 找到中間後 O(logN)，往兩邊搜尋 K 個 O(K)。 = O(logN+K)

個人覺得這題 LintCode 版本出的比較好，Leetcode 出的版本最後多了一個排序，
只是我覺得光是找最近的 K 的結果就已經找到的關鍵，就不用再排序了!

LintCode 版本的題目：460 · Find K Closest Elements

Leetcode 版本的差別只差在我最後多補了一個 sorted 給他。

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

應該要做但我沒做XD，不過題目有保證輸入正確就是

Boundary conditions

binary search 的邊界條件

這裡有兩個 Boundary conditions 要注意，一個是一開始的 binary search 的邊界條件

find K 的邊界條件

另外一個要注意的是在找 K 個鄰近的數值時，我們需要注意「不能找到範圍之外」。

Reference

在排序数组中找最接近的K个数 · Find K Closest Elements

【演算法筆記 #2】sorting 時間複雜度（Big O）— Best/Average/Worst case 比較 #面試準備

Mon, 28 Feb 2022 02:19:54 +0800

前言

sorting 簡單說明 (記憶用)

	簡單說明
Selection sort (選擇排序)	先完成的排序是「當前index」，從當前往後搜尋全部，找最小
Insertion sort (插入排序)	每一層 loop 會完成的是「當前 index」之前的所有排序，也就是說，for-loop 的外層代表處理完成的 index，而內層處理插入當前的哪個位置
Bubble sort (氣泡排序)	不斷交換的排序，已交換len=4為例，比較「(1,2),(2,3,(3,4)) / (1,2),(2,3),(3,4) / (1,2),(2,3),(3,4)」 (共 3組 x 3輪)
Quick sort (快速排序)	1.先挑選一個基準 (pivot)，經常選最後一個值，後續的數值與基準比大小，建立two pointer，比小往左、比大往右，「停止條件：two pointer 交錯」 / 2.每一輪完成一次「對基準排序」後，將基準擺在中間 / 3. 依據「divide and conquer (O(logn))」的概念，完成剩餘的左右兩側(partition)的基準排序 (partition = [0, pivot-1], [pivot], [pivot+1, n-1]) 「停止條件：代表 front,end 的 two pointer 交錯」
Merge sort (合併排序)	一樣也是「divide and conquer (O(logn))」的概念，1. 將 array 拆成 n/2，n/2再拆兩個n/4... 2. 拆到剩餘 2 or 1(種子)，開始合併，合併時只需要看如何已排序的兩數列如何交錯即可(O(m+n))，使用 two pointer
Heap sort (堆積排序)	Complete Binary Tree /Max Heap (root max) / MaxHeapify() = 自上而下調整矩陣 BuildMaxHeap() 1. 最後一個位置換到第一個 / 2.最後一個消失(取得 Max) 3. 自上而下的 MaxHeapify()
Radix sort (基數排序)

sorting 整理

	Best	Worst	Average	Space Complexity
Selection sort	O(n^2)	O(n^2)	O(n^2)	O(1)，無新增矩陣等級的空間使用
Insertion sort	O(n) 當數列已經是從小到大的	O(n^2)	O(n^2)	\|
Bubble sort				\|
				\|

特殊情況

bubble sort early break: 如果某一回合沒有 swap 發生，直接結束

所以當從小至大排列時，bubble sort 有 best case O(n) -> early break

insertion sort : 恰好小至大，免做「插入動作 O(n)」

所以當從小至大排列時，insertion sort 有 best case O(n) -> early break

quick sort can not divide well: 如果一個矩陣從小到大或從大到小，因為沒辦法好好發揮 divide and conquer 的效果，O(m+n)*O(n) 的 m=0, n=n (類似概念) = O(n^2)

所以當從小至大 or 大至小排列時，quick sort 有 worst case O(n^2)

說明

插入排序法(Insertion Sort) Best case O(n)
直到遇到第一個比正處理的值小的值

快速排序法(Quick Sort) Worst case(On^2)
當資料的順序恰好為由大到小或由小到大時
有分割跟沒分割一樣
(資料太整齊, pivot 產生不了 Divide and conquer的效果)

Reference

【Leetcode】C++ - [88] Merge Sorted Array 個人解法筆記

Fri, 25 Feb 2022 04:20:01 +0800

題目出處

88. Merge Sorted Array

難度

Easy

題目分類

Array, Two Pointers, Sorting

2022-02-25 一刷

個人範例程式碼 - 一刷 (2022/02/25)

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        while(m > 0 && n > 0){
            if(nums1[m-1] >= nums2[n-1]){
                nums1[m+n-1] = nums1[m-1];
                m -= 1;
            }
            else{
                nums1[m+n-1] = nums2[n-1];
                n -= 1;
            }
        }
        while(n > 0){
            nums1[m+n-1] = nums2[n-1];
            n -= 1;
        }        
    }
};

說明

這題我們可以先注意題目的敘述：
最需要思考的部分在於「題目希望最後的結果直接儲存在 nums1 裡面」

雖然這樣的限制會使我們解題更加的「受到限制」，但反過來說，
其實這也是題目給我們「最大的提示」。

所以這邊可以推斷出一定要「從後面開始解」，「從最無痛的 0 開始取代」，

邊際情況處理

這題要注意的邊際情況為 m=0, n=0 的時候我們要怎麼處理，
而照題目的敘述，

n=0 基本上對我們來說沒差，因為 m 控制的 nums1 即代表我們要的答案

m=0 才是重點，如果還有剩餘的 n，都需要擺入 nums1 中，而位置索幸很好取得，依然可以透過 m+n-1 算出

注意 index 細節，才是這題要考細心的部分

這題有很多 index 細節考驗著作答者的細心度，
包含：

迴圈的範圍僅限於 m, n > 0 時，其他需要進例外處理
m-1, n-1 才是當下座標
要擺入的位置為 m+n-1
處理到 n > 0 就應該停下，而非 n >= 0

Reference

Python easy to understand in-place solution

【Leetcode】C++ - [217] Contains Duplicate 個人解法筆記 — set / unordered_set 用法整理

Thu, 24 Feb 2022 03:37:54 +0800

題目出處

217. Contains Duplicate

難度

Easy

題目分類

Array, Hash Table, Sorting

2022-02-24 一刷

個人範例程式碼 - 一刷 (2022/02/24)

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        // unordered_set set
        // Hash table | RB-tree
        // (unordered) | (ordered)
        // insert and search fast O(1) | search fast only when data less
        // memory use more | memory use less
        //
        // set: ordered, print as ascend, need know n-1...
        // unordered: no-sort needed, single lookup, only insert, delete, search
        set<int> s(nums.begin(), nums.end());
        // for(auto it = s.begin(); it != s.end(); it++)
        //     cout << *it << endl;
        return nums.size() != s.size();
    }
};

說明

這題考的東西很簡單，就是找有沒有重複的東西，
「找重複」非常適合使用 set 來做，我們只需要比較 set 之後的大小是否等於原長度即可。

C++ set 用法整理

set, unordered_set 的差別

說到 C++ 的 set，我們可以先來比較 set, unordered_set 的差別，

	set	unordered_set
實現方式	RB-tree	Hash table
順序	ordered	unordered
速度	search fast only when data less	insert and search fast O(1)
空間使用	memory use less	memory use more
使用場合	ordered/ print as ascend(descend)/ need know realtion of n-1, n-2...	no-sort needed/ single lookup/ only insert, delete, search

vector 轉 set, vector to set

剛好此題目有需要 vector 轉 set，
我們這邊示範一下如何轉換這樣的資料結構。

而轉換的過程中，重複的部分會因為 set 的特性自然地消失，
因此在這題目中我們能夠自然地知道有沒有重複的內容。

vector<int> v;
set<int> s(v.begin(), v.end());
for(auto it = s.begin(); it != s.end(); it++)
    cout << *it << endl;

如何印 set, how to print set

如果我們使用一般的 for 迴圈，因為 set 不具有「順序性」
(這裡指的不是有沒有 unordered 的問題，而是資料結構本身)
我們沒有辦法用 index 的方式去呼叫，類似 set[0], set[1]…

因此我們會需要宣告一個 iterator 幫助我們遍歷這個資料結構!
以下示範剛好結合 vector 轉換 set 的內容：

vector<int> v;
set<int> s(v.begin(), v.end());
for(auto it = s.begin(); it != s.end(); it++)
    cout << *it << endl;

補充一個類似的 map, unordered_map

map 就類似 python 中的 dict (抱歉作者比較熟 python XDD)，
總之就是有「key-value」 pair 的資料結構

	map	unordered_map
實現方式	RB-tree	Hash table
順序	ordered	unordered
速度	慢 (但效率穩定)	快
空間使用	節省 memory	使用較多 memory
使用場合	元素自動排序	元素不需要排序/ only insert, delete, search/ 不需要擔心 memory 使用

Reference

【Leetcode】python - [15] 3Sum 個人解法筆記

Fri, 02 Apr 2021 00:27:36 +0800

題目出處

15. 3Sum

難度

Medium

題目分類

Array, Two Pointers, Sorting

2022-04-06 二刷

個人範例程式碼 - two pointers (第二次解：2022/4/6)

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []
        for idx, target in enumerate(nums):
            if idx > 0 and nums[idx] == nums[idx-1]: # prevent duplicate
                continue
            ans = self.two_sum(nums, ans, idx+1, len(nums)-1, -target)
        return ans


    def two_sum(self, nums, ans, start, end, target):
        last_ans = []
        while(start < end):
            if(nums[start] + nums[end] == target):
                if [-target, nums[start], nums[end]] != last_ans: # prevent duplicate
                    last_ans = [-target, nums[start], nums[end]]
                    ans.append(last_ans)
                start += 1
                end -= 1
            elif(nums[start] + nums[end] < target):
                start += 1
            else: # if(nums[start] + nums[end] > target):
                end -= 1
        else:
            return ans

算法說明

3Sum 可以當作是 2Sum 的進階版，
而變化的部分在於 target 的變化變成可以動態的，

可以視為：3Sum = 2Sum + 「動態 target」

因此我們可以沿用 2Sum 的作法，
並把 2Sum 中 target 改為動態的尋找。

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

處理 input 為 [] 的情況，應該要輸出 []。
處理 input 為 [0, 0, 0] 的情況，應該也要輸出 [[0, 0, 0]]。

Boundary conditions

有幾個重點：

防止重複 1 : 「a <= b」 <= c

防止重複的第一個部分，就是避免重複數值時，
a, b 都被重算，我們都統一取第一個去運算。

此外需要特別注意：因為判斷式為「nums[idx] nums[idx-1]」，需要再多判斷一個「idx > 0」。

if idx > 0 and nums[idx] == nums[idx-1]: # prevent duplicate
    continue

防止重複 2 : a <=「b <= c」

這邊基本上我們統一拿來結果來判斷，只要 b, c 組合不相同，就視為不同的解。

3. two pointers: start < end，交錯或等於就結束

two pointers 的基本結束條件。

2021-04-02 一刷

個人解法筆記 - (第一次解：2021/4/2)

這題是第 1 題的延伸題目，這次我們要處理 3數之和的問題。

大概念

我們將這個題目看成，「任兩數和」等於「負的第三數」
「負的第三數」我們稱之為我們要的 target
為了更乾淨我們處理的順序，我們會先進行「排序」

示意圖：

TwoPointers

在排序後，我們選定 target，我們使用 TwoPointers，
從左 ( l ) 開始小往大掃、從右 ( r ) 開始大往小掃，
當左( l ) 大於等於右( r ) ，也就是交錯甚至超過。
就是我們的終止條件。

示意圖：

重複處理 case1 : target 的重複

重複時的選擇：我們選擇第一個 target。

除了 target 重複會造成重複解答之外，
選擇第一個也能夠保證當解答中有與target重複的數值也能被我們考慮到。

示意圖：(處理 target 的重複)

可以觀察 i 與 target 的變化，仔細思考，可以得到一些心得：

重複處理 case2 : r, l 選到值的重複

重複時的選擇：我們選擇「l」的第一個值，r不同時處理。

因為，當我們得到答案並更新「l」之後，對應的 nums[r] 直接不成立。
思考時，只需要思考單邊重複如何處理即可。 (多思考會錯，可以見下面錯誤區)

選擇第一個值的原因是，我們預期「剩下的值」有可能存在答案。
而當找到答案時，我們再將「l」移至下一個值 (也就是說，反覆 l+1 直到值不同)

這樣才能處理極端狀況：[0, 0, 0]

示意圖：(處理 l, r 的重複)

個人範例程式碼 - 一刷 (2021/04/02)

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []

        # decide target
        for i in range(len(nums)):
            if(i > 0 and nums[i-1] == nums[i]): # when same target, only calculate first 
                continue # go to next loop
            target = -nums[i]
            # print(f"i = {i}, target = {target}") # debug

            l = i+1
            r = len(nums)-1

            while(l < r and l < len(nums) and r >= 0): # normal condition
                # print(f"l = {l}, r = {r}") # debug
                if nums[l] + nums[r] == target:
                    ans.append([nums[i], nums[l], nums[r]])
                    l += 1
                    while l < r and nums[l] == nums[l-1]: # when same value, only calculate first
                        l += 1 
                elif nums[l] + nums[r] > target: # need smaller, r - 1
                    r -= 1                  
                else: # nums[l] + nums[r] < target: need bigger, l + 1
                    l += 1        

        return ans

「錯誤紀錄」手繪筆記

重點：錯誤錯在兩邊同時尋找，無法解[0,0,0] 這個 case!

這題是第 1 題的延伸題目，這次我們要處理 3數之和的問題。

大概念

示意圖：

TwoPointers

示意圖：

重複處理 case1 : target 的重複

重複時的選擇：我們選擇第一個 target。

除了 target 重複會造成重複解答之外，
選擇第一個也能夠保證當解答中有與target重複的數值也能被我們考慮到。

示意圖：

重複處理 case2 : r, l 選到值的重複

重複時的選擇：我們選擇最後一個值。

選擇最後一個值的原因是，我們預期「剩下兩個值」的組合應該會不同。
所以我們只看最後一個。

~~而且，就算真的重複了。(例如極端狀況：[0, 0, 0])~~ (此方法並沒有辦法處理)
我們也會先進行 -target = nums[l] + nums[r] 的檢查後，
抓出這樣的極端情況。

示意圖：