Merge pull request #573 from openset/develop

Update: Hints

Author: Shuo

internal/leetcode/question_data.go

@@ -172,10 +172,10 @@ func (question questionType) getHints() []byte {
 	hints := question.Hints
 	var buf bytes.Buffer
 	if len(hints) > 0 {
-		buf.WriteString("\n### Hints\n")
+		buf.WriteString("\n### Hints")
 	}
 	for i, hint := range hints {
-		buf.WriteString(fmt.Sprintf("<details>\n<summary>Hint %d</summary>\n%s\n</details>\n", i+1, filterContents(hint)))
+		buf.WriteString(fmt.Sprintf("\n<details>\n<summary>Hint %d</summary>\n%s\n</details>\n", i+1, filterContents(hint)))
 	}
 	return buf.Bytes()
 }

problems/add-digits/README.md

@@ -36,14 +36,17 @@ Could you do it without any loop/recursion in O(1) runtime?</p>
 <summary>Hint 1</summary>
 A naive implementation of the above process is trivial. Could you come up with other methods?
 </details>
+
 <details>
 <summary>Hint 2</summary>
 What are all the possible results?
 </details>
+
 <details>
 <summary>Hint 3</summary>
 How do they occur, periodically or randomly?
 </details>
+
 <details>
 <summary>Hint 4</summary>
 You may find this <a href="https://en.wikipedia.org/wiki/Digital_root" target="_blank">Wikipedia article</a> useful.

problems/array-partition-i/README.md

@@ -39,14 +39,17 @@ Given an array of <b>2n</b> integers, your task is to group these integers into
 <summary>Hint 1</summary>
 Obviously, brute force won't help here. Think of something else, take some example like 1,2,3,4.
 </details>
+
 <details>
 <summary>Hint 2</summary>
 How will you make pairs to get the result? There must be some pattern.
 </details>
+
 <details>
 <summary>Hint 3</summary>
 Did you observe that- Minimum element gets add into the result in sacrifice of maximum element.
 </details>
+
 <details>
 <summary>Hint 4</summary>
 Still won't able to find pairs? Sort the array and try to find the pattern.

problems/binary-tree-tilt/README.md

@@ -47,14 +47,17 @@ Tilt of binary tree : 0 + 0 + 1 = 1
 <summary>Hint 1</summary>
 Don't think too much, this is an easy problem. Take some small tree as an example.
 </details>
+
 <details>
 <summary>Hint 2</summary>
 Can a parent node use the values of its child nodes? How will you implement it?
 </details>
+
 <details>
 <summary>Hint 3</summary>
 May be recursion and tree traversal can help you in implementing.
 </details>
+
 <details>
 <summary>Hint 4</summary>
 What about postorder traversal, using values of left and right childs?

problems/binary-watch/README.md

@@ -43,6 +43,7 @@
 <summary>Hint 1</summary>
 Simplify by seeking for solutions that involve comparing bit counts.
 </details>
+
 <details>
 <summary>Hint 2</summary>
 Consider calculating all possible times for comparison purposes.

problems/camelcase-matching/README.md

@@ -66,10 +66,12 @@
 <summary>Hint 1</summary>
 Given a single pattern and word, how can we solve it?
 </details>
+
 <details>
 <summary>Hint 2</summary>
 One way to do it is using a DP (pos1, pos2) where pos1 is a pointer to the word and pos2 to the pattern and returns true if we can match the pattern with the given word.
 </details>
+
 <details>
 <summary>Hint 3</summary>
 We have two scenarios: The first one is when `word[pos1] == pattern[pos2]`, then the transition will be just DP(pos1 + 1, pos2 + 1). The second scenario is when `word[pos1]` is lowercase then we can add this character to the pattern so that the transition is just DP(pos1 + 1, pos2)

problems/closest-binary-search-tree-value-ii/README.md

@@ -29,14 +29,17 @@ Consider implement these two helper functions:
 <li><code>getSuccessor(N)</code>, which returns the next larger node to N.</li>
 </ol>
 </details>
+
 <details>
 <summary>Hint 2</summary>
 Try to assume that each node has a parent pointer, it makes the problem much easier.
 </details>
+
 <details>
 <summary>Hint 3</summary>
 Without parent pointer we just need to keep track of the path from the root to the current node using a stack.
 </details>
+
 <details>
 <summary>Hint 4</summary>
 You would need two stacks to track the path in finding predecessor and successor node separately.

problems/contains-duplicate-iii/README.md

@@ -53,6 +53,7 @@
 <summary>Hint 1</summary>
 Time complexity O(n logk)  - This will give an indication that sorting is involved for k elements.
 </details>
+
 <details>
 <summary>Hint 2</summary>
 Use already existing state to evaluate next state  -  Like, a set of k sorted numbers are only needed to be tracked. When we are processing the next number in array, then we can utilize the existing sorted state and it is not necessary to sort next overlapping set of k numbers again.

problems/copy-list-with-random-pointer/README.md

@@ -50,10 +50,12 @@ Node 2's value is 2, its next pointer points to null and its random pointer
 <summary>Hint 1</summary>
 Just iterate the linked list and create copies of the nodes on the go. Since a node can be referenced from multiple nodes due to the random pointers, make sure you are not making multiple copies of the same node.
 </details>
+
 <details>
 <summary>Hint 2</summary>
 You may want to use extra space to keep <b>old node ---> new node</b> mapping to prevent creating multiples copies of same node.
 </details>
+
 <details>
 <summary>Hint 3</summary>
 We can avoid using extra space for old node ---> new node mapping, by tweaking the original linked list. Simply interweave the nodes of the old and copied list. 
@@ -63,6 +65,7 @@ Old List: A --> B --> C --> D
 InterWeaved List: A --> A' --> B --> B' --> C --> C' --> D --> D'
 </pre>
 </details>
+
 <details>
 <summary>Hint 4</summary>
 The interweaving is done using <b>next</b> pointers and we can make use of interweaved structure to get the correct reference nodes for <b>random</b> pointers.

problems/count-and-say/README.md

@@ -68,6 +68,7 @@ The following are the terms from n=1 to n=10 of the count-and-say sequence:
 10.     13211311123113112211
 </pre>
 </details>
+
 <details>
 <summary>Hint 2</summary>
 To generate the <i>n</i><sup>th</sup> term, just <i>count and say</i> the <i>n</i>-1<sup>th</sup> term.