給你兩個字串 word1 和 word2 。請你從 word1 開始，通過交替新增字母來合併字串。如果一個字串比另一個字串長，就將多出來的字母追加到合併後字串的末尾。
返回 合併後的字串 。
範例 1：
輸入：word1 = "abc", word2 = "pqr"
輸出："apbqcr"
解釋：字串合併情況如下所示：
word1： a b c
word2： p q r
合併後： a p b q c r範例 2：
輸入：word1 = "ab", word2 = "pqrs"
輸出："apbqrs"
解釋：注意，word2 比 word1 長，"rs" 需要追加到合併後字串的末尾。
word1： a b
word2： p q r s
合併後： a p b q r s範例 3：
輸入：word1 = "abcd", word2 = "pq"
輸出："apbqcd"
解釋：注意，word1 比 word2 長，"cd" 需要追加到合併後字串的末尾。
word1： a b c d
word2： p q
合併後： a p b q c d提示：
1 <= word1.length, word2.length <= 100word1 和 word2 由小寫英文字母組成時間6 ms 擊敗 12.69%
記憶體40.6 MB 擊敗 10.66%
在這個程式中，我們需要將兩個字串按照交替的順序合併起來。我們首先找到兩個字串的最小長度和最大長度。然後，我們用一個迴圈將兩個字串的字元按照交替的順序逐個取出來，並將它們相加到一個新的字串中。如果有一個字串的長度較短，那麼我們需要將較長的字串中剩餘的字元都新增到結果字串的末尾。最後，我們返回合併後的字串作為結果。
這個程式涉及到以下幾個知識點：
class Solution {
public String mergeAlternately(String word1, String word2) {
int finalMinLength=Math.min(word1.length(), word2.length());
int finalMaxLength=Math.max(word1.length(), word2.length());
String result="";
int i=0;
for(i=0;i<finalMinLength;i++){
result+=(word1.substring(i,i+1)+word2.substring(i,i+1));
}
if(finalMinLength==finalMaxLength){
return result;
}else if(finalMinLength==word1.length()){
result+=word2.substring(i);
}else{
result+=word1.substring(i);
}
return result;
}
}給定兩個字串 s 和 t ，它們只包含小寫字母。
字串 t 由字串 s 隨機重排，然後在隨機位置新增一個字母。
請找出在 t 中被新增的字母。
範例 1：
輸入：s = "abcd", t = "abcde"
輸出："e"
解釋：'e' 是那個被新增的字母。範例 2：
輸入：s = "", t = "y"
輸出："y"
提示：
0 <= s.length <= 1000t.length == s.length + 1s 和 t 只包含小寫字母時間1 ms 擊敗 98.85%
當我們把兩個相同的數進行互斥或運算時，結果為 0。所以如果字串 t 是由字串 s 隨機重排並在隨機位置新增一個字母得到的，那麼 t 中的所有字元都可以與 s 中的相應字元進行互斥或運算，最後得到的結果就是新增的字母。
具體步驟如下：
假設有以下輸入：
s = "hello" t = "lohlel"
我們可以按照以下步驟來解釋演演算法的執行：
首先，對字串 s 進行遍歷，依次進行互斥或運算：
然後，對字串 t 進行遍歷，同樣進行互斥或運算：
最後的結果為 0，表示在 t 中被新增的字母是 'e'。
通過對 s 和 t 進行互斥或運算，最後運算的結果就是被新增的字母。
程式用到的知識點包括：
class Solution {
public char findTheDifference(String s, String t) {
char result = 0;
for (char c : s.toCharArray()) {
result ^= c;
}
for (char c : t.toCharArray()) {
result ^= c;
}
return result;
}
}給你兩個字串 haystack 和 needle ，請你在 haystack 字串中找出 needle 字串的第一個匹配項的下標（下標從 0 開始）。如果 needle 不是 haystack 的一部分，則返回 -1 。
範例 1：
輸入：haystack = "sadbutsad", needle = "sad"
輸出：0
解釋："sad" 在下標 0 和 6 處匹配。
第一個匹配項的下標是 0 ，所以返回 0 。範例 2：
輸入：haystack = "leetcode", needle = "leeto"
輸出：-1
解釋："leeto" 沒有在 "leetcode" 中出現，所以返回 -1 。
提示：
1 <= haystack.length, needle.length <= 104haystack 和 needle 僅由小寫英文字元組成時間0 ms 擊敗 100%
記憶體39.4 MB 擊敗 64.64%
這道題劃歸為中等難度著實有些無語了
class Solution {
public int strStr(String haystack, String needle) {
return haystack.indexOf(needle);
}
}給定兩個字串 s 和 t ，編寫一個函數來判斷 t 是否是 s 的字母異位詞。
注意：若 s 和 t 中每個字元出現的次數都相同，則稱 s 和 t 互為字母異位詞。
範例 1:
輸入: s = "anagram", t = "nagaram"
輸出: true範例 2:
輸入: s = "rat", t = "car"
輸出: false
提示:
1 <= s.length, t.length <= 5 * 104s 和 t 僅包含小寫字母
進階: 如果輸入字串包含 unicode 字元怎麼辦？你能否調整你的解法來應對這種情況？
時間340 ms 擊敗 5.49%
解題思路如下：
class Solution {
public boolean isAnagram(String s, String t) {
char [] a1=s.toCharArray();
char [] a2=t.toCharArray();
Arrays.sort(a1);
Arrays.sort(a2);
String resultA="";
String resultB="";
for (char c : a1) {
resultA+= c;
}
for (char c : a2) {
resultB+= c;
}
return resultA.equals(resultB);
}
}程式用到的知識點包括：
給定一個非空的字串 s ，檢查是否可以通過由它的一個子串重複多次構成。
範例 1:
輸入: s = "abab"
輸出: true
解釋: 可由子串 "ab" 重複兩次構成。範例 2:
輸入: s = "aba"
輸出: false範例 3:
輸入: s = "abcabcabcabc"
輸出: true
解釋: 可由子串 "abc" 重複四次構成。 (或子串 "abcabc" 重複兩次構成。)
提示：
1 <= s.length <= 104s 由小寫英文字母組成時間83 ms 擊敗 23.96%
記憶體42.8 MB 擊敗 43.30%
class Solution {
public boolean repeatedSubstringPattern(String s) {
String str = s+s;
str = str.substring(1,str.length() - 1);
return str.contains(s);
}
}給定一個陣列 nums，編寫一個函數將所有 0 移動到陣列的末尾，同時保持非零元素的相對順序。
請注意 ，必須在不復制陣列的情況下原地對陣列進行操作。
範例 1:
輸入: nums = [0,1,0,3,12] 輸出: [1,3,12,0,0]範例 2:
輸入: nums = [0] 輸出: [0]
提示:
1 <= nums.length <= 104-231 <= nums[i] <= 231 - 1時間1 ms 擊敗 100%
可以使用雙指標的方法，一個指標用於遍歷陣列，另一個指標指向下一個非零元素應該插入的位置。
具體步驟如下：
初始化兩個指標，i指向當前遍歷的元素，j指向下一個非零元素應該插入的位置。
遍歷陣列，如果當前元素為0，則繼續遍歷下一個元素；如果當前元素不為0，則將當前元素複製到j指向的位置，並將i和j都加1。
遍歷完陣列後，將j之後的所有元素都置為0，以保證陣列長度不變。
class Solution {
public void moveZeroes(int[] nums) {
int i = 0, j = 0;
for (; i < nums.length; i++) {
if (nums[i] != 0) {
nums[j] = nums[i];
j++;
}
}
while (j < nums.length) {
nums[j] = 0;
j++;
}
}
}程式涉及到以下的一些知識點：
陣列操作：對陣列進行遍歷、修改陣列元素的值等等。
雙指標：使用兩個指標來進行陣列操作，一個指向當前遍歷的元素，另一個指向下一個非零元素應該插入的位置。
條件判斷：在遍歷陣列的過程中，通過條件判斷來判斷當前元素是否為0。
陣列長度：使用陣列長度來確定遍歷的範圍和陣列的結束位置。
給定一個由 整數 組成的 非空 陣列所表示的非負整數，在該數的基礎上加一。
最高位數位存放在陣列的首位， 陣列中每個元素只儲存單個數位。
你可以假設除了整數 0 之外，這個整數不會以零開頭。
範例 1：
輸入：digits = [1,2,3]
輸出：[1,2,4]
解釋：輸入陣列表示數位 123。範例 2：
輸入：digits = [4,3,2,1]
輸出：[4,3,2,2]
解釋：輸入陣列表示數位 4321。範例 3：
輸入：digits = [0]
輸出：[1]
提示：
1 <= digits.length <= 1000 <= digits[i] <= 9時間11 ms 擊敗 0.89%
記憶體40.7 MB 擊敗 5.18%
具體步驟如下：
import java.math.BigInteger;
class Solution {
public int[] plusOne(int[] digits) {
int length=digits.length;
String sum="";
for(int i=0;i<length;i++){
sum=sum+digits[i];
}
BigInteger number=new BigInteger(sum);
number=number.add(BigInteger.ONE);
char[] charArray = number.toString().toCharArray();
int[] intArray = new int[charArray.length];
for(int i = 0; i < charArray.length; i++) {
intArray[i] = Character.getNumericValue(charArray[i]);
}
return intArray;
}
}這個程式用到了以下知識點：