Hash Table on 跟著 Desolve 學程式

從LeetCode學演算法 - 109 Array (15) / Hash Table (11)

Fri, 08 Jan 2021 00:00:00 +0800

1640. Check Array Formation Through Concatenation (Easy)

寫在前面

好久不見！筆者最近剛換了工作，
所以比較忙一點XD 之後1月中會有HiSKIO 技術年貨節的活動，
歡迎大家拿著折價券來修從LeetCode學演算法的課程喲！
如果預算不夠，相信這108篇也還是很夠讀者練習的啦XDD

在更之後還有規劃0元挑戰賽的部分，
只要修課後一定時間內成功錄取新工作 ，
課程就會全額退費喲！ 這部分再請留意官方那邊的公告，
如果有開始的話，文章中也會再提醒各位。

抽獎活動還在繼續累積人數(現在好像沒有人想抽XD)
在Python Taiwan的連結第100篇的文章 底下，
公開分享到你的臉書、按讚該篇文章、並留言告訴我說，
「你最喜歡這一整個系列的哪一篇？為什麼？」或
「除了從LeetCode學演算法系列以外，
你還想要看到關於什麼方向的文章？」
超過20則留言的話 (有完成以上步驟的才算)，我們就抽一組
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」
課程的免費兌換券進行贈送！

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

容筆者工商一下，
「從Leetcode學演算法｜進階篇」 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/leetcodeadv

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

Question

You are given an array of distinct integers arr and an array of integer arrays pieces, where the integers in pieces are ** distinct**. Your goal is to form arr by concatenating the arrays in pieces ** in any order**. However, you are ** not** allowed to reorder the integers in each array pieces[i].

Return true if it is possible to form the array arr from pieces. Otherwise, return false.

Example 1

1
2


Input: arr = [85], pieces = [[85]]
Output: true

Example 2

1
2
3


Input: arr = [15,88], pieces = [[88],[15]]
Output: true
Explanation: Concatenate [15] then [88]

Example 3

1
2
3


Input: arr = [49,18,16], pieces = [[16,18,49]]
Output: false
Explanation: Even though the numbers match, we cannot reorder pieces[0].

Example 4

1
2
3


Input: arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
Output: true
Explanation: Concatenate [91] then [4,64] then [78]

Example 5

1
2


Input: arr = [1,3,5,7], pieces = [[2,4,6,8]]
Output: false

Constraints

1 <= pieces.length <= arr.length <= 100
sum(pieces[i].length) == arr.length
1 <= pieces[i].length <= arr.length
1 <= arr[i], pieces[i][j] <= 100
The integers in arr are distinct .
The integers in pieces are distinct (i.e., If we flatten pieces in a 1D array, all the integers in this array are distinct).

分析/解題

給定一個陣列arr，當中有不同的整數們，
以及另一個整數陣列的陣列pieces(好饒口XD)，
當中所有的pieces中的整數也都是相異的，
我們的目標就是要將pieces拼接成arr，
但pieces中要怎麼接順序都沒關係，
但每一個pieces中的子陣列中的順序不可以被調換 。
(例如arr = [15,88], pieces = [[88],[15]]，
可以先拚[15]再拚[88]從而組出arr，可回傳true；
但arr = [49,18,16], pieces = [[16,18,49]]的話，
因為[16,18,49]內不能夠調換順序，所以只能回傳false)

如果拚得起來就回傳true，否則回傳false。

條件限制：

arr的長度和pieces的長度均為1~100之間(後者小於前者)。
pieces的所有子陣列長度總和，和arr陣列長度相等。
arr和pieces的所有子陣列中的元素值均在1~100之間。
arr中的所有整數均為相異。
pieces中的所有整數均為相異。

根據條件限制的部分，我們可以簡單得到，
反正要能對上的話，因為總個數剛好相等，
所以不存在第二種對應方式 ！
既然不存在第二種對應的方式，
那麼我們在arr中看到一個開頭時，
我們應該只要在pieces中找那個值 ，
就知道該對上pieces中的那一個子陣列囉！

那麼，我們該怎麼樣去找對應呢？
每次都掃過一輪去找，時間複雜度感覺會很糟糕，
那麼，想要迅速的找到對應的位置，
我們就會想到利用HashTable的概念。
因此，在Java使用HashMap，Python中則使用dictionary，
就可以讓我們使用O(1)的複雜度進行存取(不過前面要先花O(N)來存喲！)

這邊我們可以選擇將每個(pieces[i][0], i)的對應存入，
這樣在搜尋時，我們就知道接下來要拚入哪一組子陣列囉！

接著我們需要遍歷整個arr，
每次先拿第一個值去搜尋到對應的pieces，
接著依序一個一個去對照兩邊的值是否相等。
如果找不到對應或者是值不相等，就表示無法對應成功囉！
(可以直接回傳false)
如果全數拚完都沒問題，自然就可以回傳true。

依此，寫成程式碼如下：

Java Java的部分，我們使用HashMap來記錄，

記得使用put(key, value) 的形式！
(因為沒有重複的問題，所以也不需要檢查)

接著我們利用cnt來進行遍歷的紀錄，
這邊不要忘記先檢查 能不能找到arr[cnt]啊！
(因為有可能找不到，直接用get會有exception的！)
另外，由於get出來是Integer，
這邊我們使用(int)來將其轉型回一般的int 。
其他就依序處理即可。

Python

Python的部分，字典和list的操作方式差不多，
不過還是不要忘記先檢查喲！
另外對初學的讀者提醒一下，
Python中沒有++或–這種方便的遞增/遞減方式 ，
所以請乖乖使用cnt += 1或cnt = cnt + 1 。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(pieces的子陣列個數，最大為N))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

想看看其他題目嗎？
歡迎從第零篇 找你想要的！

同時追蹤粉專以獲得更多新文章的通知：
跟著Desolve學程式

另外，「從Leetcode學演算法｜基礎篇」 已經回原價囉，
先前的優惠碼會失效，但這邊仍然為讀者保留了300塊的折抵，
雖然整捆一起買總體比較划算 (差290而已就有整組了阿XD)，
如果你還是想先試試基礎課的話，
300元折抵的連結 在這邊：
https://bit.ly/1desolve

從LeetCode學演算法 - 94 Hash Table (10)

Sun, 24 May 2020 00:00:00 +0800

0438. Find All Anagrams in a String (Easy)

Question

Given a string s and a ** non-empty** string ** p**, find all the start indices of ** p**’s anagrams in ** s**.

Strings consist of lowercase English letters only and the length of both strings s and ** p** will not be larger than 20,100.

The order of output does not matter.

Example 1

1
2


Input:
s: "cbaebabacd" p: "abc"

1
2


Output:
[0, 6]

1
2
3


Explanation:
The substring with start index = 0 is "cba", which is an anagram of "abc".
The substring with start index = 6 is "bac", which is an anagram of "abc".

Example 2

1
2


Input:
s: "abab" p: "ab"

1
2


Output:
[0, 1, 2]

1
2
3
4


Explanation:
The substring with start index = 0 is "ab", which is an anagram of "ab".
The substring with start index = 1 is "ba", which is an anagram of "ab".
The substring with start index = 2 is "ab", which is an anagram of "ab".

分析/解題

給定一個字串s及一個非空的字串p，
試找出所有在p在s內的所有異位構詞(anagram)的起始的索引值。
本題當中的字串僅含小寫英文字母，且s和p的長度分別不會大於20, 100.
(但不用在意輸出的順序)

我們先前已經提過anagram的定義了，詳情可見0242. Valid Anagram (Easy) 。簡單來說，anagram是指說兩個字串是由相同的字元組成的，
只有順序可能不同而已。

我們先假設我們拿到兩個字串，要檢查它們是不是互為anagram，
端看它們的’a’出現的次數，’b’出現的次數，’c’出現的次數…,
‘z’出現的次數是否相同即可。
這個儲存兩者出現的次數，可以使用HashTable來計算，
而且由於我們要分的內容很簡單，所以只需要小寫字母個數26個即可，
也就是Java可以使用一個長度為26的一維陣列，
Python可以使用串列，要使用字典也行(相當於HashMap)。

回到我們的問題，我們想要在s當中找到一個子字串，
使得這個子字串和p互為anagram，
這時候應該可以先將p的各字母出現次數先行記錄下來。
接下來從s的index 0開始往右 ，一路計算走到可以取p的長度為止，
如果這段能和p的組成內容相同，那就可以記做其中一個解。

為了要比對是否組成內容相同，
我們可以將每次看到的字母從p的hash table中扣除掉 ，
當所有整個hash table都歸零的時候，我們就知道當前的組成相同了。
但為了不需要每次都檢查整個hash table，
我們可以先行設定一個cnt變數，其值等於p的長度。
每次碰到可以扣除的組成就將cnt遞減，
這樣當cnt為0且當前長度為和p長度相等時，就知道取得一個解了。

接下來，我們需要一個left和一個right的索引值來記錄。
由於長度固定就這麼長，當我們已經來到左右距離p的長度時，
我們可以將left和right各自往右移動一格 。
同時left移出

舉例來說假設：
s: “ecba ebabac d” p: “abc”
(這邊將Example 1前面多加一個字元比較容易看出不同)

(left, right, cnt) : (0, 0, 3) -> (0, 1, 3) -> (0, 2, 2) -> (0, 3, 1)
沿路會檢查’e’, ‘c’, ‘b’，每次碰到的字母會從p的hash table中扣掉，
不過cnt這樣只會降到1，表示沒有成立anagram 。
(left, right, cnt) : (0, 3, 1) -> (1, 4, 0)
將left往右移一格，’e’就出範圍外了(hash table要加回來)，
接著right往右移一格，’a’進入範圍內，且符合p的hash table擁有的子母，
所以cnt會從1降為0，同時範圍長度相符，
表示這是其中一個解，將1加入到我們的答案範圍中。
(left, right, cnt) : (1, 4, 0) -> (2, 5, 1) -> (3, 6, 2) -> (4, 7, 3)
依序移出範圍，如果發現加上去前hash table該值有≥0的話，
表示有移出p原有的字母，所以我們要將cnt進行遞增。
(left, right, cnt) : (4, 7, 3) -> (5, 8, 2) -> (6, 9, 1) -> (7, 10, 0)
同樣經歷了一個cnt等於0且長度等於p的範圍，
將7 加入答案當中。
(left, right, cnt) : (8, 11, 1) -> right超過，停止檢查。

所以按上面這個範例的output就會是[1, 7]。

這個題目由於我們中途開始的left和right呈現一個固定距離的狀態，
只是隨著遞增滑動，所以這種固定窗口大小並且移動的方式，
一般稱為Sliding Window 。
(也可以視為Two Pointer在某種狀態的條件限定)

依此，我們可以寫成程式碼如下：

Java

Java的部分，參考了一位leetcode上的解法，
我們使用一個ArrayList來儲存我們的答案，
並且前期的檢查可以分別檢查s, p是否為null或空，
以及s的長度不能小於p的長度才行(不然要怎麼組對吧XD)

接著，我們使用一個長度26的一維陣列，
也可以使用ASCII長度256直接存，我們使用26的長度時，
index使用c-’a’即可對應。

初始化left, right, count後，迴圈條件設定為right還沒有超出去範圍。
迴圈內的判斷式則利用++和–的特性，
(放後面時會先進行完整個操作才遞增/遞減)，
其他的重點做法跟前面的描述是一樣的，
讀者可以再自己嘗試在紙上推導一次，會更加清楚。

Python

Python的部分我們示範使用字典來處理，
由於我們不想要每次在取值時都先檢查值有沒有存在的問題，
(不論是get或者是用[]取值，字典都不會有預設值)
所以這邊先行將26個字母的對應都置入0，後續就不需要再檢查了。 其它的部分跟Java的寫法基本相同，只是沒有++跟- -能用而已XD!

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1)，
空間複雜度如果要算上答案的部分的話則為O(N)，N為s的長度)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(最後一波早鳥優惠了，不確定調回原價是什麼時候)： ** https://hiskio.com/courses/319?promo_code=VE9Q5VE**

從LeetCode學演算法 - 89 Hash Table (9)

Sun, 01 Mar 2020 00:00:00 +0800

1346. Check If N and Its Double Exist (Easy)

Question

Given an array arr of integers, check if there exist two integers N and M such that N is the double of M ( i.e. N = 2 * M).

More formally check if there exist two indices i and j such that :

i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]

Example 1

1
2
3


Input: arr = [10,2,5,3]
Output: true
Explanation: N = 10 is the double of M = 5,that is, 10 = 2 * 5.

Example 2

1
2
3


Input: arr = [7,1,14,11]
Output: true
Explanation: N = 14 is the double of M = 7,that is, 14 = 2 * 7.

Example 3

1
2
3


Input: arr = [3,1,7,11]
Output: false
Explanation: In this case does not exist N and M, such that N = 2 * M.

Constraints

2 <= arr.length <= 500
-10^3 <= arr[i] <= 10^3

分析/解題

給定一組整數陣列，檢查當中是否存在兩個數N, M使得N = 2 * M。
(留意不可使用重複的index)

乍看之下有沒有覺得一陣熟悉？
沒錯，LeetCode最開始的第一題0001.Two Sum 的套路，
跟這個非常的相似，只不過從兩數相加等於固定數，
變成一個是另一個的兩倍。另一方面，我們只要將存在與否輸出，
所以不用記錄是什麼配對 。

那麼，按照先前的做法，我們需要做的事情是：

檢查現在的值有沒有符合之前的配對 ，若有，就直接回傳True即可。
(先前使用HashMap/Dictionary，這次可以使用HashSet/Set)
將當前的值對應到的配對 擺進Set當中，
由於當前的值x對應到之後的y有可能是 x = 2 * y 或 y = 2 * x，
所以我們要一次將兩種可能都放進去。
這樣子整個Set的總大小會變成2N，但不會影響檢查速度。
(因為HashSet/Set同樣是使用hash function的機制)
全部檢查完，仍然沒有符合的狀況，則回傳False。

依此，寫成程式碼如下：

Java

Java的部分，由於限制資料型態，
要留意處理除以2的部分，不能讓它自動做整數除法，
所以先檢查能否被2整除，可以的狀況才將其加入Set中 。
(使用HashSet ，檢查是否存在值使用contains() ，add() 來加入元素)

Python

Python的部分，由於/2直接會變成float，沒有特別被限制，
我們可以直接選擇加入而略過檢查的部分。
(反正小數點也不會被對到嘛XD)
(使用set() 開一個Set，in / not in 來檢查，並用update 來加入多個元素)
(先處理存在或先處理不存在的狀況都可以，看自己的喜好)

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N)，記得乘以2倍空間上是常數，不要講O(2N)歐XD)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 88 Hash Table (8)

Fri, 21 Feb 2020 00:00:00 +0800

0575. Distribute Candies (Easy)

Question

Given an integer array with ** even** length, where different numbers in this array represent different ** kinds** of candies. Each number means one candy of the corresponding kind. You need to distribute these candies ** equally** in number to brother and sister. Return the maximum number of ** kinds** of candies the sister could gain.

Example 1

1
2
3
4
5
6


Input: candies = [1,1,2,2,3,3]
Output: 3
Explanation:
There are three different kinds of candies (1, 2 and 3), and two candies for each kind.
Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too.
The sister has three different kinds of candies.

Example 2

1
2
3
4


Input: candies = [1,1,2,3]
Output: 2
Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1].
The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

The length of the given array is in the range [2, 10,000], and will be even.
The number in given array is in range [-100,000, 100,000].

分析/解題

給定一個偶數長度的整數陣列，當中不同的數字代表不同種類的糖果。
你要將糖果平分給一對兄妹(姐弟)，試算出當中姐姐/妹妹最多能拿到幾種不同種類的糖果。

什麼？題目也偏女生嗎(大誤)

題目內文基本上已經講得相當清楚了，
接下來問題就來到究竟我們要怎麼知道種類有多少種不同呢？
首先，如果每顆糖果都不同種類，女生最多能拿的也只有一半，
所以能拿到的種類上限會受限於candies的總數除以2 。
這個是大前提，我們先將它放在一邊。

那麼，如果種類總數比candies總數的一半小 呢？
簡單的想法就是發糖果的時候，每次遇到沒看過的種類，
就先記起來，藉此將整個種類數計數過一遍。
(或者你也可以想成每次看到沒看過的種類 要優先給女生，
給到女生拿滿或沒有新的種類 為止，兩個思考的模式和條件其實差不多。)

要記錄某種糖果的出現數量，
自然會想到HashTable/HashSet/Dictionary這類的東西，
但由於題目有提到種類是從-100000~100000，
所以其實我們可以開出一個長度為200001的陣列/串列，
直接當成Hash Table來使用，只要位移個100000即可。
(陣列/串列要從0開始)

因此，我們每次就可以從candies中依序取出一個數字，
將Hash Table內的對應位置進行遞增，再看看加完後是否剛好是1，
是1就代表這是新種類的糖果，所以要將種類的變數加1。

最後再回頭比較種類的數量，跟糖果的總數的一半，
選擇較小的進行回傳即可。

依此，寫成程式碼：

Java

Python的部分，我們也可以用set的方式取得不重複的種類，
再取其len()即可得到不重複的種類數量。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N)，如果將空間固定成題目給定的限制的話，
會固定要開出一個200001的空間，這個可以再直接用說的。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 86 Hash Table (7)

Wed, 05 Feb 2020 00:00:00 +0800

1331. Rank Transform of an Array (Easy)

Question

Given an array of integers arr, replace each element with its rank.

The rank represents how large the element is. The rank has the following rules:

Rank is an integer starting from 1.
The larger the element, the larger the rank. If two elements are equal, their rank must be the same.
Rank should be as small as possible.

Example 1

1
2
3


Input: arr = [40,10,20,30]
Output: [4,1,2,3]
Explanation: 40 is the largest element. 10 is the smallest. 20 is the second smallest. 30 is the third smallest.

Example 2

1
2
3


Input: arr = [100,100,100]
Output: [1,1,1]
Explanation: Same elements share the same rank.

Example 3

1
2


Input: arr = [37,12,28,9,100,56,80,5,12]
Output: [5,3,4,2,8,6,7,1,3]

Constraints

0 <= arr.length <= 10^9
-10^9 <= arr[i] <= 10^9

分析/解題

給定一個陣列，將其依照大小順序排出rank。
(由1開始，大小相同則相同rank，數字越大，其rank則越大)

由於我們需要按照大小相同來排定rank，所以顯然我們需要將其排序後，
才能知道誰應該在第幾個。對於這樣子的題目，
一般而言我們不需要自己實作排序的過程，除非面試官要求，
否則說明清楚你使用了排序即可；
不要忘記對於沒有特別安排的資料結構，
一般程式語言所使用的排序法基本上都是O(N log N) 的時間複雜度，
所以最後在問複雜度時記得納入考量。

既然我們需要取代原先的陣列，所以我們必須另外增加一組記憶體空間，
用來存放排序的狀態。存放好以後，應該要怎麼去記錄呢？
由於相同的數字要擁有相同的rank，對於存取和讀出擁有最快的複雜度的，
就是Hash Table了！我們可以先檢查當下該數字是否已經放入對應 ，
若還沒有放入對應，則需要寫入(number, rank)的對應。
這時候rank是多少呢？應該要將已經置入的配對數量+1 來計算。
(因為代表現在已經給到多少數量的rank了)
都放完以後，再依序將陣列中的每個值作為key，
來從Hash Table得到其對應的rank(value)，再覆蓋掉即可。

依此，寫成程式碼：

Java

Java在增加新的記憶體儲存一份陣列時，可以使用Arrays.copyOf() 。
(後面加length可以指定複製的總長度)
使用HashMap來進行存放，並且用putIfAbsent(key, value) ，
僅在不存在對應時才進行寫入。
最後再利用HashMap.get()來一一取得對應rank並寫入。

Python

Python的部分，我們可以直接使用sorted(arr)取得一份新的串列。
也可以使用list.copy() 或者arr[:] 的方式來取得複製的串列。
請注意 “sArr = arr” 和 “sArr = arr[:]“意義上是不同的，
後者才是完整複製一份arr的串列 ，前者是新增了一個變數名稱，
但其記憶體位址依舊是指向到arr的！(也就是後者並沒有進行複製)

Java中使用HashMap，在Python中則用Dictionary達到，
而對應到putIfAbsent的函式則是setdefault 。
(也可以用if ** a not in rk: rk[a] = len(rk) + 1**)

最後，使用map函式來一一得到arr對應到rk.get的內容。
(即每次從arr依序取出元素再代入到rk.get內)

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(NlogN)/O(N))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 79 Hash Table (6)

Tue, 31 Dec 2019 00:00:00 +0800

0383. Ransom Note (Easy)

Question

Given an arbitrary ransom note string and another string containing letters from all the magazines, write a function that will return true if the ransom note can be constructed from the magazines; otherwise, it will return false.

Each letter in the magazine string can only be used once in your ransom note.

Note:
You may assume that both strings contain only lowercase letters.

1
2
3


canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

分析/解題

繼時空旅人買賣股票( 0121 ) 及闖空門教學( 0198 , ** 0213**** )後，
我們這次要來寫勒索信** 啦！
有沒有覺得這一系列很實用？(大誤)

勒索信的構成很簡單，就是每個從雜誌上的字，
剪下來以後只能用一次 ，要用這些字去組出勒索信的內容。

所以這個就很簡單就可以處理啦！
我們可以先將所有雜誌上的字分門別類，
這邊還很貼心告訴我們全部只有小寫字母 ，
所以分成a-z即可，計算總共有的素材數量。

接下來用勒索信上的每個字來去檢驗，
每次都扣除掉對應的字母的計數，中間一旦有素材不夠，
表示已經沒辦法完成信件，即可回傳false，
否則整個迴圈完成的話表示可構成勒索信，則回傳true。

依此可以寫成程式碼。

Java

Java的部分，其實如要扣掉一些條件，
可以先檢查兩者的長度，magazine長度比較小時肯定無法完成勒索信。
由於題目的給定，我們可以不用HashMap，
僅用一個長度26的陣列來處理，index則用c - ‘a’ 來計算，
留意使用–table[c-‘a’]時由於先進行遞減 ，所以檢查條件是小於0。

Python

Python的部分，可以用dictionary作到類似的事情。
(list也可以，不過要自行用ord來轉換，和Java不同)
當然，我們也可以使用Counter或count來做更迅速的計算。
(註解提供了另外兩種leetcode上別人的解法)

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(len(ransomNote) + len(magazine))/O(1))
(空間複雜度因為依題目提示，key值固定最多26，
所以不因字串長而改變。)

「如果要求含大小寫/大小寫可混用/含標點符號等狀況呢？」
(依照所需使用HashMap或Dictionary，
並將共用的部分利用他們相減的距離歸到同類)
(在ASCII Code上，‘a’-’A’ == 32 )

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(接下來快要漲成下個價格啦XD)： ** https://hiskio.com/courses/319?promo_code=VEQZV7E**

從LeetCode學演算法 - 76 Hash Table (5)

Sat, 21 Dec 2019 00:00:00 +0800

0290. Word Pattern (Easy)

Question

Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a ** non-empty** word in str.

Example 1

1
2


Input: pattern = "abba", str = "dog cat cat dog"
Output: true

Example 2

1
2


Input:pattern = "abba", str = "dog cat cat fish"
Output: false

Example 3

1
2


Input: pattern = "aaaa", str = "dog cat cat dog"
Output: false

Example 4

1
2


Input: pattern = "abba", str = "dog dog dog dog"
Output: false

Notes:
You may assume pattern contains only lowercase letters, and str contains lowercase letters that may be separated by a single space.

分析/解題

給定一個pattern和一個字串str，檢查str是否遵循pattern的模式。
簡單來說，就是str的每一段字的重複或不重複模式，
都要能被pattern裡的"abba"這樣的每個字母去對應 的方式來表達出來。
看到這邊，有沒有覺得很像LeetCode最開始的那個Two Sum?
我們每次想要將一個pattern內的字母去對應到str的一段字串，
而重複的狀況應該要有相同的對應。

那不就是key-value的對應方式嗎?

所以想法就很簡單了：

建立一個Hash Table名為map(Java的HashMap或Python的Dictionary)
先檢查pattern的段數和str的段數是否相同 ，若否則直接回傳false
依序按段取出 pattern和對應的str的分段，檢查以下性質：
(下面pattern均作為key，str的分段均作為value)
若key不存在且value不存在->將**(key, value)** 放入map
若key不存在且value存在->回傳false (** 表示別人先對應到它了**)
若key存在且value不對->回傳false (** 表示該key已經被占用掉**)

請留意後面的兩個false的狀況，
我們可以對照Example 2 跟Example 3 ，
因為有些可能是前面某個key或某個value已經達成對應關係了，
後續如果出現對不上的狀況，就表示整個對應關係無法成立囉！

依此，寫成程式碼如下：

Java

Java的部分，
可以使用HashMap的containsKey/containsValue/get，
以及字串的split/equals函式，來協助判斷的工作。

Python

Python方面，同樣有split可以使用，
其他使用dict的in/not in及values()等簡單的存取方式即可。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N)，準確來說應該是看len(str)來決定N)

「如果限制使用split呢？」
(進行依字元掃瞄過整個陣列，碰到空白再輸出成字串(list或arraylist)即可)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(額滿即截止)： ** https://hiskio.com/courses/319?promo_code=VEQZV7E**

從LeetCode學演算法 - 71 Hash Table (4)

Tue, 26 Nov 2019 00:00:00 +0800

0205. Isomorphic Strings (Easy)

Question

Given two strings *s * and *t *, determine if they are isomorphic.

Two strings are isomorphic if the characters in *s * can be replaced to get *t *.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.

Example 1

1
2


Input: s = "egg", t = "add"
Output: true

Example 2

1
2


Input: s = "foo", t = "bar"
Output: false

Example 3

1
2


Input: s = "paper", t = "title"
Output: true

分析/解題

給定兩個字串s和t，試判斷它們是否同構(isomorphic)
若s和t同構，表示可以透過將s中的相同的字元轉換成另一個字元，
保有其順序，使得在轉換過後的s和t完全一樣。
兩個不同的字元不可映射到相同的字元 ，
但一個字元可以映射到原來的字元(也就是不變)。

這個題目簡而言之，就是在找尋用特定方式轉換對應字的方法，
比如範例中的paper -> title有以下的轉換對應：
p <-> t, a <-> i, e <-> l, r <-> e

由於同構並沒有限制轉換方向，所以既要轉得過去，也要轉得回來，
這代表了他們對應必須要1對1才行。
因此，我們可以想到以下的方式：

先檢查兩邊長度，不相等則直接回傳False (怎麼轉都沒用XD)
可以選擇建立一個HashMap/Dict 並額外處理雙向 的對應檢查，
或者選擇開出2個陣列/Dict(也可用串列，不過要自己轉換) 來做檢查。
每次從s, t中各取出一個字元 (假設現在在index i )：
3-1. 兩字元都未進入 陣列對應 -> 將s[i] 與t[i] 放入兩個陣列的對應
3-2. 兩字元都進入 陣列對應 -> 檢查s[i] 是否對到t[i] ，t[i] 是否對到s[i]
(只要其中一個對錯或沒對到，即可判定為False )
當所有字元均檢查完，表示順利全數對應到，回傳True 。

簡單吧！
在Java的部份，
我們可以直接利用char可以自動轉換成int當作陣列的index。
沒有對應則會拿到預設值(0)，依此寫成以下程式碼：

Java

Python的部份，方便起見我們使用了dict來紀錄，
預設值使用get放入0。

另外提供一個特別的用法，可以使用maketrans 及translate ，
來進行兩個表的轉換。但由於中間可能有重複，
所以要先經過set(刪去重複)和list, join 以後，
重新依照原先的字母排列排序(用key＝s.index) ，
最終看看s經過轉換以後是否和t相同。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N), 但空間複雜度最高取決於實際用到的字數，
亦可視為O(1)，因限縮在ASCII Code的話也才128種類)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
限額早鳥連結： https://hiskio.com/courses/319?promo_code=13L5QJE

問卷抽書＆取得上架通知： https://pse.is/MS2J2
如果你對線上課程不放心，
也可以先來12/17(二) 我在天瓏分享的講座看看！
講座連結： https://pse.is/JS3LJ

從LeetCode學演算法 - 49 Hash Table (3)

Fri, 13 Sep 2019 00:00:00 +0800

0217. Contains Duplicate (Easy)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

Example 1

1
2


Input: [1,2,3,1]
Output: true

Example 2

1
2


Input: [1,2,3,4]
Output: false

Example 3

1
2


Input: [1,1,1,3,3,4,3,2,4,2]
Output: true

分析/解題

給定一個整數陣列，若陣列有任何重複的數，則回傳true，否則回傳false。

今天來點簡單的，畢竟中秋節嘛XD
和之前找出單一元素的題目不同，因為這題沒有限定重複出現的次數 ，
所以並不適用於bitwise operation 的方法。

以暴力法來說要O(N²)，排序後再比要O(NlogN) ，
均不理想，所以一般常見的想法是，
一樣引入hashmap或dictionary 來解題。

而由於我們只在意數字有沒有出現 ，對於Java來說，
還有另外一個名為HashSet 的方式可以使用。
HashSet在新增方面複雜度同於HashMap均為O(1) ，
但HashSet同時具備Set的特性，同個資料只能出現在Set當中一次 ，
若有相同資料要被新增時，則新增會失敗(回傳false) ；
我們可以利用這點，每次對HashSet新增當前的數字，
失敗則代表已經出現重複了(直接回傳true)，
若全數新增完畢則代表不存在重複(回傳false)。

Java

Python的set新增時碰到重複的資料時不會進行任何動作 ，
所以這邊還是使用dictionary。
另一種作法是可以使用set來進行化簡後，直接檢查總長度是否改變 ，
即可知道是不是含有重複的元素。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(N)，因為每次插入均為O(1))

「如果限制不用HashSet/Dictionary，但給你nums值的範圍呢？」
(建立一個array/list，總長為整個範圍，
將其拿來做為輔助陣列使用即可。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 41 Hash Table (2)

Wed, 28 Aug 2019 00:00:00 +0800

0242. Valid Anagram (Easy)

Example 1

1
2


Input: s = "anagram", t = "nagaram"
Output: true

Example 2

1
2


Input: s = "rat", t = "car"
Output: false

Note:
You may assume the string contains only lowercase alphabets.

Follow up:
What if the inputs contain unicode characters? How would you adapt your solution to such case?

分析/解題

給定兩個字串s跟t，
寫出一個函式來判斷t是否是a的一個anagram(易位構詞)。

所謂的anagram就是指將這個字串的字母搬動順序以後，
可以組成另一個字串的遊戲，這在很多推理小說裡都有出現過，
比如達文西密碼或者哈利波特XD

那麼，怎麼確切知道s跟t是否是彼此的anagram呢？
我們比較幸運只需要檢查正確與否就好，所以一般常見的解法有幾個：

排序(暴力?)法
既然完全是由相同的字母及相同使用字母的個數組成，
那就代表只要將兩個字串進行排序，最後它們會長得一模一樣 。
但這樣作的時間複雜度為O(n log n)(n為字串長) 。
雖然能夠通過測試，但似乎不是很理想。
Hash Table 法
上次我們已經介紹過了Hash Table的概念，那麼這次我們應該也可以使用相同的方式來處理。由於題目已經告知字串僅含小寫字母，也就是a-z，
只要依序掃瞄過兩個字串，將字串所含每個字母的個數計算是否相等，
即可判定結果。
這麼作只需要O(n) 的時間複雜度，空間部分只需要O(1) 。
(因為是26個字母 ，所以陣列長是固定的)

我們可以利用上一次提到的ASCII的方式，
來對a-z 的部分位移到一個計數陣列的0到25 ，
同時，掃過s 的時候將對應的字母計數遞增 ，
掃過t 時將對應的字母計數遞減 ；
一旦有字母是遞減到小於零 的話就可以直接判定s和t彼此並非anagram。

Java的版本完整演示了上述的流程。

Java

Python的部分這邊也可以另外使用別的方法，
這邊提供幾個比較簡便且複雜度一樣的方法：

使用count 跟all 來計算(所以對每個字母都會分別檢查一次)
(all是用來判定所有會迭代的狀況是否全數為TRUE)
使用Counter 計算後再比較(所以會先算完全部再來檢查)

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(n)/O(1))

「如果大小寫視為相同？」
(使用類似Java的方式，但每個字元要先確認是否是大寫，
若是，先將其轉為小寫才往陣列中存放，之後的做法應該是一致的。)
(ASCII中A-Z是65~~90而a-z是97~~122，可以先平移對應的相差量)

「如果還有其他英文字母以外的字元？」
(將陣列改成用HashMap，
key存放字元，value存放出現次數。Python則用Dict即可)

「如果大小寫視為相同，空格及標點符號要省略呢？
(沒錯，就跟達文西密碼的留法一樣，沒人在管標點的XD)」
(可以嘗試刪去不需要的，或只取英文字母的部分。)

相似及延伸

1.0049. Group Anagrams 2.0438. Find All Anagrams in a String

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 39 Array (8) / Hash Table (1)

Sun, 25 Aug 2019 00:00:00 +0800

1160. Find Words That Can Be Formed by Characters (Easy)

Question

You are given an array of strings words and a string chars.

A string is good if it can be formed by characters from chars (each character can only be used once).

Return the sum of lengths of all good strings in words.

Example 1

1
2
3
4


Input: words = ["cat","bt","hat","tree"], chars = "atach"
Output: 6
Explanation:
The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.

Example 2

1
2
3
4


Input: words = ["hello","world","leetcode"], chars = "welldonehoneyr"
Output: 10
Explanation:
The strings that can be formed are "hello" and "world" so the answer is 5 + 5 = 10.

Note:

1 <= words.length <= 1000
1 <= words[i].length, chars.length <= 100
All strings contain lowercase English letters only.

分析/解題

給定字串陣列words和一個字串chars，
如果陣列中的一個字串能被定義為good，
代表它是能由chars的中的字元組成(每個字元最多只能使用一次 )，
試將所有good的字串長度加總回傳。

一般用來描述某個項目儲存多少值都會使用HashTable/HashMap，
對應到Python則通常可使用dictionary。
HashTable相關的儲存方式有搜尋為O(1) 的特性，
和一般常見的搜尋資料結構如Binary Search Tree需要O(log N) 不同，
原因是因為會實作hash function，令不同的值儲存的時候能夠得到不同的hash值，從而直接找到對應的位置。
(但當hash function的選擇不好 ，或儲存的東西太多時，
有機會發生碰撞(collision) 問題，導致查找時間加長，這裡暫不討論。)

在題目的條件限定在英文字母相關的時候或有特定長度限制時，
我們常可以用很簡單的方式來進行hash table/hash map的操作，
例如英文字母a~z只有26個，
如果題目和計算字母出現的次數有關聯性的話，
我們可以直接以一個長度為26的陣列/串列來記錄 。

以這題來說，題目所要求的檢查方式，
就是先確認chars裡面有幾個a, 幾個b, …… , 幾個z ，
接下來對每個字串 確認其組成，
一旦組成需要的個數大於chars所擁有的，我們就可以直接跳過它 ；
反之若每個字母所需的個數都滿足，
則將要回傳的結果加上這個字串的長度，
一直到全數檢查完畢即可回傳結果。

下面Java的程式碼部分演示了上面所提到的步驟。
裡面用到語法蜜糖(Syntactic sugar)的作法，讀者應稍加掌握，
如for迴圈Java有提供連續從array中依序取出單個變數的寫法，
類似於Python中**”for word in words”** 的方式。
我們將check的部分獨立出來，作為檢查並回傳長度的部分，
一旦沒有成立，直接回傳0，若最終檢查通過則將len(word)回傳。

之前應該也提到過char可以使用ASCII的代表數字來加減 ，
所以這邊取a到z來做為index 0到26，起始的基準點是’a’。

Java

Python的部分，使用Counter 可以很簡便的計算一個字串中的字母組成，
我們可以直接檢查每個key的值的大小來確認是否足夠組成，
但需留意Counter並不會放置沒有出現的字母的key，
故每次要先檢查是否dic中本來就沒有現在要檢查的key值，
避免發生錯誤。

更簡便的方式是直接使用count 來計算某個字母在字串裡面出現的次數。
這個應該是目前Python答案中跑最快的方法，
但可能是因為測試資料中比較常出現False的狀況，
導致word不用每個字母都算完就結束了 。
不然在最糟的狀況下，word的每個字母應該都會算一次count，
且相同的字母在不同的位置上還會重新再算過一次；
雖然時間複雜度還是一樣(字串最長限定是100)，
若整份資料比較容易是good的字居多的話，
並不建議用這樣子的方式操作。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(Java: O(N)/O(1)，
準確來說，最大要走完所有字的長度(所以應該可以說N個字*長度L)，
空間的部分，使用了26個字母來做為查表用的分類，
所以同一時間用到的只會有2組長度26的陣列及幾個暫存用變數
Python: 對二個解也都是 O(N)/O(1)，
但第二個解在最差的狀況下會每個字母都重覆掃過。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~