JS實現字典dict的使用

兩個數組的交集

給定兩個數組，編寫一個函數來計算它們的交集。輸出結果中每個元素出現的次數，應與元素在兩個數組中出現的次數一致。我們可以不考慮輸出結果的順序。

示例：

輸入: nums1 = [1,2,2,1], nums2 = [2,2]
輸出: [2,2]

輸入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出: [4,9]

方法一：數組切割處理

//執行用時 :64 ms, 在所有 javascript 提交中擊敗了91.85%的用戶
//內存消耗 :33.8 MB, 在所有 javascript 提交中擊敗了86.17%的用戶
var intersect = function(nums1, nums2) {
  var res = [];
  //包含之後再清除
  for(var i=0;i<nums1.length;i++){
      if(nums2.includes(nums1[i])){
          res.push(nums1[i]);
          nums2.splice(nums2.indexOf(nums1[i]), 1);
      }
  }
  return res;
};

//執行用時 :72 ms, 在所有 javascript 提交中擊敗了66.52%的用戶
//內存消耗 :33.9 MB, 在所有 javascript 提交中擊敗了72.60%的用戶
var intersect = function (nums1, nums2) {
  return nums1.filter(el => nums2.includes(el) && nums2.splice(nums2.indexOf(el), 1))
};

方法二：字典

多加了記錄元素個數的功能，我們可以使用字典 dict 實現它


//執行用時 :76 ms, 在所有 javascript 提交中擊敗了52.47%的用戶
//內存消耗 :34.7 MB, 在所有 javascript 提交中擊敗了50.79%的用戶
var intersect = function (nums1, nums2) {
  var len1 = nums1.length;
  var len2 = nums2.length;
  if (len1 === 0 || len2 === 0) {
    return [];
  }

  var dict1 = {};
  var result = [];
  nums1.forEach((item, index) => {
    if (dict1.hasOwnProperty(item)) {
      dict1[item] += 1;
    } else {
      dict1[item] = 1;
    }
  })

  nums2.forEach((item) => {
    if (dict1.hasOwnProperty(item) && dict1[item] > 0) {
      result.push(item);
      dict1[item] -= 1;
    }
  })

  return result;
}

// 執行用時 :68 ms, 在所有 javascript 提交中擊敗了82.19%的用戶
// 內存消耗 :36 MB, 在所有 javascript 提交中擊敗了12.23%的用戶
var intersect = function (nums1, nums2) {
  var obj1 = arrChange(nums1);
  var obj2 = arrChange(nums2);
  var res = [];
  for (var pro in obj1) {
    if (obj2.hasOwnProperty(pro)) {
      obj1[pro].length < obj2[pro].length ? res.push(...obj1[pro]) : res.push(...obj2[pro]);
    }
  }
  return res;
};

function arrChange(arr) {
  var obj = {};
  arr.forEach((item, index) => {
    if (obj.hasOwnProperty(item)) {
      obj[arr[index]].push(item);
    } else {
      obj[arr[index]] = [item];
    }
  })
  return obj;
}

有效的字母異位詞

給定兩個字符串 s 和 t ，編寫一個函數來判斷 t 是否是 s 的字母異位詞

示例：

輸入: s = "anagram", t = "nagaram"
輸出: true

輸入: s = "rat", t = "car"
輸出: false

方法一：字典對各個字符出現的次數進行統計

var isAnagram = function (s, t) {
  if (s.length != t.length) {
    return false;
  }

  var calT = cal(t);
  for (var ele of s) {
    if (!t.includes(ele) || calT[ele] == 0) {
      return false;
    }
    calT[ele]--;
  }
  return true;
};

function cal(str) {
  var times = {};
  for (var ele of str) {
    if (times.hasOwnProperty(ele)) {
      times[ele]++;
    } else {
      times[ele] = 1;
    }
  }
  return times;
}

方法二：轉換成數組排序後對比


//執行用時 :116 ms, 在所有 javascript 提交中擊敗了48.25%的用戶
//內存消耗 :38.6 MB, 在所有 javascript 提交中擊敗了28.30%的用戶
var isAnagram = function (s, t) {
  return JSON.stringify(s.split('').sort()) === JSON.stringify(t.split('').sort());
};


//執行用時 :132 ms, 在所有 javascript 提交中擊敗了26.88%的用戶
//內存消耗 :38.1 MB, 在所有 javascript 提交中擊敗了43.10%的用戶
var isAnagram = function (s, t) {
  return s.split('').sort().join('') === t.split('').sort().join('')
};

var isAnagram = function (s, t) {
  const sort = str => [...str]
    .sort((a, b) => a.charCodeAt() - b.charCodeAt())
    .join('')
  return sort(s) === sort(t)   //如果輸入字符串包含 unicode 字符
};

同構字符串

給定兩個字符串 s 和 t，判斷它們是否是同構的。如果 s 中的字符可以被替換得到 t ，那麼這兩個字符串是同構的。所有出現的字符都必須用另一個字符替換，同時保留字符的順序。兩個字符不能映射到同一個字符上，但字符可以映射自己本身。

示例：

輸入: s = "egg", t = "add"
輸出: true

輸入: s = "foo", t = "bar"
輸出: false

輸入: s = "paper", t = "title"
輸出: true

比較每個字符下一次出現位置是否一致

//執行用時 :60 ms, 在所有 javascript 提交中擊敗了99.19%的用戶
//內存消耗 :35.3 MB, 在所有 javascript 提交中擊敗了66.33%的用戶
var isIsomorphic = function (s, t) {
  if (s.length != t.length) {
    return false;
  }

  for (let i = 0; i < s.length; i++) {
    if (s.indexOf(s[i], i + 1) !== t.indexOf(t[i], i + 1)) {
      return false;
    }
  }
  return true;
};

哈希，記錄兩個字符串中的被替換字符和替換字符，判斷是否是唯一

//執行用時 :72 ms, 在所有 javascript 提交中擊敗了81.91%的用戶
//內存消耗 :35.2 MB, 在所有 javascript 提交中擊敗了74.49%的用戶
var isIsomorphic = function (s, t) {
  if (s.length !== t.length) return false;
  let hashOne = {}, hashTwo = {}, len = s.length;
  for (let i = 0; i < len; i++) {
    let a = s[i], b = t[i];
    if (!hashOne[a] && !hashTwo[b]) {
      hashOne[a] = b;
      hashTwo[b] = a;
    } else if (hashOne[a] !== b || hashTwo[b] !== a) {
      return false;
    }
  }
  return true;
};


//執行用時 :80 ms, 在所有 javascript 提交中擊敗了54.02%的用戶
//內存消耗 :35.8 MB, 在所有 javascript 提交中擊敗了48.98%的用戶
var isIsomorphic = function (s, t) {
  //同構則說明能相互轉化
  var map = new Map();
  var map2 = new Map();
  for (var i = 0; i < s.length; i++) {
    map.set(s[i], t[i]);
    map2.set(t[i], s[i])
  }
  for (var j = 0; j < s.length; j++) {
    if (map.get(s[j]) !== t[j]) {
      return false;
    }
    if (map2.get(t[j]) !== s[j]) {
      return false;
    }
  }
  return true;
};

數組，判斷被替換字符與替換字符一一對應

//執行用時 :68 ms, 在所有 javascript 提交中擊敗了89.95%的用戶
//內存消耗 :35.7 MB, 在所有 javascript 提交中擊敗了51.02%的用戶
var isIsomorphic = function(s, t) {
  var a=[],l=[];
  if(s.length==0){
      return true;
  }
  for(var i=0;i<s.length;i++){
      if(s[i] in a){
          if(a[s[i]]!==t[i]){  //已經替換過的情況下，被替換字符與替換字符唯一對應
              return false;
          }
      }else{
          if(l.indexOf(t[i])!==-1){  //替換字符唯一
              return false;
          }
          a[s[i]]=t[i];
          l.push(t[i]);
      }
  }
  return true;
};

根據字符出現頻率排序

給定一個字符串，請將字符串裏的字符按照出現的頻率降序排列

示例：

輸入:
"tree"

輸出:
"eert"

解釋:
'e'出現兩次，'r'和't'都只出現一次。
因此'e'必須出現在'r'和't'之前。此外，"eetr"也是一個有效的答案。


輸入:
"Aabb"

輸出:
"bbAa"

解釋:
此外，"bbaA"也是一個有效的答案，但"Aabb"是不正確的。
注意'A'和'a'被認爲是兩種不同的字符。

//執行用時 :76 ms, 在所有 javascript 提交中擊敗了96.69%的用戶
//內存消耗 :38.4 MB, 在所有 javascript 提交中擊敗了54.05%的用戶
var frequencySort = function(str) {
  let map = new Map()
  let result = ''
  str.split('').forEach(item => {
    if (map.has(item)) {
      map.set(item, map.get(item) + 1)
    } else {
      map.set(item, 1)
    }
  })
  map = [...map]
    .sort((a, b) => b[1] - a[1])
    .map(item => {
      result += item[0].repeat(item[1])
    })
  return result
}

//執行用時 :136 ms, 在所有 javascript 提交中擊敗了7.28%的用戶
//內存消耗 :44 MB, 在所有 javascript 提交中擊敗了24.32%的用戶
var frequencySort = function (s) {
  const sArr = [...s];
  const record = new Map();

  sArr.forEach(value => {
    record.set(value, (record.get(value) || 0) + 1)
  })
  return sArr.sort((a, b) => record.get(b) == record.get(a) ? a.charCodeAt(0) - b.charCodeAt(0) : record.get(b) - record.get(a)).join('');
};

字典

//執行用時 :100 ms, 在所有 javascript 提交中擊敗了40.40%的用戶
//內存消耗 :44.6 MB, 在所有 javascript 提交中擊敗了10.81%的用戶
var frequencySort = function (s) {
  var calTimes = {};
  for (let str of s) {
    if (!calTimes.hasOwnProperty(str)) {
      calTimes[str] = 1;
    } else {
      calTimes[str]++;
    }
  }

  var sortStr = sortObj(calTimes);
  var res = '';
  sortStr.forEach((key) => {
    while (calTimes[key] > 0) {
      res += key;
      calTimes[key]--;
    }
  })
  return res;
}

function sortObj(obj) {
  return Object.keys(obj).sort((a, b) => {
    return obj[b] - obj[a];
  })
}

題目來源於leetcode: https://leetcode-cn.com/explore

丫an梅

發佈了54 篇原創文章 · 獲贊 13 · 訪問量 9150

私信關注

JS實現字典dict的使用

兩個數組的交集

有效的字母異位詞

同構字符串

根據字符出現頻率排序

[轉帖]使用NMT和pmap解決JVM資源泄漏問題原創

Python實現大麥網搶票的四大關鍵技術點解析

Python 安裝庫指令大全

salesforce零基礎學習（一百三十八）零碎知識點小總結（十）

一款開源的.NET程序集反編譯、編輯和調試神器

關於接口協議，你必須要知道這些！

【2024-05-21】以茶會友

基於Node與express完成圖書管理系統項目

JS解決查找表與求和問題

ES6開發-babel

Node.js實現服務器配置

Node.js模塊封裝

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結