feat: add No.1700,1790

Author: BaffinLee

Diff for: 1601-1700/1700. Number of Students Unable to Eat Lunch.md

@@ -0,0 +1,99 @@
+# 1700. Number of Students Unable to Eat Lunch
+
+- Difficulty: Easy.
+- Related Topics: Array, Stack, Queue, Simulation.
+- Similar Questions: Time Needed to Buy Tickets.
+
+## Problem
+
+The school cafeteria offers circular and square sandwiches at lunch break, referred to by numbers `0` and `1` respectively. All students stand in a queue. Each student either prefers square or circular sandwiches.
+
+The number of sandwiches in the cafeteria is equal to the number of students. The sandwiches are placed in a **stack**. At each step:
+
+
+	
+- If the student at the front of the queue **prefers** the sandwich on the top of the stack, they will **take it** and leave the queue.
+	
+- Otherwise, they will **leave it** and go to the queue's end.
+
+
+This continues until none of the queue students want to take the top sandwich and are thus unable to eat.
+
+You are given two integer arrays `students` and `sandwiches` where `sandwiches[i]` is the type of the `i​​​​​​th` sandwich in the stack (`i = 0` is the top of the stack) and `students[j]` is the preference of the `j​​​​​​th` student in the initial queue (`j = 0` is the front of the queue). Return **the number of students that are unable to eat.**
+
+ 
+Example 1:
+
+```
+Input: students = [1,1,0,0], sandwiches = [0,1,0,1]
+Output: 0 
+Explanation:
+- Front student leaves the top sandwich and returns to the end of the line making students = [1,0,0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [0,0,1,1].
+- Front student takes the top sandwich and leaves the line making students = [0,1,1] and sandwiches = [1,0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [1,1,0].
+- Front student takes the top sandwich and leaves the line making students = [1,0] and sandwiches = [0,1].
+- Front student leaves the top sandwich and returns to the end of the line making students = [0,1].
+- Front student takes the top sandwich and leaves the line making students = [1] and sandwiches = [1].
+- Front student takes the top sandwich and leaves the line making students = [] and sandwiches = [].
+Hence all students are able to eat.
+```
+
+Example 2:
+
+```
+Input: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]
+Output: 3
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= students.length, sandwiches.length <= 100`
+	
+- `students.length == sandwiches.length`
+	
+- `sandwiches[i]` is `0` or `1`.
+	
+- `students[i]` is `0` or `1`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} students
+ * @param {number[]} sandwiches
+ * @return {number}
+ */
+var countStudents = function(students, sandwiches) {
+    var numOfOnes = 0;
+    var numOfZeros = 0;
+    for (var i = 0; i < students.length; i++) {
+        if (students[i] === 1) numOfOnes++;
+        else numOfZeros++;
+    }
+    for (var j = 0; j < sandwiches.length; j++) {
+        if (sandwiches[j] === 1) {
+            if (numOfOnes > 0) numOfOnes--;
+            else break;
+        } else {
+            if (numOfZeros > 0) numOfZeros--;
+            else break;
+        }
+    }
+    return numOfOnes + numOfZeros;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

Diff for: 1701-1800/1790. Check if One String Swap Can Make Strings Equal.md

@@ -0,0 +1,79 @@
+# 1790. Check if One String Swap Can Make Strings Equal
+
+- Difficulty: Easy.
+- Related Topics: Hash Table, String, Counting.
+- Similar Questions: Buddy Strings, Make Number of Distinct Characters Equal.
+
+## Problem
+
+You are given two strings `s1` and `s2` of equal length. A **string swap** is an operation where you choose two indices in a string (not necessarily different) and swap the characters at these indices.
+
+Return `true` **if it is possible to make both strings equal by performing **at most one string swap **on **exactly one** of the strings. **Otherwise, return `false`.
+
+ 
+Example 1:
+
+```
+Input: s1 = "bank", s2 = "kanb"
+Output: true
+Explanation: For example, swap the first character with the last character of s2 to make "bank".
+```
+
+Example 2:
+
+```
+Input: s1 = "attack", s2 = "defend"
+Output: false
+Explanation: It is impossible to make them equal with one string swap.
+```
+
+Example 3:
+
+```
+Input: s1 = "kelb", s2 = "kelb"
+Output: true
+Explanation: The two strings are already equal, so no string swap operation is required.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= s1.length, s2.length <= 100`
+	
+- `s1.length == s2.length`
+	
+- `s1` and `s2` consist of only lowercase English letters.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+var areAlmostEqual = function(s1, s2) {
+    var diffs = [];
+    for (var i = 0; i < s1.length; i++) {
+        if (s1[i] !== s2[i]) diffs.push(i);
+    }
+    return diffs.length === 0 || (
+        diffs.length === 2 &&
+            s1[diffs[0]] === s2[diffs[1]] &&
+            s1[diffs[1]] === s2[diffs[0]]
+    );
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).