Add: desc

internal/leetcode/question_data.go

@@ -236,7 +236,7 @@ func (question *questionType) Restore() {
 	if len(matches) >= 2 {
 		return
 	}
-	question.Content = string(matches[1])
+	question.Content = string(bytes.TrimSpace(matches[1]))
 	name := fmt.Sprintf(questionDataFile, question.TitleSnake())
 	filePutContents(getCachePath(name), jsonEncode(QuestionDataType{
 		Data: dataType{Question: *question},

problems/all-people-report-to-the-given-manager/README.md

@@ -11,4 +11,55 @@
 
 ## [1270. All People Report to the Given Manager (Medium)](https://leetcode.com/problems/all-people-report-to-the-given-manager "")
 
+<p>Table: <code>Employees</code></p>
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| employee_id   | int     |
+| employee_name | varchar |
+| manager_id    | int     |
++---------------+---------+
+employee_id is the primary key for this table.
+Each row of this table indicates that the employee with ID employee_id and name employee_name reports his work to his/her direct manager with manager_id
+The head of the company is the employee with employee_id = 1.
+</pre> 
 
+Write an SQL query to find employee_id of all employees that directly or indirectly report their work to the head of the company.
+
+The indirect relation between managers will not exceed 3 managers as the company is small.
+
+Return result table in any order without duplicates.
+
+The query result format is in the following example:
+<pre>
+Employees table:
++-------------+---------------+------------+
+| employee_id | employee_name | manager_id |
++-------------+---------------+------------+
+| 1           | Boss          | 1          |
+| 3           | Alice         | 3          |
+| 2           | Bob           | 1          |
+| 4           | Daniel        | 2          |
+| 7           | Luis          | 4          |
+| 8           | Jhon          | 3          |
+| 9           | Angela        | 8          |
+| 77          | Robert        | 1          |
++-------------+---------------+------------+
+
+Result table:
++-------------+
+| employee_id |
++-------------+
+| 2           |
+| 77          |
+| 4           |
+| 7           |
++-------------+
+
+The head of the company is the employee with employee_id 1.
+The employees with employee_id 2 and 77 report their work directly to the head of the company.
+The employee with employee_id 4 report his work indirectly to the head of the company 4 --> 2 --> 1. 
+The employee with employee_id 7 report his work indirectly to the head of the company 7 --> 4 --> 2 --> 1.
+The employees with employee_id 3, 8 and 9 don't report their work to head of company directly or indirectly. 
+</pre>

problems/page-recommendations/README.md

@@ -11,4 +11,76 @@
 
 ## [1264. Page Recommendations (Medium)](https://leetcode.com/problems/page-recommendations "")
 
+<p>Table: <code>Friendship</code></p>
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| user1_id      | int     |
+| user2_id      | int     |
++---------------+---------+
+(user1_id, user2_id) is the primary key for this table.
+Each row of this table indicates that there is a friendship relation between user1_id and user2_id.
+</pre>
+
+<p>Table: <code>Likes</code></p>
+<pre>
++-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| user_id     | int     |
+| page_id     | int     |
++-------------+---------+
+(user_id, page_id) is the primary key for this table.
+Each row of this table indicates that user_id likes page_id.
+</pre>
+
+Write an SQL query to recommend pages to the user with user_id = 1 using the pages that your friends liked. It should not recommend pages you already liked.
 
+Return result table in any order without duplicates.
+
+The query result format is in the following example:
+<pre>
+Friendship table:
++----------+----------+
+| user1_id | user2_id |
++----------+----------+
+| 1        | 2        |
+| 1        | 3        |
+| 1        | 4        |
+| 2        | 3        |
+| 2        | 4        |
+| 2        | 5        |
+| 6        | 1        |
++----------+----------+
+
+Likes table:
++---------+---------+
+| user_id | page_id |
++---------+---------+
+| 1       | 88      |
+| 2       | 23      |
+| 3       | 24      |
+| 4       | 56      |
+| 5       | 11      |
+| 6       | 33      |
+| 2       | 77      |
+| 3       | 77      |
+| 6       | 88      |
++---------+---------+
+
+Result table:
++------------------+
+| recommended_page |
++------------------+
+| 23               |
+| 24               |
+| 56               |
+| 33               |
+| 77               |
++------------------+
+User one is friend with users 2, 3, 4 and 6.
+Suggested pages are 23 from user 2, 24 from user 3, 56 from user 3 and 33 from user 6.
+Page 77 is suggested from both user 2 and user 3.
+Page 88 is not suggested because user 1 already likes it.
+</pre>

problems/print-immutable-linked-list-in-reverse/README.md

@@ -11,4 +11,41 @@
 
 ## [1265. Print Immutable Linked List in Reverse (Medium)](https://leetcode.com/problems/print-immutable-linked-list-in-reverse "")
 
+You are given an immutable linked list, print out all values of each node in reverse with the help of the following interface:
 
+- ImmutableListNode: An interface of immutable linked list, you are given the head of the list.
+You need to use the following functions to access the linked list (you can't access the ImmutableListNode directly):
+
+- ImmutableListNode.printValue(): Print value of the current node.
+- ImmutableListNode.getNext(): Return the next node.
+The input is only given to initialize the linked list internally. You must solve this problem without modifying the linked list. In other words, you must operate the linked list using only the mentioned APIs.
+
+Follow up:
+
+Could you solve this problem in:
+
+- Constant space complexity?
+- Linear time complexity and less than linear space complexity?
+
+<p><b>Example 1:</b></p>
+<pre>
+Input: head = [1,2,3,4]
+Output: [4,3,2,1]
+</pre>
+
+<p><b>Example 2:</b></p>
+<pre>
+Input: head = [0,-4,-1,3,-5]
+Output: [-5,3,-1,-4,0]
+</pre>
+
+<p><b>Example 3:</b></p>
+<pre>
+Input: head = [-2,0,6,4,4,-6]
+Output: [-6,4,4,6,0,-2]
+</pre>
+
+Constraints:
+
+- The length of the linked list is between [1, 1000].
+- The value of each node in the linked list is between [-1000, 1000].

problems/traffic-light-controlled-intersection/README.md

@@ -11,4 +11,63 @@ Next >
 
 ## [1279. Traffic Light Controlled Intersection (Easy)](https://leetcode.com/problems/traffic-light-controlled-intersection "")
 
+There is an intersection of two roads. First road is road A where cars travel from North to South in direction 1 and from South to North in direction 2. Second road is road B where cars travel from West to East in direction 3 and from East to West in direction 4.
 
+There is a traffic light located on each road before the intersection. A traffic light can either be green or red.
+
+1. Green means cars can cross the intersection in both directions of the road.
+- Red means cars in both directions cannot cross the intersection and must wait until the light turns green.
+
+The traffic lights cannot be green on both roads at the same time. That means when the light is green on road A, it is red on road B and when the light is green on road B, it is red on road A.
+
+Initially, the traffic light is green on road A and red on road B. When the light is green on one road, all cars can cross the intersection in both directions until the light becomes green on the other road. No two cars traveling on different roads should cross at the same time.
+
+Design a deadlock-free traffic light controlled system at this intersection.
+
+Implement the function void carArrived(carId, roadId, direction, turnGreen, crossCar) where:
+
+- carId is the id of the car that arrived.
+- roadId is the id of the road that the car travels on.
+- direction is the direction of the car.
+- turnGreen is a function you can call to turn the traffic light to green on the current road.
+- crossCar is a function you can call to let the current car cross the intersection.
+
+Your answer is considered correct if it avoids cars deadlock in the intersection. Turning the light green on a road when it was already green is considered a wrong answer.
+
+<p><b>Example 1:</b></p>
+<pre>
+Input: cars = [1,3,5,2,4], directions = [2,1,2,4,3], arrivalTimes = [10,20,30,40,50]
+Output: [
+"Car 1 Has Passed Road A In Direction 2",    // Traffic light on road A is green, car 1 can cross the intersection.
+"Car 3 Has Passed Road A In Direction 1",    // Car 3 crosses the intersection as the light is still green.
+"Car 5 Has Passed Road A In Direction 2",    // Car 5 crosses the intersection as the light is still green.
+"Traffic Light On Road B Is Green",          // Car 2 requests green light for road B.
+"Car 2 Has Passed Road B In Direction 4",    // Car 2 crosses as the light is green on road B now.
+"Car 4 Has Passed Road B In Direction 3"     // Car 4 crosses the intersection as the light is still green.
+]
+</pre>
+
+<p><b>Example 2:</b></p>
+<pre>
+Input: cars = [1,2,3,4,5], directions = [2,4,3,3,1], arrivalTimes = [10,20,30,40,40]
+Output: [
+"Car 1 Has Passed Road A In Direction 2",    // Traffic light on road A is green, car 1 can cross the intersection.
+"Traffic Light On Road B Is Green",          // Car 2 requests green light for road B.
+"Car 2 Has Passed Road B In Direction 4",    // Car 2 crosses as the light is green on road B now.
+"Car 3 Has Passed Road B In Direction 3",    // Car 3 crosses as the light is green on road B now.
+"Traffic Light On Road A Is Green",          // Car 5 requests green light for road A.
+"Car 5 Has Passed Road A In Direction 1",    // Car 5 crosses as the light is green on road A now.
+"Traffic Light On Road B Is Green",          // Car 4 requests green light for road B. Car 4 blocked until car 5 crosses and then traffic light is green on road B.
+"Car 4 Has Passed Road B In Direction 3"     // Car 4 crosses as the light is green on road B now.
+]
+Explanation: This is a dead-lock free scenario. Note that the scenario when car 4 crosses before turning light into green on road A and allowing car 5 to pass is also correct and Accepted scenario.
+</pre>
+
+Constraints:
+
+- 1 <= cars.length <= 20
+- cars.length = directions.length
+- cars.length = arrivalTimes.length
+- All values of cars are unique
+- 1 <= directions[i] <= 4
+- arrivalTimes is non-decreasing