摘要：實現優化思路直接一路暴力下來，免去了預先定義數組及從二維數組中取值，故速度空間都得到節省。初始思路創建，雙循環組裝出實際文件路徑，并將內容作為，數組為放入相同數組不斷插入，最后取整合出目標二維數組。

難度：easy

標簽：ASCII碼

初始思路：大寫字母ASCII范圍65-90，小寫字母ASCII范圍97-122，func_大寫轉小寫即為val+32

resultStr = ""
for(str) {
    if (str[i] in 大寫字母ASCII碼范圍) {
        resultStr + = func_大寫轉小寫（str[i]）
    } else {
        resultStr += str[i]
    }
}
return resultStr

復雜度：時間 O(N), 空間 O(1)

優化：
第一次優化：使用正則判斷字符是否處于大寫字母ASCII碼范圍，只有處于該范圍內才進行進行轉ASCII處理，結果復雜度不變，減少了轉換ASCII碼的次數。實現如下：

var toLowerCase = function(str) {
    let resultStr = "";
    for (let i=0, strLen=str.length; i


804 uniqueMorseRepresentations

難度：easy
初始思路：使用Set存儲計算結果
復雜度: 時間：雙for=>O(n^2), 空間：最差情況即全部字符串Morse碼不同時為O(n)

實現：
var uniqueMorseRepresentations = function(words) {
    let morseArr = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."];
    let set = new Set();
    for (let i=0, wordsLen=words.length; i


929 numUniqueEmails

難度：easy
標簽：Set  正則

題意分析：只需關注@前面部分，遇.去掉，遇+忽略其后字符;

初始思路：基于@分割，前面部分正則去點，然后取加號之前的部分，組合放入set去重;

復雜度：時間O(n)，空間O(n)

實現
var numUniqueEmails = function(emails) {
     let set = new Set();
     for (let i=0, emailsLen=emails.length; i-1) { localStr=localStr.slice(0, indexAdd); }
         set.add(localStr+"@"+tempArr[1]);
     }
     return set.size;
 };




首次優化：先基于加號分割再正則去點，組合操作一起提高可讀性；

實現：
var numUniqueEmails = function(emails) {
    let set = new Set();
    for (let i=0, emailsLen=emails.length; i



22 generateParenthesis

難度： medium
標簽：遞歸


初始思路：創建校驗函數，生成所有情況的組合后逐個校驗；
復雜度：時間、空間都 N!




優化：分析正確組合結果生成規律，只生成符合要求的結果；


左右括號規則（每次新增都有添加左括號和添加右括號兩種選擇，故重點在于了解不得添加情況）：
1 . 不可加左括號：左括號數量===Num
2 . 不可加右括號：首位、左右括號數量相等時

思路：用函數不斷根據左右括號規則運行添加，最終生成目標結果；
復雜度：時間O(n)、空間O(n)

實現：
var generateParenthesis = function(n) {
    let arr = [];
    if (n===0) return [];
    calcFunc(arr, n, 0, 0, "");  
    return arr;
};

function calcFunc(resultArr, N, leftNum, rightNum, currStr) {
    if (leftNum+rightNum === N*2) {
        resultArr.push(currStr);
        return;
    }
    if (leftNum !== N) {
        calcFunc(resultArr, N, leftNum+1, rightNum, currStr+"(");
    }
    if (currStr !== "" && leftNum !== rightNum) {
        calcFunc(resultArr, N, leftNum, rightNum+1, currStr+")");
    }
}



657 judgeCircle

難度：easy

初始思路：放置兩個計數器，for字符串并增減計數器，最終計數器歸0則True;

復雜度：時間O(n) 空間O(1)

實現：
var judgeCircle = function(moves) {
  let [x, y] = [0, 0];
  for (let i=0, movesLen=moves.length; i




思路二:使用Hashmap做需要字符數量的存儲，及最后用以對比

復雜度：時間O(n) 空間O(1)
實現：

let map = new Map();
map.set("U", 0);
map.set("D", 0);
map.set("L", 0);
map.set("R", 0);
for (let i=0, movesLen=moves.length; i


344 reverseString

難度：easy
題意分析：原地翻轉數組并輸出，空間復雜度需為O(1)

思路：首尾ij向中間推進并交換，i

復雜度：時間O(n), 空間O(1)
實現：

var reverseString = function(s) {
    let [i, j] = [0, s.length-1];
    while (i


890 findAndReplacePattern

難度：medium
題意分析：word和pattern的每個字母能構成不重復映射即滿足條件

初始思路：for words, 再for pattern.length, 當map不存在當前字母則添加，當map存在當前字母時比對，成功繼續,失敗next word

Tip:隱蔽規則：“沒有兩個字母映射到同一個字母”, 即字母列表&對應pattern列表長度應始終一致（借助set與map長度對比)
復雜度：時間O(n)，空間O(n)
實現:

var findAndReplacePattern = function(words, pattern) {
    let resultArr = [];
    let patternLen = pattern.length;
    for(let i=0, wordsLen=words.length; i


圍觀：

排名第一：遍歷pattern用pattern.indexOf(item)獲取下標數組，使words也按照這個方法對比；
其他：大同小異封裝方法,只封裝一次用以檢測足矣;


總結:本題其實是:"如何制定對比word和pattern的規則",注意點是一一映射



557 reverseWords

難度：easy
題意分析："注意"中提到，"每個單詞由單個空格分隔，且字符串中不會有任何額外的空格"，于是解題只需要先基于單個空格作分割，然后依次反轉每個單詞就行(時間復雜度：O(n^2)，空間復雜度：O(n^2))

實現：
var reverseWords = function(s) {
    let resultS = ""
    let arr = s.split(" ")
    for (let i=0, arrLen=arr.length; i


思路二：遍歷字符串并處理每段單詞（記錄開始位，遇到【下位為空格or最后一位】記錄結束位&處理，處理完成后記錄結束位+2為起始位），時間空間復雜度不變，減少了split("").reverse().join("")造成的空間損耗，實現如下：
var reverseWords = function(s) {
    let arr = s.split("")
    let [startIndex, endIndex] = [0, 0]
    for (let i=0, arrLen=arr.length; i


537 complexNumberMultiply

難度：medium
題意分析：根據給定的兩個格式為a+bi的復數字符串，計算出a+bi格式的結果字符串

思路：使用字符串分割或者正則提取輸入字符串的a和b值，計算得出結果a和b值，填充入模板字符串并返回

復雜度：時空均O(1)

實現：
var complexNumberMultiply = function(a, b) {
    let [aArr, bArr] = [a.split("+"), b.split("+")]
    let [a1, b1] = [aArr[0], aArr[1].split("i")[0]]
    let [a2, b2] = [bArr[0], bArr[1].split("i")[0]]
    let [aResult, bResult] = [a1*a2-b1*b2, a1*b2+a2*b1]
    return `${aResult}+${bResult}i`
}




521 findLUSlength

難度：easy
題意分析：這道題著重題意分析，目標是獲取最長特殊序列（定義：獨有的最長子序列）。可得兩字符串不相同時必定不互為子序列，故取長者返回；若相等則互為子序列而非最長特殊序列，即不存在，返回-1

實現：
var findLUSlength = function(a, b) {
    if (a === b) { 
        return -1 
    } else {
        return Math.max(a.length, b.length)
    }
};


791 customSortString

難度：medium
題意解析：使T按照S的順序做排列，S中不存在的字符可隨意排列

思路一：暴力思路（不推薦）。切分S形成順序數組，并以此形成char+count的Map。for T并加入Map，for SArr按序形成結果字符串

特點：思路簡單，空間占用多，代碼繁瑣
復雜度:時間O(T), 空間O(S+2T)

實現：
var customSortString = function(S, T) {
    let orderArr = S.split("")
    let countMap = new Map()
    let resultS = ""
    for (let i=0, SLen=S.length; i




思路二：用Map存儲S順序，然后用數組存儲每個S位置所對應的所有T字符，整合輸出

特點：思路&代碼清晰

實現：
var customSortString = function(S, T) {
    let SLen = S.length
    let map = new Map()
    let resultArr = Array.from({length: SLen+1}, ()=>"")
    for (let i=0; i




791 numSpecialEquivGroups

難度：easy
題意分析：目標是將數組內特殊等價的字符串歸納為一組并求總數組長度。判斷是否為特殊等價的依據是，奇位字符相同&偶位字符相同（忽略順序）。

思路：for數組，取得item并將其分開為奇字符串及偶字符串，sort兩個字符串并整合放入Set中，Set長度即結果。

實現
var numSpecialEquivGroups = function(A) {
  let set = new Set();
  let itemSize = A[0].length;
  for (let i=0, ALen=A.length; i



12. intToRoman

難度：medium
題意分析：將一個0~3999的數轉換為羅馬數字

初始思路：枚舉0~9(間隔1)、10-90(間隔10)、100~900(間隔100)、1000-3000(間隔1000), 然后循環取數字最后一位取得對應字符串，累加結果。

實現：
var intToRoman = function(num) {
    let fixedArr = [
        ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"],
        ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"],
        ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"],
        ["", "M", "MM", "MMM"]
    ];
    let resultStr = "";
    let count = 0;
    while (num!==0) {
        resultStr = fixedArr[count++][num%10] + resultStr
        num = Math.floor(num/10)
    }
    return resultStr;
};



優化思路：直接一路暴力if下來，免去了預先定義數組及從二維數組中取值，故速度空間都得到節省。

實現：
var intToRoman = function(num) {
    let resultStr = ""
    if (num>=1000) {
        for (let i=0, len=Math.floor(num/1000); i=900) {
        resultStr += "CM"
        num -= 900
    }
    if (num>=500) {
        resultStr += "D"
        num -= 500
    }
    if (num>=400) {
        resultStr += "CD"
        num -= 400
    }
    if (num>=100) {
        for (let i=0, len=Math.floor(num/100); i=90) {
        resultStr += "XC"
        num -= 90
    }
    if (num>=50) {
        resultStr += "L"
        num -= 50
    }
    if (num>=40) {
        resultStr += "XL"
        num -= 40
    }
    if (num>=10) {
        for (let i=0, len=Math.floor(num/10); i=9) {
        resultStr += "IX"
        num -= 9
    }
    if (num>=5) {
        resultStr += "V"
        num -= 5
    }
    if (num>=4) {
        resultStr += "IV"
        num -= 4
    }
    if (num>=1) {
        for (let i=0; i



13. romanToInt

難度：easy
題意分析：將羅馬數字轉換為數字

思路：創建對象映射單個羅馬數字與數值的關系，遍歷羅馬數字字符串，比較第 i 位與第 i+1 位的值，如果第 i 位的值小于第 i+1 位，則額外計算，其他情況直接計算獲得結果。

實現：
var romanToInt = function(s) {
    let fixedObj = {
        "": 0,
        "I": 1,
        "V": 5,
        "X": 10,
        "L": 50,
        "C": 100,
        "D": 500,
        "M": 1000
    };
    let result = 0;
    for (let i=0; ifixedObj[s[i]]) {
            result += fixedObj[s[i+1]] - fixedObj[s[i++]];
        } else {
            result += fixedObj[s[i]];
        }
    }
    return result;
};



1016. queryString

難度：medium
題意解析：確認 1~N 的每個數的二進制表示都是 S 的子串。

思路：編寫一個數字轉二進制字符串方法（避開32位限制），for 數組轉換結果，確定是否在 S 中都存在。(由于只要一個二進制字符串不匹配就退出故實際運行時間應該是更低的)

復雜度: 時間 O(n), 空間 O(N)

實現：
var queryString = function(S, N) {
    for (let i=0; i<=N; ++i) {
        if (S.indexOf(num2bin(i)) === -1) {
            return false;
        }
    }
    return true;
};

function num2bin (num){
    let binStr = "";
    while(num>0) {
        binStr = num%2 + binStr;
        num = Math.floor(num/2);
    }
    return binStr;
}




49. groupAnagrams

難度：medium
題意解析：將字符串數組中，字母組成相同的詞歸納到同一數組內，再合并進數組。

初始思路：遍歷數組，對item進行 sort 并作為 map 的key，value 為計數器的計數（也是結果數組的 index），根據map.has(key)的情況，數組分別尾增新數組或在特定數組中尾插單詞。

復雜度：時間 O(n), 空間復雜度O(n)

實現：
var groupAnagrams = function(strs) {
    let map = new Map();
    let resultArr = [];
    let count = 0;
    for (let i=0, arrLen=strs.length; i




優化思路：用 map 存放 a-z 映射到26個質數的鍵值對，用每次"拆分 item 對獲得乘積" 替換 "sort item"的過程

復雜度：同上. 中間的從 item 獲取 key 的過程被簡化了。

實現：
var groupAnagrams = function(strs) {
    var fixedObj={
        a:2,
        b:3,
        c:5,
        d:7,
        e:11,
        f:13,
        g:17,
        h:19,
        i:23,
        j:29,
        k:31,
        l:37,
        m:41,
        n:43,
        o:47,
        p:53,
        q:59,
        r:61,
        s:67,
        t:71,
        u:73,
        v:79,
        w:83,
        x:89,
        y:97,
        z:101
    }
    let map = new Map();
    let resultArr = [];
    let count = 0;
    for (let i=0, arrLen=strs.length; i




824. toGoatLatin

難度：easy

題意解析：句子可被空格分割為 n 個單詞，每個單詞處理如下：

單詞開頭為元音則尾部+ma+a*(單詞在數組中的下標+1)；
非元音開頭則單詞摘出開頭+開頭+ma+a*(單詞在數組中的下標+1)；



解題思路：按照題意編寫代碼

實現：
var toGoatLatin = function(S) {
    let arr = S.split(" ");
    for (let i=0, arrLen=arr.length; i



609.findDuplicate

難度：medium
題意解析：給定一個二維數組，每個子數組第一個元素為根目錄，第二到第 n 個元素為文件+文件內容，目標是將相同文本內容的文件路徑名放入同一數組。

初始思路：創建 map，雙 for 循環組裝出實際文件路徑，并將內容作為key，數組為 value 放入 map, 相同數組不斷插入 value，最后取 map.values() 整合出目標二維數組。

實現：
var findDuplicate = function(paths) {
    let map = new Map();
    for (let i=0, pathsLen=paths.length; i 1) {
            resultArr.push(value)
        }
    }
    return resultArr
};



優化思路：

優化點1：將中間的"兩次切分字符串"改為"字符串截取"，減少了空間消耗；

優化點2：最后從 map.values()生產目標二維數組的過程使用 ES6語法的 Array.from + filter 代替，提高執行效率（副作用是加大內存消耗）；

實現：
var findDuplicate = function(paths) {
    let map = new Map();
    for (let i=0, pathsLen=paths.length; iitem.length>1);
};





49. groupAnagrams

難度：medium
題意解析：從包含數個字符串的數組中獲取包含字母完全相同的字符串。

初始解法：通過鍵值對方法，將每個字符串的字母排序形成鍵，鍵相同的字符串放到一起。

復雜度：時間O(n)、空間O(n)

實現：
var groupAnagrams = function(strs) {
    let map = new Map();
    for (let i=0, strsLen=strs.length; i




788. rotatedDigits

難度：easy

題意解析：計算 1-》N 中間的數字有多少個是好數，好數的定位為180旋轉后仍為數字且不與原數相等。即滿足數字為好數的前提是：

1）翻轉后所有數字有效（0，1，2，5，6，8，9）；
2）至少一個數字為不同數；（2，5，6，9）



初始解法：所有數均為有效=》沒有無效數字=》不包含(3，4，7), 故只要滿足包含(2,5,6,9)且不包含(3,4,7)即符合要求，用正則可以簡單得出結果。

實現：
var rotatedDigits = function(N) {
let count = 0;
    for (let i=1, len=N+1; i



To Be Continue~