Merge pull request #782 from openset/develop

A: v1.6.0

Author: Shuo

Diff for: internal/leetcode/topic_tag.go

@@ -38,11 +38,13 @@ func (tag *TagType) SaveContents() {
 	buf.WriteString("| # | 题目 | 标签 | 难度 |\n")
 	buf.WriteString("| :-: | - | - | :-: |\n")
 	format := "| %d | [%s](../../problems/%s)%s | %s | %s |\n"
+	preID := 0
 	for _, question := range questions {
 		if question.TranslatedTitle == "" {
 			question.TranslatedTitle = question.Title
 		}
-		if question.frontendID() > 0 {
+		if question.frontendID() > 0 && question.frontendID() != preID {
+			preID = question.frontendID()
 			buf.WriteString(fmt.Sprintf(format, question.frontendID(), question.TranslatedTitle, question.TitleSlug, question.IsPaidOnly.Str(), question.TagsStr(), question.Difficulty))
 		}
 	}

Diff for: internal/version/version.go

@@ -8,7 +8,7 @@ import (
 	"github.com/openset/leetcode/internal/base"
 )
 
-const version = "1.5.3"
+const version = "1.6.0"
 
 // CmdVersion - version.CmdVersion
 var CmdVersion = &base.Command{

Diff for: problems/backspace-string-compare/README.md

@@ -13,6 +13,8 @@
 
 <p>Given two&nbsp;strings&nbsp;<code>S</code>&nbsp;and <code>T</code>,&nbsp;return if they are equal when both are typed into empty text editors. <code>#</code> means a backspace character.</p>
 
+<p>Note that after&nbsp;backspacing an empty text, the text will continue empty.</p>
+
 <div>
 <p><strong>Example 1:</strong></p>
 
@@ -51,11 +53,11 @@
 
 <p><span><strong>Note</strong>:</span></p>
 
-<ol>
+<ul>
 	<li><code><span>1 &lt;= S.length &lt;= 200</span></code></li>
 	<li><code><span>1 &lt;= T.length &lt;= 200</span></code></li>
 	<li><span><code>S</code>&nbsp;and <code>T</code> only contain&nbsp;lowercase letters and <code>&#39;#&#39;</code> characters.</span></li>
-</ol>
+</ul>
 
 <p><strong>Follow up:</strong></p>
 

Diff for: problems/capital-gainloss/README.md

@@ -11,4 +11,56 @@
 
 ## [1393. Capital Gain/Loss (Medium)](https://leetcode.com/problems/capital-gainloss "股票的资本损益")
 
+<p>Table: <code>Stocks</code></p>
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| stock_name    | varchar |
+| operation     | enum    |
+| operation_day | int     |
+| price         | int     |
++---------------+---------+
+(stock_name, day) is the primary key for this table.
+The operation column is an ENUM of type ('Sell', 'Buy')
+Each row of this table indicates that the stock which has stock_name had an operation on the day operation_day with the price.
+It is guaranteed that each 'Sell' operation for a stock has a corresponding 'Buy' operation in a previous day.
+</pre>
+ 
+Write an SQL query to report the Capital gain/loss for each stock.
 
+The capital gain/loss of a stock is total gain or loss after buying and selling the stock one or many times.
+
+Return the result table in any order.
+
+The query result format is in the following example:
+
+<pre>
+Stocks table:
++---------------+-----------+---------------+--------+
+| stock_name    | operation | operation_day | price  |
++---------------+-----------+---------------+--------+
+| Leetcode      | Buy       | 1             | 1000   |
+| Corona Masks  | Buy       | 2             | 10     |
+| Leetcode      | Sell      | 5             | 9000   |
+| Handbags      | Buy       | 17            | 30000  |
+| Corona Masks  | Sell      | 3             | 1010   |
+| Corona Masks  | Buy       | 4             | 1000   |
+| Corona Masks  | Sell      | 5             | 500    |
+| Corona Masks  | Buy       | 6             | 1000   |
+| Handbags      | Sell      | 29            | 7000   |
+| Corona Masks  | Sell      | 10            | 10000  |
++---------------+-----------+---------------+--------+
+
+Result table:
++---------------+-------------------+
+| stock_name    | capital_gain_loss |
++---------------+-------------------+
+| Corona Masks  | 9500              |
+| Leetcode      | 8000              |
+| Handbags      | -23000            |
++---------------+-------------------+
+Leetcode stock was bought at day 1 for 1000$ and was sold at day 5 for 9000$. Capital gain = 9000 - 1000 = 8000$.
+Handbags stock was bought at day 17 for 30000$ and was sold at day 29 for 7000$. Capital loss = 7000 - 30000 = -23000$.
+Corona Masks stock was bought at day 1 for 10$ and was sold at day 3 for 1010$. It was bought again at day 4 for 1000$ and was sold at day 5 for 500$. At last, it was bought at day 6 for 1000$ and was sold at day 10 for 10000$. Capital gain/loss is the sum of capital gains/losses for each ('Buy' --> 'Sell') operation = (1010 - 10) + (500 - 1000) + (10000 - 1000) = 1000 - 500 + 9000 = 9500$.
+</pre>

Diff for: problems/customers-who-bought-products-a-and-b-but-not-c/README.md

@@ -11,4 +11,68 @@
 
 ## [1398. Customers Who Bought Products A and B but Not C (Medium)](https://leetcode.com/problems/customers-who-bought-products-a-and-b-but-not-c "购买了产品A和产品B却没有购买产品C的顾客")
 
+<p>Table: <code>Customers</code></p>
+<pre>
++---------------------+---------+
+| Column Name         | Type    |
++---------------------+---------+
+| customer_id         | int     |
+| customer_name       | varchar |
++---------------------+---------+
+customer_id is the primary key for this table.
+customer_name is the name of the customer.
+</pre>
+ 
+<p>Table: <code>Orders</code></p>
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| order_id      | int     |
+| customer_id   | int     |
+| product_name  | varchar |
++---------------+---------+
+order_id is the primary key for this table.
+customer_id is the id of the customer who bought the product "product_name".
+</pre>
+ 
+Write an SQL query to report the customer_id and customer_name of customers who bought products "A", "B" but did not buy the product "C" since we want to recommend them buy this product.
 
+Return the result table ordered by customer_id.
+
+The query result format is in the following example.
+
+<pre>
+Customers table:
++-------------+---------------+
+| customer_id | customer_name |
++-------------+---------------+
+| 1           | Daniel        |
+| 2           | Diana         |
+| 3           | Elizabeth     |
+| 4           | Jhon          |
++-------------+---------------+
+
+Orders table:
++------------+--------------+---------------+
+| order_id   | customer_id  | product_name  |
++------------+--------------+---------------+
+| 10         |     1        |     A         |
+| 20         |     1        |     B         |
+| 30         |     1        |     D         |
+| 40         |     1        |     C         |
+| 50         |     2        |     A         |
+| 60         |     3        |     A         |
+| 70         |     3        |     B         |
+| 80         |     3        |     D         |
+| 90         |     4        |     C         |
++------------+--------------+---------------+
+
+Result table:
++-------------+---------------+
+| customer_id | customer_name |
++-------------+---------------+
+| 3           | Elizabeth     |
++-------------+---------------+
+Only the customer_id with id 3 bought the product A and B but not the product C.
+</pre>

Diff for: problems/delete-columns-to-make-sorted/README.md

@@ -15,54 +15,46 @@
 
 <p>Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.</p>
 
-<p>For example, if we have an array <code>A = [&quot;</code><code>abcdef</code><code>&quot;,&quot;uvwxyz&quot;]</code> and deletion indices <code>{0, 2, 3}</code>, then the final array after deletions is <code>[&quot;bef&quot;, &quot;vyz&quot;]</code>,&nbsp;and the remaining columns of <code>A</code> are&nbsp;<code>[&quot;b&quot;</code><code>,&quot;</code><code>v&quot;]</code>, <code>[&quot;e&quot;,&quot;y&quot;]</code>, and <code>[&quot;f&quot;,&quot;z&quot;]</code>.&nbsp; (Formally, the <code>c</code>-th column is <code>[A[0][c], A[1][c], ..., A[A.length-1][c]]</code>.)</p>
+<p>For example, if we have an array <code>A = [&quot;abcdef&quot;,&quot;uvwxyz&quot;]</code> and deletion indices <code>{0, 2, 3}</code>, then the final array after deletions is <code>[&quot;bef&quot;, &quot;vyz&quot;]</code>,&nbsp;and the remaining columns of <code>A</code> are&nbsp;<code>[&quot;b&quot;,&quot;v&quot;]</code>, <code>[&quot;e&quot;,&quot;y&quot;]</code>, and <code>[&quot;f&quot;,&quot;z&quot;]</code>.&nbsp; (Formally, the <code>c</code>-th column is <code>[A[0][c], A[1][c], ..., A[A.length-1][c]]</code>).</p>
 
 <p>Suppose we chose a set of deletion indices <code>D</code> such that after deletions, each remaining column in A is in <strong>non-decreasing</strong> sorted order.</p>
 
 <p>Return the minimum possible value of <code>D.length</code>.</p>
 
 <p>&nbsp;</p>
-
-<div>
 <p><strong>Example 1:</strong></p>
 
 <pre>
-<strong>Input: </strong><span id="example-input-1-1">[&quot;cba&quot;,&quot;daf&quot;,&quot;ghi&quot;]</span>
-<strong>Output: </strong><span id="example-output-1">1</span>
+<strong>Input:</strong> A = [&quot;cba&quot;,&quot;daf&quot;,&quot;ghi&quot;]
+<strong>Output:</strong> 1
 <strong>Explanation: </strong>
 After choosing D = {1}, each column [&quot;c&quot;,&quot;d&quot;,&quot;g&quot;] and [&quot;a&quot;,&quot;f&quot;,&quot;i&quot;] are in non-decreasing sorted order.
 If we chose D = {}, then a column [&quot;b&quot;,&quot;a&quot;,&quot;h&quot;] would not be in non-decreasing sorted order.
 </pre>
 
-<div>
 <p><strong>Example 2:</strong></p>
 
 <pre>
-<strong>Input: </strong><span id="example-input-2-1">[&quot;a&quot;,&quot;b&quot;]</span>
-<strong>Output: </strong><span id="example-output-2">0</span>
+<strong>Input:</strong> A = [&quot;a&quot;,&quot;b&quot;]
+<strong>Output:</strong> 0
 <strong>Explanation: </strong>D = {}
 </pre>
 
-<div>
 <p><strong>Example 3:</strong></p>
 
 <pre>
-<strong>Input: </strong><span id="example-input-3-1">[&quot;zyx&quot;,&quot;wvu&quot;,&quot;tsr&quot;]</span>
-<strong>Output: </strong><span id="example-output-3">3</span>
+<strong>Input:</strong> A = [&quot;zyx&quot;,&quot;wvu&quot;,&quot;tsr&quot;]
+<strong>Output:</strong> 3
 <strong>Explanation: </strong>D = {0, 1, 2}
 </pre>
 
 <p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
 
-<p><strong><span>Note:</span></strong></p>
-
-<ol>
+<ul>
 	<li><code>1 &lt;= A.length &lt;= 100</code></li>
 	<li><code>1 &lt;= A[i].length &lt;= 1000</code></li>
-</ol>
-</div>
-</div>
-</div>
+</ul>
 
 ### Related Topics
   [[Greedy](../../tag/greedy/README.md)]

Diff for: problems/distinct-subsequences/README.md

@@ -15,13 +15,14 @@
 
 <p>A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, <code>&quot;ACE&quot;</code> is a subsequence of <code>&quot;ABCDE&quot;</code> while <code>&quot;AEC&quot;</code> is not).</p>
 
+<p>It&#39;s guaranteed the answer fits on a 32-bit signed integer.</p>
+
 <p><strong>Example 1:</strong></p>
 
 <pre>
 <strong>Input: </strong>S = <code>&quot;rabbbit&quot;</code>, T = <code>&quot;rabbit&quot;
 <strong>Output:</strong>&nbsp;3
-</code><strong>Explanation:
-</strong>
+</code><strong>Explanation:</strong>
 As shown below, there are 3 ways you can generate &quot;rabbit&quot; from S.
 (The caret symbol ^ means the chosen letters)
 
@@ -38,8 +39,7 @@ As shown below, there are 3 ways you can generate &quot;rabbit&quot; from S.
 <pre>
 <strong>Input: </strong>S = <code>&quot;babgbag&quot;</code>, T = <code>&quot;bag&quot;
 <strong>Output:</strong>&nbsp;5
-</code><strong>Explanation:
-</strong>
+</code><strong>Explanation:</strong>
 As shown below, there are 5 ways you can generate &quot;bag&quot; from S.
 (The caret symbol ^ means the chosen letters)
 

Diff for: problems/get-the-second-most-recent-activity/README.md

@@ -11,4 +11,48 @@
 
 ## [1369. Get the Second Most Recent Activity (Hard)](https://leetcode.com/problems/get-the-second-most-recent-activity "获取最近第二次的活动")
 
+SQL Schema
+<p>Table: <code>UserActivity</code></p>
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| username      | varchar |
+| activity      | varchar |
+| startDate     | Date    |
+| endDate       | Date    |
++---------------+---------+
+This table does not contain primary key.
+This table contain information about the activity performed of each user in a period of time.
+A person with username performed a activity from startDate to endDate.
+</pre>
 
+Write an SQL query to show the second most recent activity of each user.
+
+If the user only has one activity, return that one. 
+
+A user can't perform more than one activity at the same time. Return the result table in any order.
+
+The query result format is in the following example:
+<pre>
+UserActivity table:
++------------+--------------+-------------+-------------+
+| username   | activity     | startDate   | endDate     |
++------------+--------------+-------------+-------------+
+| Alice      | Travel       | 2020-02-12  | 2020-02-20  |
+| Alice      | Dancing      | 2020-02-21  | 2020-02-23  |
+| Alice      | Travel       | 2020-02-24  | 2020-02-28  |
+| Bob        | Travel       | 2020-02-11  | 2020-02-18  |
++------------+--------------+-------------+-------------+
+
+Result table:
++------------+--------------+-------------+-------------+
+| username   | activity     | startDate   | endDate     |
++------------+--------------+-------------+-------------+
+| Alice      | Dancing      | 2020-02-21  | 2020-02-23  |
+| Bob        | Travel       | 2020-02-11  | 2020-02-18  |
++------------+--------------+-------------+-------------+
+
+The most recent activity of Alice is Travel from 2020-02-24 to 2020-02-28, before that she was dancing from 2020-02-21 to 2020-02-23.
+Bob only has one record, we just take that one.
+</pre>

Diff for: problems/longest-uncommon-subsequence-i/README.md

@@ -11,33 +11,45 @@
 
 ## [521. Longest Uncommon Subsequence I  (Easy)](https://leetcode.com/problems/longest-uncommon-subsequence-i "最长特殊序列 Ⅰ")
 
-<p>
-Given a group of two strings, you need to find the longest uncommon subsequence of this group of two strings.
-The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be <b>any</b> subsequence of the other strings.
-</p>
+<p>Given two strings, you need to find the longest uncommon subsequence&nbsp;of this two strings. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be <b>any</b> subsequence of the other string.</p>
 
-<p>
-A <b>subsequence</b> is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.
-</p>
+<p>A <b>subsequence</b> is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.</p>
 
-<p>
-The input will be two strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.
-</p>
+<p>The input will be two strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn&#39;t exist, return -1.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> a = &quot;aba&quot;, b = &quot;cdc&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest uncommon subsequence is &quot;aba&quot;, 
+because &quot;aba&quot; is a subsequence of &quot;aba&quot;, 
+but not a subsequence of the other string &quot;cdc&quot;.
+Note that &quot;cdc&quot; can be also a longest uncommon subsequence.
+</pre>
+
+<p><strong>Example 2:</strong></p>
 
-<p><b>Example 1:</b><br />
 <pre>
-<b>Input:</b> "aba", "cdc"
-<b>Output:</b> 3
-<b>Explanation:</b> The longest uncommon subsequence is "aba" (or "cdc"), <br/>because "aba" is a subsequence of "aba", <br/>but not a subsequence of any other strings in the group of two strings. 
+<strong>Input:</strong> a = &quot;aaa&quot;, b = &quot;bbb&quot;
+<strong>Output:</strong> 3
 </pre>
-</p>
-
-<p><b>Note:</b>
-<ol>
-<li>Both strings' lengths will not exceed 100.</li>
-<li>Only letters from a ~ z will appear in input strings. </li>
-</ol>
-</p>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> a = &quot;aaa&quot;, b = &quot;aaa&quot;
+<strong>Output:</strong> -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>Both strings&#39; lengths will be between <code>[1 - 100]</code>.</li>
+	<li>Only letters from a ~ z will appear in input strings.</li>
+</ul>
 
 ### Related Topics
   [[String](../../tag/string/README.md)]