Merge branch 'master' into master

problems/0027.移除元素.md

@@ -329,6 +329,22 @@ int removeElement(int* nums, int numsSize, int val){
 }
 ```
 
+Scala:
+```scala
+object Solution {
+  def removeElement(nums: Array[Int], `val`: Int): Int = {
+    var slow = 0
+    for (fast <- 0 until nums.length) {
+      if (`val` != nums(fast)) {
+        nums(slow) = nums(fast)
+        slow += 1
+      }
+    }
+    slow
+  }
+}
+```
+
 C#:
 ```csharp
 public class Solution {
@@ -343,6 +359,5 @@ public class Solution {
     }
 }
 ```
-
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0034.在排序数组中查找元素的第一个和最后一个位置.md

@@ -480,7 +480,52 @@ var searchRange = function(nums, target) {
     return [-1, -1];
 };
 ```
+### Scala
+```scala
+object Solution {
+  def searchRange(nums: Array[Int], target: Int): Array[Int] = {
+    var left = getLeftBorder(nums, target)
+    var right = getRightBorder(nums, target)
+    if (left == -2 || right == -2) return Array(-1, -1)
+    if (right - left > 1) return Array(left + 1, right - 1)
+    Array(-1, -1)
+  }
 
+  // 寻找左边界
+  def getLeftBorder(nums: Array[Int], target: Int): Int = {
+    var leftBorder = -2
+    var left = 0
+    var right = nums.length - 1
+    while (left <= right) {
+      var mid = left + (right - left) / 2
+      if (nums(mid) >= target) {
+        right = mid - 1
+        leftBorder = right
+      } else {
+        left = mid + 1
+      }
+    }
+    leftBorder
+  }
+
+  // 寻找右边界
+  def getRightBorder(nums: Array[Int], target: Int): Int = {
+    var rightBorder = -2
+    var left = 0
+    var right = nums.length - 1
+    while (left <= right) {
+      var mid = left + (right - left) / 2
+      if (nums(mid) <= target) {
+        left = mid + 1
+        rightBorder = left
+      } else {
+        right = mid - 1
+      }
+    }
+    rightBorder
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0035.搜索插入位置.md

@@ -316,7 +316,26 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
     return right + 1
 }
 ```
-
+### Scala
+```scala
+object Solution {
+  def searchInsert(nums: Array[Int], target: Int): Int = {
+    var left = 0
+    var right = nums.length - 1
+    while (left <= right) {
+      var mid = left + (right - left) / 2
+      if (target == nums(mid)) {
+        return mid
+      } else if (target > nums(mid)) {
+        left = mid + 1
+      } else {
+        right = mid - 1
+      }
+    }
+    right + 1
+  }
+}
+```
 
 ### PHP 
 

problems/0059.螺旋矩阵II.md

@@ -130,57 +130,37 @@ Java：
 ```Java
 class Solution {
     public int[][] generateMatrix(int n) {
+        int loop = 0;  // 控制循环次数
         int[][] res = new int[n][n];
+        int start = 0;  // 每次循环的开始点(start, start)
+        int count = 1;  // 定义填充数字
+        int i, j;
 
-        // 循环次数
-        int loop = n / 2;
-
-        // 定义每次循环起始位置
-        int startX = 0;
-        int startY = 0;
-
-        // 定义偏移量
-        int offset = 1;
-
-        // 定义填充数字
-        int count = 1;
-
-        // 定义中间位置
-        int mid = n / 2;
-        while (loop > 0) {
-            int i = startX;
-            int j = startY;
-
+        while (loop++ < n / 2) { // 判断边界后，loop从1开始
             // 模拟上侧从左到右
-            for (; j<startY + n -offset; ++j) {
-                res[startX][j] = count++;
+            for (j = start; j < n - loop; j++) {
+                res[start][j] = count++;
             }
 
             // 模拟右侧从上到下
-            for (; i<startX + n -offset; ++i) {
+            for (i = start; i < n - loop; i++) {
                 res[i][j] = count++;
             }
 
             // 模拟下侧从右到左
-            for (; j > startY; j--) {
+            for (; j >= loop; j--) {
                 res[i][j] = count++;
             }
 
             // 模拟左侧从下到上
-            for (; i > startX; i--) {
+            for (; i >= loop; i--) {
                 res[i][j] = count++;
             }
-
-            loop--;
-
-            startX += 1;
-            startY += 1;
-
-            offset += 2;
+            start++;
         }
 
         if (n % 2 == 1) {
-            res[mid][mid] = count;
+            res[start][start] = count;
         }
 
         return res;

problems/0150.逆波兰表达式求值.md

@@ -136,19 +136,19 @@ java:
 class Solution {
     public int evalRPN(String[] tokens) {
         Deque<Integer> stack = new LinkedList();
-        for (int i = 0; i < tokens.length; ++i) {
-            if ("+".equals(tokens[i])) {        // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
+        for (String s : tokens) {
+            if ("+".equals(s)) {        // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
                 stack.push(stack.pop() + stack.pop());      // 注意 - 和/ 需要特殊处理
-            } else if ("-".equals(tokens[i])) {
+            } else if ("-".equals(s)) {
                 stack.push(-stack.pop() + stack.pop());
-            } else if ("*".equals(tokens[i])) {
+            } else if ("*".equals(s)) {
                 stack.push(stack.pop() * stack.pop());
-            } else if ("/".equals(tokens[i])) {
+            } else if ("/".equals(s)) {
                 int temp1 = stack.pop();
                 int temp2 = stack.pop();
                 stack.push(temp2 / temp1);
             } else {
-                stack.push(Integer.valueOf(tokens[i]));
+                stack.push(Integer.valueOf(s));
             }
         }
         return stack.pop();

problems/0188.买卖股票的最佳时机IV.md

@@ -409,5 +409,27 @@ var maxProfit = function(k, prices) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function maxProfit(k: number, prices: number[]): number {
+    const length: number = prices.length;
+    if (length === 0) return 0;
+    const dp: number[][] = new Array(length).fill(0)
+        .map(_ => new Array(k * 2 + 1).fill(0));
+    for (let i = 1; i <= k; i++) {
+        dp[0][i * 2 - 1] = -prices[0];
+    }
+    for (let i = 1; i < length; i++) {
+        for (let j = 1; j < 2 * k + 1; j++) {
+            dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] + Math.pow(-1, j) * prices[i]);
+        }
+    }
+    return dp[length - 1][2 * k];
+};
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0202.快乐数.md

@@ -386,6 +386,39 @@ bool isHappy(int n){
 }
 ```
 
+Scala:
+```scala
+object Solution {
+  // 引入mutable
+  import scala.collection.mutable
+  def isHappy(n: Int): Boolean = {
+    // 存放每次计算后的结果
+    val set: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+    var tmp = n // 因为形参是不可变量，所以需要找到一个临时变量
+    // 开始进入循环
+    while (true) {
+      val sum = getSum(tmp) // 获取这个数每个值的平方和
+      if (sum == 1) return true // 如果最终等于 1，则返回true
+      // 如果set里面已经有这个值了，说明进入无限循环，可以返回false，否则添加这个值到set
+      if (set.contains(sum)) return false
+      else set.add(sum)
+      tmp = sum
+    }
+    // 最终需要返回值，直接返回个false
+    false
+  }
+
+  def getSum(n: Int): Int = {
+    var sum = 0
+    var tmp = n
+    while (tmp != 0) {
+      sum += (tmp % 10) * (tmp % 10)
+      tmp = tmp / 10
+    }
+    sum
+  }
+
+
 C#：
 ```csharp
 public class Solution {

problems/0309.最佳买卖股票时机含冷冻期.md

@@ -325,6 +325,66 @@ const maxProfit = (prices) => {
 };
 ```
 
+TypeScript：
+
+> 版本一，与本文思路一致
+
+```typescript
+function maxProfit(prices: number[]): number {
+    /**
+        dp[i][0]: 持股状态；
+        dp[i][1]: 无股状态，当天为非冷冻期；
+        dp[i][2]: 无股状态，当天卖出；
+        dp[i][3]: 无股状态，当天为冷冻期；
+     */
+    const length: number = prices.length;
+    const dp: number[][] = new Array(length).fill(0).map(_ => []);
+    dp[0][0] = -prices[0];
+    dp[0][1] = dp[0][2] = dp[0][3] = 0;
+    for (let i = 1; i < length; i++) {
+        dp[i][0] = Math.max(
+            dp[i - 1][0],
+            Math.max(dp[i - 1][1], dp[i - 1][3]) - prices[i]
+        );
+        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][3]);
+        dp[i][2] = dp[i - 1][0] + prices[i];
+        dp[i][3] = dp[i - 1][2];
+    }
+    const lastEl: number[] = dp[length - 1];
+    return Math.max(lastEl[1], lastEl[2], lastEl[3]);
+};
+```
+
+> 版本二，状态定义略有不同，可以帮助理解
+
+```typescript
+function maxProfit(prices: number[]): number {
+    /**
+        dp[i][0]: 持股状态，当天买入；
+        dp[i][1]: 持股状态，当天未买入；
+        dp[i][2]: 无股状态，当天卖出；
+        dp[i][3]: 无股状态，当天未卖出；
+        
+        买入有冷冻期限制，其实就是状态[0]只能由前一天的状态[3]得到；
+        如果卖出有冷冻期限制，其实就是[2]由[1]得到。
+     */
+    const length: number = prices.length;
+    const dp: number[][] = new Array(length).fill(0).map(_ => []);
+    dp[0][0] = -prices[0];
+    dp[0][1] = -Infinity;
+    dp[0][2] = dp[0][3] = 0;
+    for (let i = 1; i < length; i++) {
+        dp[i][0] = dp[i - 1][3] - prices[i];
+        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0]);
+        dp[i][2] = Math.max(dp[i - 1][0], dp[i - 1][1]) + prices[i];
+        dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2]);
+    }
+    return Math.max(dp[length - 1][2], dp[length - 1][3]);
+};
+```
+
+
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0349.两个数组的交集.md

@@ -313,6 +313,50 @@ int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* re
 }
 ```
 
+Scala:
+
+正常解法:
+```scala
+object Solution {
+  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+    // 导入mutable
+    import scala.collection.mutable
+    // 临时Set，用于记录数组1出现的每个元素
+    val tmpSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+    // 结果Set，存储最终结果
+    val resSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+    // 遍历nums1，把每个元素添加到tmpSet
+    nums1.foreach(tmpSet.add(_))
+    // 遍历nums2，如果在tmpSet存在就添加到resSet
+    nums2.foreach(elem => {
+      if (tmpSet.contains(elem)) {
+        resSet.add(elem)
+      }
+    })
+    // 将结果转换为Array返回，return可以省略
+    resSet.toArray
+  }
+}
+```
+骚操作1:
+```scala
+object Solution {
+  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+    // 先转为Set，然后取交集，最后转换为Array
+    (nums1.toSet).intersect(nums2.toSet).toArray
+  }
+}
+```
+骚操作2:
+```scala
+object Solution {
+  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+    // distinct去重，然后取交集
+    (nums1.distinct).intersect(nums2.distinct)
+  }
+}
+
+
 C#:
 ```csharp
  public int[] Intersection(int[] nums1, int[] nums2) {
@@ -330,6 +374,7 @@ C#:
     	}
         return one;
 	}
+
 ```
 ## 相关题目
 

problems/0704.二分查找.md

@@ -610,7 +610,48 @@ public class Solution{
     }
 }
 ```
+**Scala:**
 
+（版本一）左闭右闭区间
+```scala
+object Solution {
+  def search(nums: Array[Int], target: Int): Int = {
+    var left = 0
+    var right = nums.length - 1
+    while (left <= right) {
+      var mid = left + ((right - left) / 2)
+      if (target == nums(mid)) {
+        return mid
+      } else if (target < nums(mid)) {
+        right = mid - 1
+      } else {
+        left = mid + 1
+      }
+    }
+    -1
+  }
+}
+```
+（版本二）左闭右开区间
+```scala
+object Solution {
+  def search(nums: Array[Int], target: Int): Int = {
+    var left = 0
+    var right = nums.length
+    while (left < right) {
+      val mid = left + (right - left) / 2
+      if (target == nums(mid)) {
+        return mid
+      } else if (target < nums(mid)) {
+        right = mid
+      } else {
+        left = mid + 1
+      }
+    }
+    -1
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/1002.查找常用字符.md

@@ -418,6 +418,38 @@ char ** commonChars(char ** words, int wordsSize, int* returnSize){
     return ret;
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  def commonChars(words: Array[String]): List[String] = {
+    // 声明返回结果的不可变List集合，因为res要重新赋值，所以声明为var
+    var res = List[String]()
+    var hash = new Array[Int](26) // 统计字符出现的最小频率
+    // 统计第一个字符串中字符出现的次数
+    for (i <- 0 until words(0).length) {
+      hash(words(0)(i) - 'a') += 1
+    }
+    // 统计其他字符串出现的频率
+    for (i <- 1 until words.length) {
+      // 统计其他字符出现的频率
+      var hashOtherStr = new Array[Int](26)
+      for (j <- 0 until words(i).length) {
+        hashOtherStr(words(i)(j) - 'a') += 1
+      }
+      // 更新hash，取26个字母最小出现的频率
+      for (k <- 0 until 26) {
+        hash(k) = math.min(hash(k), hashOtherStr(k))
+      }
+    }
+    // 根据hash的结果转换输出的形式
+    for (i <- 0 until 26) {
+      for (j <- 0 until hash(i)) {
+        res = res :+ (i + 'a').toChar.toString
+      }
+    }
+    res
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>