新增leetcode解題練習

javascript/LeetCode/Array/1725.js

@@ -0,0 +1,46 @@
+/**
+ * 1725. Number Of Rectangles That Can Form The Largest Square
+ * 
+ * @param {number[][]} rectangles
+ * @return {number}
+ */
+var countGoodRectangles = function(rectangles) {
+    /**
+     * 2維陣列，每個陣列元素分別代表該陣列三角形的長l、寬w
+     * each rectangle are of lengths [5,3,5,5] is min of [l,w] 
+     * 回傳有幾個maxLen可組成三角形
+    */
+   // solution 1
+  //  let rectangleLen = [];
+  //  let countMaxLen = 0;
+  //  for(const eachLen of rectangles){
+  //     rectangleLen.push(parseInt(Math.min(...eachLen)));
+  //  }
+  // let maxLen = Math.max(...rectangleLen);
+  // for(let i = 0;i < rectangleLen.length;++i) {
+  //   if(rectangleLen[i] === maxLen){
+  //     countMaxLen++;
+  //   }
+  // }
+  // return countMaxLen;
+
+  // solution 2.
+  // time:O(N)
+  let count = 0, maxLen = 0;
+  for(const eachLen of rectangles) {
+    let side = Math.min(...eachLen);
+
+    if(side > maxLen){
+      count = 1;
+      maxLen = side;
+    }else if(side === maxLen){
+      count++;
+    }
+  }
+  return count;
+};
+let rectangles = [[5,8],[3,9],[5,12],[16,5]]
+// Output: 3
+// Explanation: The largest squares you can get from each rectangle are of lengths [5,3,5,5].
+// The largest possible square is of length 5, and you can get it out of 3 rectangles.
+console.log(countGoodRectangles(rectangles));

javascript/LeetCode/Array/1848.js

@@ -0,0 +1,27 @@
+/**
+ * 1848. Minimum Distance to the Target Element
+ * 
+ * @param {number[]} nums
+ * @param {number} target
+ * @param {number} start
+ * @return {number}
+ */
+var getMinDistance = function(nums, target, start) {
+    /**
+     * nums[i] === target
+     * 找最小的abs(i - start)
+     */
+    let minDistance = Infinity;
+    for(let i = 0;i < nums.length;++i) {
+      if(nums[i] === target){
+        minDistance = Math.min(minDistance,Math.abs(i - start));
+      }
+    }
+    return minDistance;
+};
+// let nums = [1,2,3,4,5], target = 5, start = 3
+// Output: 1
+// Explanation: nums[4] = 5 is the only value equal to target, so the answer is abs(4 - 3) = 1.
+let nums = [1,1,1,1,1,1,1,1,1,1], target = 1, start = 9;
+// 0
+console.log(getMinDistance(nums,target,start));

javascript/LeetCode/Array/2515.js

@@ -0,0 +1,38 @@
+/** 
+ * 2515. Shortest Distance to Target String in a Circular Array
+ * 
+ * 陣列是一個圓，意味著陣列頭元素可以取得陣列尾元素
+ * 從左邊或右邊開始都能通
+ * 
+ * @param {string[]} words
+ * @param {string} target
+ * @param {number} startIndex
+ * @return {number}
+ */
+var closestTarget = function(words, target, startIndex) {
+    /**
+     * 若陣列中沒有元素符合target，回傳-1
+     * 往左或往右找
+     * 回傳最短能到words[target]的距離
+     */
+    for(let i = 0;i < words.length;++i) {
+      let right = (startIndex + i) % words.length;
+      let left = (startIndex - i + words.length) % words.length;
+
+      if(words[left] === target || words[right] === target){
+        return i;
+      }
+    }
+    return -1;
+};
+let word = ["hello","i","am","leetcode","hello"], target = "hello", startIndex = 1
+/*
+Output: 1
+Explanation: We start from index 1 and can reach "hello" by
+- moving 3 units to the right to reach index 4.
+- moving 2 units to the left to reach index 4.
+- moving 4 units to the right to reach index 0.
+- moving 1 unit to the left to reach index 0.
+The shortest distance to reach "hello" is 1.
+*/
+console.log(closestTarget(word,target,startIndex));

javascript/LeetCode/Array/3740.js

@@ -0,0 +1,40 @@
+/**
+ * 3740. Minimum Distance Between Three Equal Elements I
+ * 
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumDistance = function(nums) {
+    /**
+     * good定義：nums[i] == nums[j] == nums[k].
+     * 其中(i, j, k)是3個不重複index且元素一樣
+     * distance of a good tuple is abs(i - j) + abs(j - k) + abs(k - i), where abs(x) denotes the absolute value of x.
+     * 回傳最小good tuple，否則-1
+     * 
+     * 必須要有3個元素是一樣的
+     */
+    let ans = Infinity;
+    if(nums.length < 2){
+      return -1;
+    }
+    for(let i = 0;i < nums.length;++i) {
+      for(let j = i+1;j < nums.length;++j) {
+        if(nums[i] === nums[j]){
+          for(let k = j+1;k < nums.length;++k) {
+            if(nums[j] === nums[k]){
+              ans = Math.min(ans,2*(k-i));
+             }
+          }
+        }
+      }
+    }
+    return ans === Infinity ? -1 : ans;
+};
+let nums = [1,1,2,3,2,1,2]
+/*
+Output: 8
+Explanation:
+The minimum distance is achieved by the good tuple (2, 4, 6).
+(2, 4, 6) is a good tuple because nums[2] == nums[4] == nums[6] == 2. Its distance is abs(2 - 4) + abs(4 - 6) + abs(6 - 2) = 2 + 2 + 4 = 8.
+*/
+console.log(minimumDistance(nums));

javascript/LeetCode/Array/3761.js

@@ -0,0 +1,44 @@
+/**
+ * 3761. Minimum Absolute Distance Between Mirror Pairs
+ * 
+ * mirror pair = indices(i,j)
+ * reverse(nums[i] === nums[j]) 若數字前面為0，則省略0
+ * 回傳最小mirror pair絕對距離 abs(i - j)，若無，回傳-1
+ * 
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minMirrorPairDistance = function(nums) {
+  /**
+   * 陣列元素兩個為一組(i,j)，每個元素反轉後跟下一個元素比較是否一致。若一致 abs(index i - index j)，取最小結果
+   */
+  // 反轉數字
+  function reverseNum(x){
+    let y = 0;
+    while(x > 0){
+      y = y * 10 + (x % 10);
+      x = Math.floor(x / 10);
+    }
+    return y;
+  }
+
+  let map = new Map();
+  let ans = nums.length + 1;
+  for(let i = 0;i < nums.length;i++){
+    if(map.has(nums[i])){
+      ans = Math.min(ans,i - map.get(nums[i]));
+    }
+    map.set(reverseNum(nums[i]),i);
+  }
+  return ans === nums.length + 1 ? -1 : ans;
+};
+let nums = [12,21,45,33,54]
+/*
+Output: 1
+Explanation:
+The mirror pairs are:
+(0, 1) since reverse(nums[0]) = reverse(12) = 21 = nums[1], giving an absolute distance abs(0 - 1) = 1.
+(2, 4) since reverse(nums[2]) = reverse(45) = 54 = nums[4], giving an absolute distance abs(2 - 4) = 2.
+The minimum absolute distance among all pairs is 1.
+*/
+console.log(minMirrorPairDistance(nums));

javascript/LeetCode/String/3794.js

@@ -7,7 +7,26 @@
  * @return {string}
  */
 var reversePrefix = function(s, k) {
-  return s.substring(0,k).split("").reverse().join("") + s.substring(k);
+  // solution 1.
+  // return s.substring(0,k).split("").reverse().join("") + s.substring(k);
+
+  // solution 2.
+  // 2 pointers
+  let result = "";
+  let i = 0,j = k - 1; // left side and right side
+  let splitS = s.split("");
+  while(i < j){
+    let letter = splitS[i];
+    // swap
+    splitS[i] = splitS[j];
+    splitS[j] = letter;
+    i++;
+    j--;
+  }
+  for (let a = 0; a < splitS.length; a++) {
+    result += splitS[a];
+  }
+  return result;
 };
 // let s = "abcd", k = 2;
 // "bacd"