String on 跟著 Desolve 學程式

從LeetCode學演算法 - 107 String (7) / Stack (2)

Sat, 12 Dec 2020 00:00:00 +0800

1544. Make The String Great (Easy)

好久不見啦！最近筆者比較忙碌，還請多多見諒XD

寫在前面

抽獎活動還在繼續累積人數(現在好像沒有人想抽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

Given a string s of lower and upper case English letters.

A good string is a string which doesn’t have two adjacent characters s[i] and s[i + 1] where:

0 <= i <= s.length - 2
s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case or vice-versa .

To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.

Return the string after making it good. The answer is guaranteed to be unique under the given constraints.

Notice that an empty string is also good.

Example 1

1
2
3


Input: s = "leEeetcode"
Output: "leetcode"
Explanation: In the first step, either you choose i = 1 or i = 2, both will result "leEeetcode" to be reduced to "leetcode".

Example 2

1
2
3
4
5


Input: s = "abBAcC"
Output: ""
Explanation: We have many possible scenarios, and all lead to the same answer. For example:
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""

Example 3

1
2


Input: s = "s"
Output: "s"

Constraints

1 <= s.length <= 100
s contains only lower and upper case English letters.

分析/解題

給定一個字串s，當中含有大小寫的英文字母，
一個好的字串被定義為對於 0 ≤ i ≤ s.length - 2 來說，
兩個相鄰的字元s[i]和s[i+1]不會含有相同字母但大小寫相反的狀況，
例如aA, Cc這種型式。

要讓字串變好，可以透過每次拿掉兩個相鄰且讓字串變壞的字元達到，
最終得到一個好的字串。

題目表示給定的題目一定有答案且必然是唯一的。
(空字串也是好的字串)

說起來這題的標題不禁讓人想到美國總統大選，
不過到現在恐怕已經大勢底定了就是，
這句話恐怕就要成為絕響了吧XD

扯遠了，我們來看看這題。

由於它已經保證會有唯一解，
那麼相鄰字元的移除順序理論上並不會影響結果，
所以直觀上好像可以每次掃過一遍字串，
將大小寫相鄰的相同字母移掉就解決了……嗎？

但這麼做的話，我們會不知道要掃過幾次字串才能夠將所有問題移除完，
因為比如碰到abBA 這樣子的字串，我們要將**’bB’** 移除掉，
才會在下一次發現**’aA’** 可以移除。

所以為求簡單起見，
我們可以使用一個Stack 來存放已經檢查過的部分，
每次放一個字元到Stack中，存放前將Stack最上面的那個字元，
跟準備要放的字元做比較：
兩者是相同字母且大小寫相反->將Stack中最上面的字元pop掉
兩者不需相消->放入Stack

這麼一來，我們就只會放沒有讓字串變壞的字元進到Stack，
同時每次都會拿新的字元跟前面的比對，以排除掉應該移除的部分。

那麼，怎麼算大小寫相反呢？
除了用upper/lower case相關的函式外，
在 ASCII Code 中，相同大小寫的字母的對應碼會恰巧差32。

為什麼不是26? 因為中間還有帶一些標點符號。 Python中我們可以使用ord()來對一個字元取其ASCII Code值，
而在Java中，我們可以視char為一個數字來進行加減運算，
所以直接相加減就可以了。

可能有讀者會問：
「那我記不住32這個數字怎麼辦？」

在寫的過程中，我們也可以用’a’和’A’的位置差算出來，
注意**’a’對應的值是比較大** 的呦！
所以可以將其寫成：‘a’ - ‘A’ (Java)或 ord(‘a’)- ord(‘A’) (Python)

你再問：
「那我記不住哪個在前面怎麼辦？」
呃……那你只好再加個絕對值 了！
使用Math.abs() (Java) 或 abs() (Python)就可以囉！

因此，流程大體如下：

建立一個stack名為st
從字串s當中依序取出字元c，進行迴圈：
2-1. 當st不為空，且最上面的值和c的值相差32 時，就對st進行pop
2-2. 否則表示不需消除，將c推入st中(push)
完成迴圈後，將st的所有字元連起來得到的字串即為答案

依此，寫成程式碼如下：

Java

Java的部分，由於Java的Stack固定從尾端取出，
最終使用StringBuilder進行組合完以後，toString之前記得要reverse，
不然答案就會反掉囉XD！
當然，也可以採用ArrayDeque來做，
這樣就可以從頭排列到尾而不需要反轉。
使用peek()可以幫助我們確認stack的最上面一個值是什麼，
而不會將其取出，同時因不確定大小寫誰在前面，
所以檢查時要記得取絕對值！

Python

Python這邊多加了一條判斷，但其實不影響，
只是s的長度是1或0時都可以直接回傳就是了XD

我們可以看到對於Python來說好處就是可以直接拿list當stack來使用，
同時，使用join函式可以簡單地將list組成字串。

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

「時間/空間複雜度？」
(O(N)/O(N)，N為字串長度。Java也可以使用CharAt(i)的型式來處理取出字元的部分，但不影響空間複雜度，因為後面還有其他要組的部分XD)

相似及延伸

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

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

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

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

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

從LeetCode學演算法 - 101 String (6)

Sun, 26 Jul 2020 00:00:00 +0800

1529. Bulb Switcher IV (Medium)

寫在前面

截止時間為7/31 23:59:59，這之後的留言問題我有看到還是會回答，
但就不會納入抽獎資格歐！

當前面試篇以上傳完畢，進階篇則會在8/31前陸續上傳完成呦！

有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/advleetcode

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

Question

There is a room with n bulbs, numbered from 0 to n-1, arranged in a row from left to right. Initially all the bulbs are turned off .

Your task is to obtain the configuration represented by target where target[i] is ‘1’ if the i-th bulb is turned on and is ‘0’ if it is turned off.

You have a switch to flip the state of the bulb, a flip operation is defined as follows:

Choose any bulb (index i) of your current configuration.
Flip each bulb from index i to n-1.

When any bulb is flipped it means that if it is 0 it changes to 1 and if it is 1 it changes to 0.

Return the minimum number of flips required to form target.

Example 1

1
2
3
4
5
6
7


Input: target = "10111"
Output: 3
Explanation: Initial configuration "00000".
flip from the third bulb: "00000" -> "00111"
flip from the first bulb: "00111" -> "11000"
flip from the second bulb: "11000" -> "10111"
We need at least 3 flip operations to form target.

Example 2

1
2
3


Input: target = "101"
Output: 3
Explanation: "000" -> "111" -> "100" -> "101".

Example 3

1
2


Input: target = "00000"
Output: 0

Example 4

1
2


Input: target = "001011101"
Output: 5

Constraints

1 <= target.length <= 10^5
target[i] == '0' or target[i] == '1'

分析/解題

這題是今天(2020/07/26)舉辦的199th LeetCode Weekly Contest的第2題。
房間裡有n個燈泡**(0~n-1)** ，從左至右排列，初始全數是關的 。
我們的目標是將燈開關成target 的狀態，在index i的位置上，
target[i]如果是'1’的話就表示開，target[i]如果是'0’的話就表示關。

所能夠做的操作只有一種叫flip 的方法。
flip方法的操作是選取一個index i，
接著會將i~n-1的所有燈泡狀態反轉，1變成0，0變成1 。

我們要作的事情是找出最少完成target的flip次數。

是說每次碰到稍微生活化一點的題目，就會覺得有點87：
像這題亮燈就亮燈，搞那麼麻煩的開關方式幹嘛啦！！！
不怕燈泡壞掉逆？？？

這題乍看之下好像不容易，
但仔細一看，flip的操作只影響該點及其右側的燈泡，
所以我們由左往右看的話，只需要考慮當前該燈泡需不需要翻轉 即可，
因為某個點右側的燈泡flip不會影響該點。

由於右邊的會一起反轉 ，所以我們可以定位一個flag=1 ，
一開始大家都是0，所以第一次我們要翻轉的狀況，
就是碰到target[i]和flag相等時。 把右側翻過來以後，我們可以將flag從'1’變成'0’，
因為我們只要考慮翻或不翻 ，所以使用flag的變化 ，
和target[i]碰到的値來作對照 會相當方便：
只要碰到和flag相同的就代表要加翻一次 ，
不同的就代表不用翻 ，這樣沿路走到尾端，就可以得到計數的答案。

依此，寫成程式碼如下：

Java

Java的部分使用charAt可以按char來取出每個字元，
請留意要比較的時候要取成int，這邊直接減去’0’即可。

Python

Python的部分直接用int進行轉換字元成整數即可。

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

「時間/空間複雜度？」
(O(len(target))/O(1)，除了flag跟cnt以外並未額外再多用到其他空間)

相似及延伸

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

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

從LeetCode學演算法 - 92 String (5)

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

0680. Valid Palindrome II (Easy)

Question

Given a non-empty string s, you may delete at most one character. Judge whether you can make it a palindrome.

Example 1

1
2


Input: "aba"
Output: True

Example 2

1
2
3


Input: "abca"
Output: True
Explanation: You could delete the character 'c'.

Note:

The string will only contain lowercase characters a-z. The maximum length of the string is 50000.

分析/解題

給定一個非空白的字串s，最多可以從當中刪除掉一個字元，
試判斷你能否讓這個字串變成一個回文。

回文(Palindrome)先前已經介紹過了 ，
就是符合「從尾到頭和從頭到尾看起來相同」即可，
所以它可以是像是abcba 的形式(中間有一個單獨的字元)，
或者是abba (成對兩兩相對)，這個概念在很多回文的題目都有用到，
讀者可以多加留意。

假設今天不能刪除任何字元的話，
問題就會直接變成檢查字串是否是回文，
那麼我們就可以直接設定兩個index i, j，
當中i從0開始遞增，j從s.length()-1(或len(s)-1)開始遞減 ，
依序對照對稱的位置檢查字元是否相等 即可。
(檢查到i, j交會都還兩兩對稱相等，則為回文)

好，那麼問題來了：
如果原先不是回文，需要刪掉一個字元才能變成回文呢？
該刪哪個？
有一句話說得好：
「解決不了問題，就解決產生問題的人」(大誤)，
既然我們只有一個可以刪的空間，
那麼就只能等到有無法對應到的狀況才處理。
舉例來說：
abcce ba -> a-a, b-b, 在c-e這個地方沒有對應到，
那麼有可能是c有問題，也有可能是e有問題，
所以我們可以分成刪掉c或刪掉e的狀況來檢查。
(因為實際上我們不會預先知道是誰有問題，也有可能都有問題)
也就是說，
當i, j沒辦法對應到時，我們可以選擇略過i 的位置上的字元，
或者略過j 的位置上的字元。(因為只是要檢查，所以不用真的作刪除)
略過i 的話，我們就要嘗試拿i+1來和j做對應 ；
略過j 的話，則是拿i和j-1做對應 。
剩下的狀況，就是按照前面一般檢查回文的流程依序檢查，
只要這兩條路其中一種 可以讓s變為回文，答案就會是true 。
那麼，如果又碰到沒對應到的呢？

那我們就只能說抱歉了XD~
我們已經用掉了一次刪除的機會，
後面再碰到對應不上的，當然就是不能成為回文囉！
所以這題看似會產生分支，其實只會產生一次而已，
因為我們只能刪一次而已，所以這題的時間複雜度並不高。

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

Java

Java的部分求方便起見，使用了toCharArray()，
我們將後續略過1個字元檢查的函式稱為isp(isPalindrome)，
當validPalindrome內的迴圈檢查到不符合的時候，
便呼叫isp來分支檢查；進入isp時，則只有所有剩下的字元兩兩對應，
才會回傳true，否則一定會回傳false。

Python

Python的部分，一樣不要忘記被用到的子函式要先宣告在前面，
其它和Java的解大同小異。

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

「時間/空間複雜度？」
(O(len(s))/O(1)，
由於最多分支就只有一次，
所以總體的複雜度還是跟字串長有關；
Java的部分因為偷懶使用toCharArray()，
所以空間複雜度也是O(len(s))，願意節省一點的話，
也可以用CharAt()來取得某個位置的字元。)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 91 String (4)

Sun, 19 Apr 2020 00:00:00 +0800

0678. Valid Parenthesis String (Medium)

Question

Given a string containing only three types of characters: ‘(‘, ‘)’ and ‘*’, write a function to check whether this string is valid. We define the validity of a string by these rules:

Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
An empty string is also valid.

Example 1

1
2


Input: "()"
Output: True

Example 2

1
2


Input: "(*)"
Output: True

Example 3

1
2


Input: "(*))"
Output: True

Note: The string size will be in the range [1, 100].

分析/解題

給定一個字串，當中僅含三種字元：’(’, ‘)’, ‘*’ (左括號，右括號及米字號)，試寫一個函式以檢查這個字串是否有效。
一個字串要符合以下的規則才算是有效的：

任一個左括號都要有一個對應的右括號
任一個右括號都要有一個對應的左括號
左括號必須出現在其對應的右括號之前
米字號(*)可以被視為單一個右括號、左括號、或空字串
空字串也是有效的

綜合上面的描述，我們可以知道像是：
‘)(’ -> 右括號還沒對應就出現在左括號前所以是False；
但像是‘(()()*)’ 就會是True，
仔細觀察可以發現，如果我們先不考慮米字號的部分，
從左到右，左括號出現的次數必然 >= 右括號出現的次數。
(因為要兩兩相對應，且右括號不能還沒對應到就出現在左括號之前)

所以，如果是沒有米字號的話，這題會相當簡單：
定義一個cnt(初始值為0)，由左至右，
每次碰到左括號則+1，右括號則-1 ，中間如果cnt變為負數，
則代表有右括號還沒對應到就出現了 ，則有效性是False ；
而遍歷整個字串到結尾時，
如果cnt變為0 的話則有效性是True (剛好所有括號兩兩對應)，
否則則為False (還有未對應到的括號)。

那麼，加上米字號的話該怎麼辦呢？
我們可以先將所有的米字號當成左括號來用 ，
由左至右檢查是否左括號足夠配對右括號完還有剩。
假設中途左括號不夠的話 ，肯定是False (因為加上米字號都不夠用)；
配對完剛好用完 -> ** True**(因為所有的米字號全拿來當左括號剛好OK)
配對完左括號還有剩 呢？
這時候我們應該從右至左， 換成將所有的米字號當成右括號來用，
換成檢查右括號足不足夠配對。
中途右括號不夠 -> False；
最後如果右括號數量足夠的話，則為True。

最後一段我們需要更仔細的考慮原因：
有沒有可能在由左至右留下來多出來的部分是左括號呢？
答案是否定的，因為如果是這樣的話，這些多出來的部分，
在反方向的時候會因為它們不是米字號，使得右括號的數量不夠用 ，
從而讓中途不足以配對 的狀況發生。
所以要嘛就是剛好完全配對 ，不然的話，就是剩下的全都是米字號 ，
這樣反向時才有辦法處理。

所以，當雙向都能夠順利滿足的時候，
只要將多出來的米字號視作空字串，就能使整個字串得以滿足有效性了！

依照上面的邏輯，我們可以進行 two pass 經過整個字串，
完成整個檢查工作，其空間複雜度為O(1)，時間複雜度為O(n)。
(n為字串的長度)

寫成程式碼如下。

Java

Java的部分，使用charAt()來取得特定index的字元，
並分別設定l跟r變數來計算。(要設成同一個cnt變數也行，自己歸零即可)

Python

Python的部分，這邊使用三元運算子處理。
此外，如果不想用index一個一個數的話，
用for c in s以及for c in reversed(s)也可以。

讀者可能會留意到註解裡有附註了lee215的one pass解法 ，
有興趣的可以再深入了解。具體的思路是記錄從左至右途中，
我們現在需要等待多少右括號來將一組括號完整；
cmax 是將所有碰到的*都當作是左括號 處理，
(也就是最大可能會產生尚未配對的左括號數量)
而cmin 是中間能消去配對的狀況就消去 。
(也就是最少一定要被配對完成的左括號數量)
按這個條件的話，cmax必然要一直>=0，
且cmin再結尾時要剛好是0才可以。

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

「時間/空間複雜度？」
(O(n)/O(1)，n為字串長度，空間不論是哪種方式都只需常數大小)

「如果不管空間複雜度，你能使用stack來解這題嗎？」
(可以做配對然後將成對的括號吐掉，
具體可以參考以下幾個discussion的解法。
Java: https://leetcode.com/problems/valid-parenthesis-string/discuss/107572/Java-using-2-stacks.-O(n)-space-and-time-complexity.

Python: https://leetcode.com/problems/valid-parenthesis-string/discuss/145228/python-using-stack-20ms-beats-100-probably-the-easiest-solution)

相似及延伸

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

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

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

從LeetCode學演算法 - 85 String (3)

Thu, 30 Jan 2020 00:00:00 +0800

1332. Remove Palindromic Subsequences (Easy)

寫在前面

Question

Given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.

A string is called palindrome if is one that reads the same backward as well as forward.

Example 1

1
2
3


Input: s = "ababa"
Output: 1
Explanation: String is already palindrome

Example 2

1
2
3
4


Input: s = "abb"
Output: 2
Explanation: "abb" -> "bb" -> "".
Remove palindromic subsequence "a" then "bb".

Example 3

1
2
3
4


Input: s = "baabb"
Output: 2
Explanation: "baabb" -> "b" -> "".
Remove palindromic subsequence "baab" then "b".

Example 4

1
2


Input: s = ""
Output: 0

Constraints

0 <= s.length <= 1000
s only consists of letters ‘a’ and ‘b’

分析/解題

給定一個字串，當中僅由’a’或’b’的字母所構成，每次你可以從中移除一個palindrome subsequence. 試回傳將該字串刪成空字串所需的最小步數。

我們先前有講過subsequence的定義，可以參照之前的題目。
所以每次要移除掉一個subsequence且必須符合palindrome的條件，
乍看之下似乎不容易。
但選這題的目的就是要告訴大家，有時候事情並沒有想像中那麼複雜，
靜下心來好好推敲，可能可以找到適合的規律，
不要急著找通解，先試著去用上所有已知的條件 看看才對！

我們知道subsequence就是按照排列的先後順序取就可以了，
但palindrome(回文) 則必須取出來從頭到尾和從尾到頭一致才行。

我們先考慮最簡單的部分，再慢慢往下推。
1. 當字串是空白的時候：
不需操作 即可達到條件，所以總step為0。
2. 當字串本身就是palindrome：
把整個字串做為subsequence移除，所以總step為1。

接下來是最重要的部分，
如果字串本身不是palindrome的話，
要怎麼樣才會移除一個palindrome sequence後，
可以用最小步數化簡呢？
由於s僅僅由’a’和’b’所組成 ，
所以我們可以考慮直接移去全部的’a’或全部的’b’，
由於全部都是’a’或全部都是’b’也是一種palindrome，
所以符合前面移除的規則；
而剩下來的就全部都是另外一種字元，
同樣也構成palindrome。
因此，最多只要2個step，就能全數移完。

(想一下，如果今天是有N種不同的字元構成s，
最多就會需要N個step，但這只是上限而已，而不是minimum steps。)

有興趣寫更細的話，可以用two pointer來寫這題的檢查palindrome的部分，
這裡就直接用簡單的操作處理。

Java

Java的部分，操作reverse 要使用StringBuilder 來處理，
處理完以後，再轉回String。

Python

Python的部分更精簡，使用**[::-1]** 即可表達從尾到頭 的部分。

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

「時間/空間複雜度？」
(O(N)/O(N)，若願意一個一個字元比較的話，
空間複雜度也可以降到O(1)，也就是用簡單的two pointer處理即可)

相似及延伸

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

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

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

從LeetCode學演算法 - 77 String (2)

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

1071. Greatest Common Divisor of Strings (Easy)

Question

For strings S and T, we say “T divides S” if and only if S = T + ... + T (T concatenated with itself 1 or more times)

Return the largest string X such that X divides str1 and X divides str2.

Example 1

1
2


Input: str1 = "ABCABC", str2 = "ABC"
Output: "ABC"

Example 2

1
2


Input: str1 = "ABABAB", str2 = "ABAB"
Output: "AB"

Example 3

1
2


Input: str1 = "LEET", str2 = "CODE"
Output: ""

Note:

1 <= str1.length <= 1000
1 <= str2.length <= 1000
str1[i] and str2[i] are English uppercase letters.

分析/解題

給定兩字串，找出能「除盡」這兩個字串的最長字串X。
題目已經給定的非常明顯了就是在求gcd(最大公因數)，
因此，拿出小學就教過的輾轉相除法即可。
(要看起來厲害一點的話，也可以叫歐幾里得算法Euclidean algorithm)

輾轉相除法告訴我們說，兩個數的最大公因數，
就是不斷將大的除以小的，取出餘數替代之，直到能夠整除為止。
於是這邊變成字串時，我們的除就會比較麻煩一點。
為求簡單起見，我們可以固定將第一個字串選擇放比較長的 ，
如果發現相反 的話，則將兩者進行對調 。

所以就可以分成以下的步驟：

取兩字串長l1, l2，若l1 < l2 則呼叫遞迴將str1, str2交換
若str1和str2完全一樣，則回傳str1
若str1的前面的部分 和str2 一樣，則將str1扣除掉該部份 以後，
呼叫遞迴傳入繼續計算。
(因為我們操作字串的除只能一組一組扣掉 )
否則就回傳空字串 (因為不一樣的話代表完全沒有共同的字串，
跟數字的最大公因數是1概念一樣)

Java

Java的部分，字串相等請使用equals來比較，
而前面的部分一樣可以用startsWith函式，
並留意空字串要用雙引號，不能用單引號(因為單引號是char)。

Python

Python的部分，使用==和串列取值的方式，
可以簡單達成我們所需要的操作。

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

「時間/空間複雜度？」
(O(l1+l2)/O(l1+l2)，由於每階段會固定消去最小單位的長度，
所以最差的狀況就是全部都消去，也就做了兩字串長度的消去的動作，
但中間未考慮比較是否相等的狀況。
空間複雜度的部分，
Java的substring和Python的切list的方式都會產生新的單位，
理論上仍然最少會佔用到完整的l1+l2單位空間)

相似及延伸

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

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

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

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