Array on 跟著 Desolve 學程式

從LeetCode學演算法 - 117 Array (17)

Sun, 30 Jan 2022 00:00:00 +0800

0941. Valid Mountain Array (Easy)

寫在前面

2022/03/09: 配合官方修改格式，各項優惠連結3/14之後會失效，
這邊更新新版的連結給大家~**

從 LeetCode 學演算法｜完整解題技巧 + 面試成功指南： https://bit.ly/lc2022all

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

Question

Given an array of integers arr, return true if and only if it is a valid mountain array.

Recall that arr is a mountain array if and only if:

arr.length >= 3
There exists some i with 0 < i < arr.length - 1 such that:
arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Example 1

1
2


Input: arr = [2,1]
Output: false

Example 2

1
2


Input: arr = [3,5,5]
Output: false

Example 3

1
2


Input: arr = [0,3,2,1]
Output: true

Constraints

1 <= arr.length <= 104
0 <= arr[i] <= 104

分析/解題

給定一個整數陣列arr，若且唯若它是一個合格的mountain array時，
回傳true(否則回傳false)。
mountain array的條件要符合以下幾點:

arr長≥3
存在i，0<i<arr.length-1使得:
arr[0] < arr[1] < … < arr[i-1] < arr[i] 且
arr[i] > arr[i + 1] > … > arr[arr.length-1]

為了避免大家隔太久沒有練習(我也是)，而且快過年了不要讓大家太燒腦，
今天我們就介紹簡單一點的題目就好XD！

在LeetCode的題型中，有一些簡單的題目的規格，
會呈現為只要題目讀得懂，按要求做完就會答對的形式，
本題就是相當明確的例子之一。

我們來看看要求：mountain array
前面必須要嚴格遞增 ，後面必須要嚴格遞減 ，
中間的arr[i]值為整個陣列的最高點。
同時限制了長度必須大於等於3，也就是上下坡都必然存在。

那麼解題方式就很明確了：

先檢查長度是否≥3，且arr[0]是否小於arr[1]
(一定要檢查，因為我們希望上下坡都存在 )
從陣列的開頭開始以i計數，往後沿途比較arr[i]跟arr[i+1]，
一路遞增到遞減轉折出現為止(也就是第一個arr[i] >arr[i+1])
在2當中如果出現前後相等 的狀況可直接回傳False，
同時，如果還沒下坡就已經走到底(i + 1 == arr.length) 的話，
也要回傳False 。
沿路下坡，一路走到尾端
如果沿途均符合的話(會走到i + 1 == arr.length )，則回傳true；
如果沿途變平或上坡的話，需在4的位置提早停下，
這樣子就可以藉由是否走到尾端這點來判斷要回傳true或false。

依此，寫成程式碼如下。

Java

可以看到我們在上坡的時候使用迴圈，
每次檢查就做兩件事來確認是否離開迴圈：

是不是走到底了 -> 走到底的話就不對了，因為還沒下坡
是不是有在走上坡 -> 變平的話不對，只有變下坡可以接受

而下坡時只有一路下坡走到底可以被接受。

Python

Python寫法基本上一致，所以說這題不難，對吧XD！
關鍵還是在於是否能確切釐清題目要求，
例如如果沒有寫A[0] ≥ A[1]的檢查的話，
就有可能碰到只有下坡的陣列，從而讓檢查結果出問題喲！

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

「時間/空間複雜度？」
(O(N)/O(1)，這題最多需要掃完整個陣列，
且我們只有多使用一個i的變數。)

相似及延伸

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

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

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

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

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

從LeetCode學演算法 - 110 Array (16) / Greedy Algorithm (1)

Sun, 17 Jan 2021 00:00:00 +0800

0881. Boats to Save People (Medium)

寫在前面

目前0元挑戰賽 的活動已經開始囉！
只要修課後三個月內完課且成功錄取新工作並撰寫心得，
課程就會全額退費喲！請使用下面連結看更詳細的規則說明：

零元求職挑戰賽 Python 組｜從 LeetCode 學演算法 + 面試成功指南 http://bit.ly/zeroclg

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

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

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

Question

The i-th person has weight people[i], and each boat can carry a maximum weight of limit.

Each boat carries at most 2 people at the same time, provided the sum of the weight of those people is at most limit.

Return the minimum number of boats to carry every given person. (It is guaranteed each person can be carried by a boat.)

Example 1

1
2
3


Input: people = [1,2], limit = 3
Output: 1
Explanation: 1 boat (1, 2)

Example 2

1
2
3


Input: people = [3,2,2,1], limit = 3
Output: 3
Explanation: 3 boats (1, 2), (2) and (3)

Example 3

1
2
3


Input: people = [3,5,3,4], limit = 5
Output: 4
Explanation: 4 boats (3), (3), (4), (5)

Note :

1 <= people.length <= 50000
1 <= people[i] <= limit <= 30000

分析/解題

有一群人people，當中第i個人的重量是people[i]，
且每艘船最重可以載重limit，同時最多只能乘載2個人，
乘載的重量最多為limit(剛好的話也可以)
試計算並回傳最少所需裝載所有人的船的數量。

乍看之下，這題是不是有點像以前的Two Sum?
但再仔細想想，就會發現，
由於我們並不一定要每艘船都裝載到limit的重量，
所以並不能夠形成相加等於特定和的關係。

那麼該怎麼處理呢？
如果這群人是由小到大排列的話，
不管如何最重的那些人都還是要上船，
所以我們先挑最右邊的(最重的人)上船。
接下來這艘船還能不能帶人呢？
我們就再幫忙找最左邊的(最輕的人)看能不能湊一組，
可以湊就沒問題，不能湊也無法強求，就只好讓這個人自己一條船囉！
這樣搭配下，我們就可以盡可能先幫較重的人找看看能不能組起來，
因此會是所需求的船隻數量會是最小的。

上面這樣子的概念，被稱為貪婪演算法(Greedy Algorithm) 。
貪婪演算法的核心精神，在於先找到一個方法，
使得每次盡可能都處理所有可以操作的單位，
再依序往下做處理，這樣的方法是對總體來說也是最佳 的時候，
就符合貪婪演算法的特性。
請讀者務必留意，
如果像是動態規劃(Dynamic Programming) 這類型的問題，
就顯然不會符合 貪婪演算法的作法，
因為局部的最佳解，不見得會是全局的最佳解 。

所以對這題來說，當我們排序完這群人以後，
從最重的開始盡可能幫其安排組合，對總體來說就會是最好的。

因此，我們的大體解法應該如下：

先將people由小到大排序
令l = 0, r = people.length - 1, res = 0 (用來記錄需要幾艘船)
使用一個迴圈，當 l ≤ r 時，進行以下操作：
3–1. 如果 people[l]+people[r]<= limit 時，
代表可以捎上index l 的人，此時將** l遞增。
3–2. 由於所有人的重量都一定小於limit** ，(題目說的)
所以people[r]一定可以占一艘船 (不管people[l]有沒有上船)，
所以我們將r遞減 ，並且將res遞增 ，這艘船我們就處理完囉！
回傳res 即為答案。

讀者可能會問：咦？那l和r重疊 的話怎麼辦？
問得好！重疊的話，由於不論怎麼樣r都會遞減，
所以重疊的時候，事實上就是相當於3–1沒有任何作用 ，
但並沒有影響到我們要計算的res，對吧XD？

依此，寫成程式碼如下：

Java

Java的話使用Arrays.sort()，
其他部分應該相當直觀。
這裡提供LeetCode的另一種解法，
由於有limit的限制，所以我們可以利用長度為limit+1的陣列，
來達到排序的效果(這相當於O(limit)的空間去換取時間複雜度降低)

Python

Python的排序則直接對串列進行.sort()即可，
讀者請記得sorted()函式是產生一個新的排序的串列，別搞混喲！

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

「時間/空間複雜度？」
(O(NlogN)/O(1)，N為people的長度。
如果是使用Java附上的參考解的話則是O(limit)/O(limit))

相似及延伸

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

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

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

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

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

從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元挑戰賽的部分，
只要修課後一定時間內成功錄取新工作 ，
課程就會全額退費喲！ 這部分再請留意官方那邊的公告，
如果有開始的話，文章中也會再提醒各位。

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

「從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學演算法 - 75 Array (14)

Thu, 19 Dec 2019 00:00:00 +0800

0289. Game of Life (Medium)

Question

According to the Wikipedia’s article: “The Game of Life , also known simply as Life , is a cellular automaton devised by the British mathematician John Horton Conway in 1970.”

Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

Any live cell with fewer than two live neighbors dies, as if caused by under-population.
Any live cell with two or three live neighbors lives on to the next generation.
Any live cell with more than three live neighbors dies, as if by over-population..
Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

Write a function to compute the next state (after one update) of the board given its current state. The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


Input:
[
 [0,1,0],
 [0,0,1],
 [1,1,1],
 [0,0,0]
]
Output:
[
 [0,0,0],
 [1,0,1],
 [0,1,1],
 [0,1,0]
]

Follow up :

Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.
In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?

分析/解題

這題是典型的生命遊戲 題目。生命遊戲一般是透過2D的棋盤式的格子，
上面以1代表活著的細胞，0代表死去的細胞，
透過設定好的規則來觀察其演化的狀況。
設定這些東西的目的最初應該是為了要產生模擬圖靈機，
後來發現一些有趣的現象，比如能穩定周期性的圖案像是滑翔機、
機關槍等等，也有的看似是有周期的但最後會消滅的狀況，
總之某種層面上有點像是可以拿來模擬族群聚落的演進等狀態就是了，
有興趣的讀者可以再看看相關的資料。

回到題目，基本上生命遊戲裡面的每個單位，
在下一個時間點要嘛是1(活著)，不然就是0(死去)。
典型的規則是看其九宮格的周圍：

如果原本自己是1(活著) 的話，只有周圍有2~3個 鄰居(活著的細胞)，
下一刻自己才會繼續存活，否則就會死去。
(只有1個鄰居以下會因人口過少而死，
而超過3個鄰居會因人口過多而死)
如果原本自己是0(死去) 的話，只有周圍恰好有3個鄰居 ，
下一刻自己會變成1(活著) (視作被繁衍出來的後代)

Follow up有兩點，1是詢問是否能in-place解題，
2是棋盤是無窮大的話該怎麼描述問題。

這個題目其實看懂定義的話並不困難，只是繁瑣而已。
首先有一個重點是：更新的時候必須要一口氣一起更新，
因為每個細胞的變化都需要看周圍的細胞，不同時改變的話，
結果就有可能會出錯。這邊有兩種考慮方式：

開一個跟board一樣大的二維陣列(串列)，
記錄下一刻的狀態，最後再進行替換。
想辦法用原有的board 來進行記錄。
我們這邊因為希望達成in-place，所以自然選擇2。
還記得之前我們提過的word search嗎？
我們利用了沒有被用到的位元做為遮罩進行XOR，
使得visited的資訊用原先的棋盤就可以做記錄了；
這邊比之前還要簡單，我們只要拿2的1次方位 來記錄即可，
因為board一開始只用到1和0而已 ，所以判斷完以後，
如果它會變成存活的狀態，則將該值加上2，
死去的話則不用額外動作。
這樣一來，最後我們只要將整個board除以2取整數 ，
就可以得到新的棋盤狀態了！
中間在進行周圍八格的判斷時，不要忘記要除以2取餘數 。

所以總體會像這樣：

遍歷整個棋盤做check
check 函式中:
a. 依次檢查是否存活(alive)，並加總周圍八格的存活細胞數量
b. 若本身當前存活 -> 檢查** 周圍存活數是 2或3時，將自己加上2**
c. 否則(本身死亡 )，若周圍存活數 是3 ，將自己加上2
alive 函式中:
a. 若超出邊界則回傳0
b. 否則回傳該格數值除以2的餘數
全數檢查完後呼叫next 函式更新狀態
next 函式: 遍歷整個棋盤，將值除以2取整數 。

一般典型的話理論上邊界應該要互相連接，
(走到最底會通往最上面，走到最右邊會連通最左邊)
但我們這邊就不考慮這個問題了。

Java

Java的部分，計算八方向我們使用了一個d(direction)的二維陣列來記錄，
除了邊界條件以外沒有特別需要注意的地方。

Python

Python的部分，d的方面我們可以用list comprehension ，
扣掉自身(0, 0)來建構。除了留意子函式的定義，
要在拿來做為global的部分後面(才能拿來用) ，
在呼叫之前(因為是腳本執行) 以外，
其他沒有什麼特別的地方XD

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

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

「如果棋盤無限大？」
(那應該要找出一個pattern來表示它才對，
不可能真的開出一個無限大的棋盤)

「首尾相接的話？」
(Python直接按照負數index會發生的事情處理，
Java要自己計算過界的狀況)

「還能簡化嗎？」
(理論上相鄰的兩個點會共用到4個鄰居點 ，
應該可以再節省一點計算時間，但時間複雜度是一樣的 )

相似及延伸

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

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

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

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

從LeetCode學演算法 - 65 Array (13)

Mon, 28 Oct 2019 00:00:00 +0800

0926. Flip String to Monotone Increasing (Medium)

Flip String to Monotone Increasing (Easy)

Question

A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)

We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.

Return the minimum number of flips to make S monotone increasing.

Example 1

1
2
3


Input: "00110"
Output: 1
Explanation: We flip the last digit to get 00111.

Example 2

1
2
3


Input: "010110"
Output: 2
Explanation: We flip to get 011111, or alternatively 000111.

Example 3

1
2
3


Input: "00011000"
Output: 2
Explanation: We flip to get 00000000.

分析/解題

一個只含'0’和'1’的字串在以下的狀況成立時會被視為單調遞增 ：
數個'0’作為開頭(也可能是0個)，其後接著數個'1’作為開頭(也可能是0個)。
(簡單說就是0後面接1就對了，也可以全0或全1)
給定一個字串s ，且可以將當中任意的'0’翻轉成'1’，
也可以將任意的'1’翻轉成'0’，
試求要將s經過翻轉操作成為單調遞增 的狀態所需的最小翻轉次數 。

這題其實某種程度隱含了一點動態規劃的概念在內，
但相對而言算是較簡單的。

我們先思考根據單調遞增特性，由於這個特性，
注定了一旦在某個點變為1，其後的每個單位也必須要是1 才可以。
若將最後的結果分成兩個狀況的話，事情會變比較簡單：

全部都是0
前面0後面1(含全部都是1)

考慮做到第i位時，要保持單調遞增所需翻轉的次數:
a. 如果第i位是0，對狀況1來說，不需額外作任何事情即可保持
b. 如果第i位是1，對狀況1來說，要將第i位翻轉為0(翻轉次數+1)
c. 如果第i位是0，對狀況2來說，要將第i位翻轉為1(翻轉次數+1)
d.如果第i位是1，對狀況2來說，相當於從第i-1位時選擇狀況1/狀況2均可

若我們將上面的狀況1所需的翻轉次數叫做f0，
狀況2的所需次數叫做f1的話，
上面的a/c就是第i位碰到'0’的狀況 ，此時從第i-1位的f0/f1 更新到第i位 時，
新的f0不需改變 ，但f1必須遞增 ；
b/d就是碰到'1’的狀況 ，更新時新的f1要取原先的f0, f1中較小的値 ，
且f0必須要遞增 。

一開始什麼都還沒做，所以我們可以定f0, f1均為0 ，
接下來從頭到尾依照碰到的字元進行操作。

最終，答案只要取f0/f1中較小值 即可。

依此寫成程式碼：
Java的部分可以利用for each的語法蜜糖來取出單個char，
(記得S要先轉成char array)
且需要留意f0的遞增要在取完f1之後 (不然值會錯)。

Java

Python的部分亦同，記得只有+=沒有++這種東西XD

Python

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

「時間/空間複雜度？」
(O(N)/O(1)，需遍歷整個String的長度，但記錄用輔助變數只需常數單位)

相似及延伸

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

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

從LeetCode學演算法 - 64 Array (12) / Two Pointer (3)

Tue, 22 Oct 2019 00:00:00 +0800

0080. Remove Duplicates from Sorted Array II (Medium)

Question

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array ** in-place** with O(1) extra memory.

Example 1

1

Given nums = [1,1,1,2,2,3],

1

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.

1

It doesn't matter what you leave beyond the returned length.

Example 2

1

Given nums = [0,0,1,1,1,1,2,3,3],

1

Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

1

It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference , which means modification to the input array will be known to the caller as well.

Internally you can think of this:

1
2


// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

1
2
3
4
5


// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
 print(nums[i]);
}

分析/解題

給定一個已排序的陣列nums，將其重復超過2次的部分捨棄掉，
且使用in-place的方式來操作(在原陣列操作)，回傳最終結果的長度。

這題算是之前的0083. Remove Duplicates from Sorted List (Easy)的延伸，說真的我認為這題不該當作Medium難度XD

再次提醒，當題目要求使用in-place的時候，
對一些語言的確是可以真的用刪掉單點 的方式來處理(例如Python)，
但刪除這件事情也是較耗時的操作，所以沒特別要求的話，
請依照題目希望你的方向來撰寫(面試則依照面試官的限制條件 )。

我們先來講筆者直觀想到的解法，再來提leetcode上另一位高手的解。

直觀而言，要怎麼能夠知道有沒有碰到3個以上的重復呢？
最直接的方式就是使用一個cnt變數來記錄。
同時，為了要確認是否是重複的數，
我們需要記錄上一次開始重復的數last。

那麼步驟就會像這樣：

如果nums長度 ≤ 2 的話，表示完全不用更動，
直接回傳nums的長度 即可。
將last設為nums[0], cnt設為1, 預計要覆蓋的** index j設為1。**
令i從1開始一個迴圈來遍歷整個nums:
3-a. 如果nums[i]不等於last 的話，表示數字不同 ，
必須將其覆蓋到j的位置 。
同時，我們必須更新last為nums[i]，j要遞增，
cnt要重設為1 (用來做下一次比較)。
3-b. 否則，如果兩者相等且cnt小於2 ，
代表重複未超過2次，同樣要進行複寫和遞增j，但cnt要遞增 。
當整個迴圈完畢以後，j 應該是位在處理過後的陣列的尾端+1 的位置。
所以回傳j即可代表新的陣列的總長 。

聽起來有點多，但其實寫起來並不困難，
但還有更厲害的解法XD

這邊提供了LeetCode上StefanPochmann 的解，
簡單來說呢，我們可以換個思路：
由於整個陣列是排序過的 ，當我們遍歷陣列時，
某個數字應不應該要覆蓋到index上 ，
(筆者之前的解法將這個index叫做j，相當於這個解裡的i)
取決於前面兩個數字是否跟它一樣 ；
都一樣的話，就產生了三個相同的數 的狀況，
自然不需要再被取用，且由於排序的關係，
我們只需要比較前面兩個數字中較前面的那個 即可。

當i小於2時，直接無條件覆蓋( 因為不可能重複超過2次)；
當遍歷到的値n大於num[i-2] 時，代表數字不一樣 或重複未超過2次 ，
則應將其值覆蓋過去並遞增i 。

各自寫成程式碼如下：

Java

Python

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

「時間/空間複雜度？」
(O(N)/O(1)，我們需要遍歷整個陣列，且儲存用的輔助變數只有常數個)

相似及延伸

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

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

從LeetCode學演算法 - 52 Array (11)

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

0268. Missing Number (Easy)

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

Question

Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.

Example 1

1
2


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

Example 2

1
2


Input: [9,6,4,2,3,5,7,0,1]
Output: 8

Note :
Your algorithm should run in linear runtime complexity.
Could you implement it using only constant extra space complexity?

分析/解題

給定一個陣列內含n個不同的數字，
(從0~n之間選n個，也就是說會少一個)
試找出漏掉的那個數。

首先最笨最暴力的方法當然是排序過後再從0開始看nums[i]是否為i。
這個做法顯然經過排序就需要O(NlogN)的時間，
但其實還是可以通過測資XD

我們考慮比較簡單一點的作法：
我們都知道梯形公式(以及那個聰明的高斯XD)，
從0加到n的總和會是n * (n+1) / 2。

所以想要知道中間漏掉哪個，就將0~n的總和，
減去nums的所有元素全部加起來即可。

Java

在Python中不要忘記了除法取整數要用「//」，
並且陣列的和可以用sum來取得。

Python

這種解法要留意一點，如果在有限制int的狀態下，
n*(n+1)是有機會溢位的！所以如果有時間的話，
還是可以嘗試一下下面提到的解法。

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

「時間/空間複雜度？」
(O(N)/O(1)，乘法只做一次，加法會做n次，儲存的部分只有幾個輔助的變數)

「這題有別的解法嗎？」
(其實用Bitwise Operation來解也很簡單，
這邊留給讀者可以自行嘗試看看(用XOR)。)

相似及延伸

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

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

從LeetCode學演算法 - 47 Array (10)

Mon, 09 Sep 2019 00:00:00 +0800

0204. Count Primes (Easy)

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

Question

Count the number of prime numbers less than a non-negative number, *n *.

Example:

1
2
3


Input: 10
Output: 4
Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.

分析/解題

給定一個非負整數n，試求所有小於這個n的質數。

讓我們來複習一下國中(還是國小？)數學：
質數的定義就是除了1和自己 以外，沒有其他數可以整除它的正整數。

透過這個特點我們可以再延伸：
因為合成數必然可以拆成質數相乘 ，
所以我們要判定某個數是否是質數的話，
只要將其他比它小的質數 測試它是否是目標的因數 即可。

另外，由於一個數若能拆成2數相乘，
那麼其中一個因數會小於等於這個數的開根號 ；
另一個因數則是大於等於這個數的開根號 。
如此一來，我們只要檢驗2**~目標數的開根號** 的數是否能整除目標數 即可。

所以老師會教你一個消去法：
首先將2的倍數排除掉，再將3的倍數排除掉，
再將5的倍數排除掉……(2倍以上，不含自己)
一個個操作，走到沒有被排除掉的數即為質數 。

我們可以再進一步處理一點：
假設現在處理到i，
那麼其實我們應該知道i*2, i*3, …, i*(i-1 )的部分，
應該都被前面的操作排除了，
故每次我們只要從i*i開始，排除到n，
也就是i走到最大n的開根號即可。

故整個程式會從2到根號n，每次將對應i的i倍以上的部分設為非質數，
最後計算總質數有多少個。

Java的部分，由於boolean預設為false，
這邊使用nPrime代表not prime，所以nPrime為false代表這個數是質數，
要設定成不是質數時請用nPrime[j] = true。
在處理完後請記得bound後面的質數個數要記得加起來。

Java

Python的部分，sqrt可以直接用n ** 0.5，
並且我們可以用1代表質數，0代表非質數，
讀者可以仔細看一下第8行，其實和Java迴圈的目的是一樣的，
不過這邊直接最後才算prime陣列的總和來取得質數個數。

Python

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

「時間/空間複雜度？」
(O(n), O(n log log n))
(外層迴圈的boundary上限是sqrt(n)，
內層j的次數上限會從n/2 -> sqrt(n)，具體計算我也不會XD
以Wikipedia提供的時間複雜度為O(n log log n)。
https://zh.wikipedia.org/wiki/%E5%9F%83%E6%8B%89%E6%89%98%E6%96%AF%E7%89%B9%E5%B0%BC%E7%AD%9B%E6%B3%95)

Special Thanks suggestions/corrections from viewers:
Python Taiwan, 林宣丞：此篩選方式又稱 埃拉托斯特尼篩法(sieve of Eratosthenes)。

(歡迎提供意見協助更正歐~)

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

1
2


如果你／妳非常喜歡這篇文章，可以按著拍手直到50下。
也請記得「Follow」我，隨時收看最新的文章。

從LeetCode學演算法 - 40 Array (9)

Mon, 26 Aug 2019 00:00:00 +0800

0238. Product of Array Except Self (Medium)

Question

Given an array nums of n integers where n > 1, return an array outputsuch that output[i] is equal to the product of all the elements of numsexcept nums[i].

Example:

1
2


Input: [1,2,3,4]
Output: [24,12,8,6]

Note: Please solve it ** without division** and in O(n).

Follow up:
Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.)

分析/解題

題目給定一個陣列nums，目標是產生一個output陣列，
這個output上的output[i]都相當於除了nums[i]以外其他的乘積。
要求不能用除法且必須在O(n)的時間完成。
延伸要求：用來做為輸出的output不算在額外的空間內的話，
是否可使用常數空間複雜度來解決此題？(即僅使用O(1)空間)

這題如果用暴力法來解的話，
就是使用兩層for-loop，將每個output[i]先初始化為1，
再進行對其他值的相乘(也就是要乘N-1次)，
所需的總乘法會是N*(N-1)，故時間複雜度為O(N²)。

這樣顯然速度不太好，我們再來考慮一下實際的情形。

1
2
3
4


nums 2 3 4 5
res 3*4*5 2*4*5 2*3*5 2*3*4
l 2 2*3 2*3*4
r 3*4*5 4*5 5

假設有一個陣列是[2, 3, 4, 5]，而我們要求的結果是res，
按照定義我們可以先將res的結果寫出。
仔細觀察我們可以發現，如果將res的每項拆成兩組相乘 ，
我們可以拆分成l, r兩個陣列，
當中l從index 1 開始往後推 有數值，依序是2, 2*3, 2*3*4 。
r則從index 2 開始往回推 有數值，依序是5, 4*5, 3*4*5 。

(這邊的拆分就是取明顯有斷層的部分，空出來的部分為1 )

所以我們可以先將res初始化，用它承載l 的部分，
再依次將r從1開始，把5,4,3依序乘上去一個值以後依序乘到res中，
這樣一來計算res的時候就只有分別經歷過兩次O(N)，
時間複雜度會維持在O(N)。
同時，因為前面第一次利用了res來儲存l的部分，
第二次只用單個變數r來依序記錄要乘的順序，
故扣除res以後空間複雜度為O(1)。

Java

Python

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

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

相似及延伸

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學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 38 Array (7)

Fri, 23 Aug 2019 00:00:00 +0800

0088. Merge Sorted Array (Easy)

Question

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:

The number of elements initialized in nums1 and nums2 are m and n respectively.
You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.

Example:

1
2
3


Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

1

Output: [1,2,2,3,5,6]

分析/解題

這題雖然相對比較無聊，
但merge的過程中其實蠻像merge sort的merge的，
所以選來讓讀者熟悉一下merge的概念，對上上篇提的應該會有幫助。

題目給定兩個陣列及有放元素的對應長度，兩者除了未放元素的0以外，
其他均已排序。同時，題目也假設第一個陣列必定有足夠空間，
可以放入全部的元素。請嘗試將兩個陣列merge成一個排序的陣列，
放置在第一個陣列中 。

由於最終要放在nums1裡，我們可以先考慮會有的情形：

n等於0：不用搬了，因為只有nums1有非0值。
m等於0：只要把nums2的全搬過來即可
其他：按照merge的原則，將雙方依序填入nums1中。

到這邊讀者可能會想到常規的merge是開一個新陣列 將雙方依次比較，
每次將較小的值放入新陣列，最後排序完成。
現在說想放到nums1當然是可以，但nums1前面有值 ，
直接這麼做會蓋掉耶！那怎麼辦呢？
答案很簡單，我們已經知道兩邊的長度是m跟n，
那麼合併後的長度就會是m+n ，尾端的index會是m+n-1 。
我們只要將**「每次將較小的值放入開頭」** 改成**「每次將較大的值放入結尾」** ，最後即可達到相同的狀況。

所以操作順序會是：

令i, j, k分別為m-1, n-1, m+n-1 2. 當i和j都≥0 時：
如果nums1的值比nums2的值大，
將nums1的尾端放到k的位置，同時遞減i跟k以更新。
如果nums1的值比nums2的值小(或相等)，
將nums2的尾端放到k的位置，同時遞減j跟k以更新。
重複這個迴圈直到跳出，代表有一邊陣列放完了 。
當 i ≥ 0 時，表示其實我們已經做完了，所以不用任何操作。
(剩下nums1前面的部分，不需要再動了)
當 j ≥ 0 時，表示 i 的部分已經被用完了，
剩下的就是一路將 j 的對應值填入即可。

Java的部分，可以利用**”–“** 讓對應index先填入以後再進行遞減，
步驟流程請參考上面演算方式並對照。

Java

Python沒有++或 – 這種東西，所以遞減時要乖乖的自己等於自己減一，
不過可以將需要遞減的寫在同一行，會稍微簡潔一點點。

Python

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

「時間/空間複雜度？」
(O(m+n)，O(1)
前者是典型merge的時間，後者是因為我們只有使用常數變數，
其他都是原有的記憶體空間，故僅額外占用到O(1)的空間)

相似及延伸

1.0021. Merge Two Sorted Lists (Easy) 2. 0148. Sort List (Medium)

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

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

從LeetCode學演算法 - 34 Array (6)

Mon, 19 Aug 2019 00:00:00 +0800

0977. Squares of a Sorted Array (Easy)

Question

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.

Example 1

1
2


Input: [-4,-1,0,3,10]
Output: [0,1,9,16,100]

Example 2

1
2


Input: [-7,-3,2,3,11]
Output: [4,9,9,49,121]

Note:

1 <= A.length <= 10000
-10000 <= A[i] <= 10000
A is sorted in non-decreasing order.

分析/解題

給定一個非遞減排序(也就是相等或遞增)的陣列，
以排序好的狀況回傳其每個元素平方後所得的陣列。

一般我們所熟知的排序應該需要至少O(NlogN)的狀況才能達成，
(之後筆者會再挑一題來專門作排序這個部分的問題)
但這題在平方過以後，並不算完全散亂的狀態，
原先負整數的部分平方後會由大到小排列 ；
原先0到正整數的部分平方後則會由小到大排列 。
利用這點我們可以使用two pointer的模式來進行處理，
每次將兩邊的元素絕對值進行比較，比較大的代表其平方後比較大，
將其取出置於新的陣列/串列的最右邊，依序往回填。

實作上，如果不限制A必須保持原樣的話，
也可以先將負號的部分全數去掉，再進行後面的比較時，
就可免去取絕對值了。

Java的部分兩個方法皆有提供，讀者可依實際狀況決定寫法。

Java

Python的部分，還另外提供了一個偷吃步的方法：
使用sorted函式搭配list comprehension，一行即可解決問題，
但其時間複雜度為O(NlogN) (因為直接使用排序法)

神奇的是，這個方法還比較快XD
(估計是A的長度限制在比較小的範圍，可能測試資料也不是很大，
所以主動用排序帶來的負面效益較低的原因)

Python

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

「時間/空間複雜度？」
(O(N), O(N)
每個陣列均會掃過一次，且會產生一個新的陣列。)

「這題在產生新的陣列的時候跟合併排序(Merge Sort)其實很像，
可以概略描述Merge Sort的作法嗎？」
(可以XD 這個我們之後會專門寫一題講解)
(如果不想等的話，可以先查詢Merge Sort，應該有蠻多資料的，
但簡言之，就是每次將陣列拆兩半，
分別各自排序過後(mergesort)，再依序合併起來(merge)。)

相似及延伸：
1. 0021. Merge Two Sorted Lists (Easy)
2. 0148. Sort List (Medium)

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

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

從LeetCode學演算法 - 33 Array (5)

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

0905. Sort Array By Parity (Easy)

Question

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1

1
2
3


Input: [3,1,2,4]
Output: [2,4,3,1]
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:

1 <= A.length <= 5000
0 <= A[i] <= 5000

分析/解題

給定一個不含負整數的整數陣列A，回傳一個陣列，
這個陣列的前面會是所有A的偶數的元素，
跟在後面的是所有A的奇數的元素的部分。

這題我們在先前的Move Zeros題目中有提到過類似的部分，
如果當時我們只想把0往後挪而不需考慮保留原順序，
可以從兩端開始掃描，找到左邊是0而右邊非0並交換 就可以解完此題；
這題概念是一樣的，只是變成要左邊全是偶數，右邊全是奇數 。
演算的順序大概會像這樣：

分別取兩端的index作為起始(i = 0, j = l-1, l為A的長度)
先確認i的位置是否為奇數，若否，則遞增i，直到A[i]為奇數
再確認j的位置是否為偶數，若否，則遞減j，直到A[j]為偶數
交換A[i], A[j]
重複前述2~4的操作直到i不再小於j(開始前也要檢查)
此時全數交換完畢，所有偶數應排在奇數之前

這邊程式碼需要注意continue的作用，
目的是讓每次index變動都進行i<j的檢查，
唯有這個條件成立，我們才有可能需要進行交換。

Java

Python的部分後面提供了一個非in-place的作法，
也就是各自將偶數和奇數的串列累積起來，
最後再將其連接。好處是比較簡單，缺點是要額外的空間來存，
端看使用者需求和題目需求來決定。

Python

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

「時間/空間複雜度？」
(O(N), O(1)
two pointer會掃過整個陣列，所以時間複雜度為O(N)；
如果不另外開陣列/串列的話，可以用in-place達到則空間複雜度為O(1)，
如果像Python額外提到的方法的話則由於額外儲存的關係需要O(N))

「如果除了偶數在前，奇數在後以外，要按照原先順序排列呢？」
(Python的另一個解就會按順序排)

相似及延伸：
1. ** 0283**. Move Zeros

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

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

從LeetCode學演算法 - 27 Array (4)

Fri, 09 Aug 2019 00:00:00 +0800

0189. Rotate Array (Easy)

Question

Given an array, rotate the array to the right by k steps, where k is non-negative.

Example 1

1
2
3
4
5
6


Input: [1,2,3,4,5,6,7] and k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2

1
2
3
4
5


Input: [-1,-100,3,99] and k = 2
Output: [3,99,-1,-100]
Explanation:
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

Note:

Try to come up with as many solutions as you can, there are at least 3 different ways to solve this problem.
Could you do it in-place with O(1) extra space?

分析/解題

題目給定一個陣列，將其往右輪轉k步，
要求直接將該陣列調整成輪轉後的結果。

這題一旦沒有Note的要求的話瞬間簡單一百倍 。
舉例來說，我們可以直接將後k項和前l-k項合併起來(l為陣列長度)，
就會是答案了；或者，將整個陣列重複銜接一次，取[(l-k):(2*l-k)]亦可。
(這兩個解法筆者列在Python的註解中供讀者參閱)
但，它們都不是in-place。

要考慮到in-place的話，我們必須知道，
一定有方法能讓他們跑到該有的地方，且不需用到超過O(1)以外的空間，
一般就意味著會在陣列進行swap的操作(交換兩個元素)。

先看一下原本的例子：
[1,2,3,4,5,6,7] and k = 3 -> [5,6,7,1,2,3,4]
先不論其他的部分，我們可以發現57從最尾端3個變成最前面的3個了；
與此同時，14自然從最前面4個變成最尾端4個。
我們先不論大家的順序，先將整個陣列倒過來的話，
可以先達到1~~4，5~~7分別占據目標的區塊的效果：[7,6,5 ,4,3,2,1]。
接著再比對一下，發現區塊是對了，但各自剛好被顛倒過一次 ，
那麼我們再對7~~5及4~~1分別各進行一次反轉 ，就會得到我們要的結果。

所以整個流程就會變成：

將整個陣列 進行反轉
將前k個數 進行反轉
將後l-k個數 進行反轉

反轉是很基本的操作，希望讀者能熟練掌握，
原則上利用two pointer的方式，每次將兩個元素進行交換 ，
並對pointer位置進行遞增/遞減的操作，直到相交 為止。
(例: [1 ,2,3,4 ]->[4,2 ,3 ,1]->[4,3,2,1])
Java的部分的兩數交換需要宣告一個暫存值tmp(temp)，
Python的部分則可直接使用a, b = b, a的方式進行交換。
最後，操作之前不要忘記將k先取除以l的餘數。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(1)(如果是使用3次reverse的方法))

「如不限制空間複雜度必須O(1)？」
(可以參照上面Python程式碼中註解的做法)

相似及延伸

0031. Next Permutation (可以用到swap跟reverse的操作來解題)

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

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

從LeetCode學演算法 - 25 Array (3)

Tue, 06 Aug 2019 00:00:00 +0800

0283. Move Zeroes (Easy)

Question

Given an array nums, write a function to move all 0’s to the end of it while maintaining the relative order of the non-zero elements.

Example:

1
2


Input: [0,1,0,3,12]
Output: [1,3,12,0,0]

Note :

You must do this in-place without making a copy of the array.
Minimize the total number of operations.

分析/解題

題目給定一個陣列nums並要求將所有當中的0全部都放到最後面，
且必須保持所有非0的元素的原有相對排列。
另外Note中還要求必須要in-place且最小化總共操作的次數。

這題其實有很多變形，雖然簡單，
務必請留意題目所要求的條件，不要倉促作答。

首先題目強調必須in-place(in-place的部分先前的文章有提到過)，
故諸如開一個ArrayList/List來將所有非0的部分一個一個存起來的方法，
在這裡就完全行不通了。

直覺上或許讀者會想到諸如以下的方法：

從頭開始找到第一個0元素(位置假設為a)
找到從這個0元素以後第一個非0的元素
將兩者交換
從a+1開始找到下一個0元素
再找到從這個0元素以後第一個非0的元素
按照這樣的邏輯直到沒有更多的0元素，或找到0元素以後，
其後沒有非0的元素為止。
(上面的方法沒有很嚴謹，因為1有可能就已經找不到0元素了，
僅為大概的範例)

但這樣的方法對每一個0元素都有可能需要掃瞄過一整個陣列，
總體的時間複雜度會來到O(N^2)。

有更好的方法嗎？
我們可以先考慮：
如果我們將原先的陣列當成額外開的ArrayList或List來使用的話呢？
先將所有的非0值從index 0開始放入，直到沒有非0的元素為止，
接著，和開新的空間不同，後面多出來的部分相當於被排開的0 ，
所以我們要將後面的值全部設為0 。

這麼做只需要記錄當前非0的部分放到哪邊，在其後再進行補0的動作即可，
最極端的狀況是全部都是0(即完全不用更動陣列)，
以及全部都非0(即將原本的位置複寫相同的數字一次)；
一旦中間有出現0的狀況，只代表其後的數字被往前挪一格，
讀者可以紙筆稍加操作看看即可確認不會有非0的數字會被吃掉XD~

我們使用了index來記錄下一個即將被寫入非0數字的位置，
遍歷整個陣列/串列，當元素非0時，則將其寫入index的位置，
並遞增index，其程式碼如下所示。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(1)，因為最多只須掃過陣列兩次即可)

「如果不要求順序保持相同的話呢？」
(使用two pointer的方式，i由頭至尾，j由尾至頭，
分別找到0和非0的元素進行交換，直到彼此交會即可。
時間/空間複雜度相同但可預期因只須掃過一次陣列，有機會較快)

「如果不要求要in-place呢？」
(以python為例:
res=[x for x in nums if x != 0]
res += (len(nums)- len(res))*[0]
(後面再接上對應個數的0即可)
(時間/空間複雜度O(N),O(N))

所以，有些題目簡單歸簡單，看到的時候，還是請留心限制條件，
它有可能跟你熟悉的題目有些出入！有時候一旦限制條件不同，
可以用的手段和時間/空間複雜度可能就會完全不同了！

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

從LeetCode學演算法 - 23 Array (2)

Sat, 03 Aug 2019 00:00:00 +0800

0229. Majority Element II (Medium)

Question

Given an integer array of size n,
find all elements that appear more than ⌊ n/3 ⌋ times.

Note: The algorithm should run in linear time and in O(1) space.

Example 1

1
2


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

Example 2

1
2


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

分析/解題

跟上一篇相似，這篇將出現超過二分之一改變為三分之一，
要求求所有出現超過三分之一次數的數值，
這使得可能超過三分之一的種類會變成2種，但並不保證一定會有2種。
按照上一篇的摩爾投票算法的思路，
我們可以取2個數(n1, n2)暫存，
每次拿一個新的來檢驗並處理每三個相消的動作，
這樣我們即可以保證留下來的會有當中超過三分之一的元素。

要特別留意的是，兩個數有可能會是一致的，
且不一定每次都存在2種超過三分之一的元素，
所以最後我們要個別重新確認留在n1及n2上的元素，
其個數是否有超過三分之一。

Java

Python的部分，我們這邊除了同於Java的解法以外，
再提供一個簡單的作法：使用Counter。
利用Counter可以將一個列表轉換成Counter物件，
儲存的方式是(key:元素及 value: 該元素出現的次數)
在迴圈中的取用基本上跟字典類似。
只要檢查每個元素出現次數是否大於三分之一的數量即可加至結果。

(請留意如果認真按照題目要求的話，
這個解法因為會佔用額外O(n) 空間，
故不是一個在O(1)空間內可以完成的算法。)

Python

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

「時間/空間複雜度？」
(O(n), O(1)。
要經過整個陣列兩次，且額外並沒有需求常數次數以外的空間)

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

從LeetCode學演算法 - 22 Array (1)

Wed, 31 Jul 2019 00:00:00 +0800

0169. Majority Element (Easy)

Question

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

You may assume that the array is non-empty and the majority element always exists in the array.

Example 1

1
2


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

Example 2

1
2


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

分析/解題

嗨，大家今天過得好嗎？歡迎回到軟工宅宅(誤)。
接下來的幾題我們會著墨一下有關陣列(Array)或列表(List)相關的內容。

題目給定了一個長度為n的陣列，
已知當中有一個majority element(佔大多數的元素)，
這個數的個數會多過於⌊ n/2 ⌋。
(此符號代表向下取整數，如⌊ 5/2 ⌋=2。
別忘了是more than，所以如果n是5的話，
代表majority element至少要有3個)

題目還貼心地告訴我們，可以假定陣列不是空的，
且一定存在majority element，所以這邊可以省掉一些常用的檢查。

怎麼解這題呢？
一般來說的直覺可能會想使用HashMap來解(Python則用dict)，
將每個數塞入HashMap/字典中，最後找最大的那個數就是了。
這麼做的時間複雜度為O(n)，空間複雜度亦為O(n)，
因為插入耗費的時間為O(1)，插入n個數即為O(n)，
同時，我們只能保證最多有n - ⌊ n/2 ⌋的不同種類的數，
所以空間上還是保持在O(n)的複雜度。
在中途過程中在去檢驗是否有超過半數的element也可以，
但由於過程不保證會先碰到超過半數，所以額外檢驗的時間，
和省下來後面可能不用做完的時間相比，是不能肯定誰效率比較好的。

那麼，有沒有比較節省空間的做法呢？
有的！這裡介紹一個演算法，全名叫做：
Boyer–Moore majority vote algorithm(摩爾投票算法)
這個算法的核心在於，
刪去一個數列中的兩個不同的數字，不會影響該數列的majority element。

假想有一群人要投票，候選人有A、B、C，假設A已知會過半數的話，
任取其中2個人取消他們的投票資格，會有以下的狀況：

被取消資格的是B跟C -> 顯然A還是過半數(而且比例更高了XD)
被取消資格的是(A, B)或(A, C) -> 一個投A的和一個不投A的同步被排除，所以無法改變A會過半數的狀況。

同理，在不只3個候選人(數字)的時候，每次取2個人取消投票資格(移除)，亦無法改變投票結果(A還是會是majority element)。

註：
所以我們可以知道，當你跟你的家人政治立場不同時，
只有兩個人的狀況下都不去投票是沒有用的，
有用的方式是在投票前夕帶著跟你立場相反的家人們出國去玩 ，
多於1人時，每多一個人你就多賺一張選票差距 ，但你的荷包可能會哭。
(不要說是我教的！)

依此，我們可以使用下列的方式來進行陣列運算：

取出第一個數放到一個暫存的變數(res)，
將計數器(cnt)設定為1，代表這個數出現1次。
取出下一個數nums[i]，如果和res相等，則將計數器+1；
如果和res不同，且計數器>0時，將計數器-1；(代表取這兩個數成對移除)
如果和res不同但是計數器=0時，將res更改為nums[i]並將計數器+1(代表res已經用完了，現在還沒被移除的是nums[i])
反覆進行步驟2直到陣列結尾，剩下的res即為答案。
(因為兩兩移除到最後一定是非majority element的先被移光)

Java

還有另一種作法，是將陣列進行排序，
無論如何majority element一定會通過中間的位置。
這種方式的時間複雜度為O(nlogn)，空間複雜度視你的呼叫方式而定，
可能是O(1)也可能是O(n)(將排序的結果放到別的地方的話)

Python

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

「時間/空間複雜度？」
(O(n), O(1)，除了一些變數以外我們沒有使用到額外的空間)

「各方法的優劣為何？」
(可以參照Solution的頁面，這篇作者分析的內容很完整)

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