Permutations II Diagrams

https://ibb.co/n0js4B6

https://ibb.co/Sw0fgk5

Desirable Difficulty

UCLA professor Robert Bjork has argued that desirable difficulty is actually required for us to upskill and move to another level.

Consider two kinds of batting practice. In one, the pitches are chunked into categories—twenty-five fastballs, twenty-five curve balls—in a predictable rhythm. At the end of this practice, hitters reported feeling a sense of confidence and flow.

The alternative involves mixing up the pitches randomly. Here, the batters reported frustration and less satisfaction. But teacher Torre’ Mills points out that the random method, where desirable difficulty is at work, actually improves players’ skills more than the chunked approach.

Desirable difficulty is the hard work of doing hard work. Setting ourselves up for things that cause a struggle, because we know that after the struggle, we’ll be at a new level.

Learning almost always involves incompetence. Shortly before we get to the next level, we realize that we’re not yet at that level and we feel insufficient. The difficulty is real, and it’s desirable if our goal is to move forward.

When we intentionally avoid desirable difficulty, our practice suffers, because we’re only coasting.

The commitment, then, is to sign up for days, weeks, or years of serial incompetence and occasional frustration. To seek out desirable difficulty on our way to a place where our flow is actually productive in service of the change we seek to make.

Seth Godin. “The Practice.” 

Learning Environment

 Learn in a relaxed environment. The best recall occurs when brainwave patterns show a relaxed state.

Learn in a multi-sensory environment by involving visual, auditory and kinesthetic activities.

Use color! This stimulates the right brain and helps recall.

Make sure you take breaks every hour.

Try to relate what you are learning to a bigger picture.

Reinforce what you have learned through practice and review.

Remove whitespace from file names in Unix/Mac

 Go to the folder where the files are located and run:

for f in *; do mv "$f" `echo $f | tr ' ' '_'`; done

Upload File to S3

 require 'aws-sdk-s3'  # v2: require 'aws-sdk'

ACCESS_KEY_ID = ""

SECRET_ACCESS_KEY = ""

REGION_ID = "us-east-1"

BUCKET_NAME = "bucket-name"

def uploadS3

  credentials = Aws::Credentials.new(

                                     ACCESS_KEY_ID,

                                     SECRET_ACCESS_KEY

                                     )

  s3 = Aws::S3::Client.new(

                          region: REGION_ID,

                          credentials: credentials

                          )

                          

  #Upload export/file1.zip, export/file2.zip

  for file_name in ['file1.zip', 'file2.zip']

    name = File.join('export', file_name)

    # Upload

    File.open(name, 'rb') do |file|

      puts "start uploading #{file_name} to s3"

      resp = s3.put_object(bucket: BUCKET_NAME, acl: "public-read", key: file_name, body: file)

      puts resp

    end

    puts "File should be available at https://#{BUCKET_NAME}.s3.amazonaws.com/#{file_name}"

  end

end

Law of Success

1. Fall in love with the process.
2. Do it every single day.
3. Celebrate your commitment.
4. Track your metrics and data.
5. Master your craft.

Tommy Baker. “The 1% Rule: How to Fall in Love with the Process and Achieve Your Wildest Dreams.” 

Live Coding 175 Session Recordings Now Available

We have now over 175+ live coding recordings for Leetcode live coding sessions. That is over 200 hours of discussions on coding problems. We are a group of developers preparing for FANG interviews. We meet everyday and work collaboratively on solving one medium Leetcode problem via Zoom.

This is NOT a study group. We flip the classroom. You study whatever resources you find useful before the meeting. We only focus on PRACTICE and FEEDBACK during the Zoom calls. We share tips and the peer to peer learning has worked really well so far.

I started the daily live coding sessions on July 25th, 2020. I have learned in just two months as much as I have learned in one year when I was studying and practicing by myself. Members requested me to record the sessions so they can watch any sessions that they miss.

We don't rush into coding. We analyze the problem, create a model of the problem and use the model to answer questions. We then brainstorm alternate approaches to solve the problem starting with brute-force and eventually code the optimal solution by the end of the session.

This is not passive learning like watching videos. The paid courses ask you to pause the video and think. But no one teaches how to think and ask questions to solve problem from scratch. We code the solution to problems from scratch.

Our group hates memorizing and we focus on gaining deep understanding of the concepts. Join Leetcode Live Coding Telegram group: https://t.me/joinchat/VOy5LhxpFvgV4aJKeMBIRg

You will also get access to the Zoom cloud recordings. You will develop insights on how to approach coding problems and you don't have to memorize anything. You will learn how visualizing the key aspects of well known algorithms can make it easier to understand the algorithms at a deeper level. 

Topic Wise or Random Practice ?

 Topic wise practice if fine when you are learning the basics of data structures and algorithms. You basically can be operating in either Learning Mode or Practice Mode. When you are in learning mode, it's ok to practice by topic otherwise you should not be practicing by topic. Because, you have to develop the ability to recognize what data structure and algorithm to use just like a real interview.

Leetcode Live Coding Thread Discussion Link

 https://leetcode.com/discuss/general-discussion/1002477/Leetcode-Live-Coding

Optimal Algorithm for a Problem

 “The ultimate goal in designing algorithms and data structures is to find an optimal algorithm for a problem, that is, an algorithm whose worst-case runtime complexity matches the intrinsic complexity of the problem it solves.”

Martin Erwig. “Once Upon an Algorithm: How Stories Explain Computing.” 

Problem Simplification

 “Problem simplification is often a crucial step toward solving a problem.”

Martin Erwig. “Once Upon an Algorithm: How Stories Explain Computing.” 

Relationship Between the Complexity of the Problem and Solution

 The distinction between the complexity of a problem and the complexity of its solutions helps us understand the notion of an optimal solution.

 Martin Erwig. “Once Upon an Algorithm: How Stories Explain Computing.” 

Precomputing

 In this case, even if the sorting takes linearithmic time, it is worth the effort, since it saves precious class time. This is an example of precomputing, where some data needed for an algorithm is computed before the algorithm is executed.

“This strategy of computing information ahead of time is called precomputation.”

“The crucial aspect of precomputation is that computational effort is expended at one time and the computed result is used at a later time. The precomputed result is preserved in a data structure”

“Situations in which one can expect to make use of a data structure repeatedly provide a strong incentive to expend the precomputing effort because the cost can be amortized over several uses.”

“ There are many situations, however, when it’s not clear whether the precomputation effort will pay off.”

“In cases like these, the value of acting early, or precomputing, is called into question by uncertainty about the future. Since the benefit of precomputation depends on a specific outcome of future events, it reflects a rather optimistic computation attitude with a confident outlook on the future.”

“A skeptical attitude toward the future calls for a radically different strategy for scheduling computation, namely, a strategy that tries to delay costly operations as much as possible until they cannot be avoided anymore. The hope or expectation is that something might happen that makes the costly operation obsolete and thus saves its runtime (and potentially other resources). In real life this behavior would be called procrastination; in computer science it is called lazy evaluation. ”

“Lazy evaluation can save computation effort whenever the information that would have been obtained by the saved computation is not needed anymore.”

“While lazy evaluation seems attractive in its promise to not waste effort, it is problematic when an action that becomes unavoidable takes longer than it would have under precomputing, or worse, longer than there is time available. In particular, when several delayed actions become due at the same time, this might present a serious resource problem. Therefore, an overall more sensible strategy is to distribute work evenly over time. While this might waste some effort on precomputing, it avoids crises that a lazy evaluation strategy might bring on.”

Martin Erwig. “Once Upon an Algorithm: How Stories Explain Computing.” 

Problem Sequence

 

1. Contains Duplicate

2. Missing Number

3. Find All Numbers Disappeared in an Array

4. Single Number

5. Climbing Stairs

6. House Robber

7. Best Time to Buy and Sell Stock

8. Maximum Subarray

9. Range Sum Query - Immutable

10. Linked List Cycle

11. Middle of the Linked List

12. Palindrome Linked List

13. Remove Linked List Elements

14. Remove Duplicates from Sorted List

15. Reverse Linked List

16. Merge Two Sorted Lists

17. Meeting Rooms

18. Binary Search

19. Find Smallest Letter Greater Than Target

20. Peak Index in a Mountain Array

21. Binary Tree Level Order Traversal II

22. Average of Levels in Binary Tree

23. Minimum Depth of Binary Tree

24. Same Tree

25. Path Sum

26. Diameter of Binary Tree

27. Merge Two Binary Trees

28. Maximum Depth of Binary Tree

29. Lowest Common Ancestor of a Binary Search Tree

30. Subtree of Another Tree

31. Invert Binary Tree

32. Two Sum

33. Squares of a Sorted Array

34. Backspace String Compare

35. Longest Word in Dictionary

36. Index Pairs of a String

37. Majority Element

38. Product of Array Except Self

39. Find the Duplicate Number

40. Find All Duplicates in an Array

41. Set Matrix Zeroes

42. Spiral Matrix

43. Rotate Image

44. Word Search

45. Letter Case Permutation 46. Subsets
47. Subsets II
48. Permutations

49. Permutations II
50. Combinations
51. Combination Sum
52. Combination Sum II 53. Combination Sum III 54. Generate Parentheses 55. Target Sum

56. Palindrome Partitioning
57. Letter Combinations of a Phone Number
58. Generalized Abbreviation
59. House Robber II
60. Coin Change
61. Maximum Product Subarray
62. Longest Increasing Subsequence
63. Longest Palindromic Substring
64. Word Break
65. Combination Sum IV
66. Decode Ways
67. Unique Paths
68. Jump Game
69. Palindromic Substrings
70. Number of Longest Increasing Subsequence
71. Partition Equal Subset Sum
72. Partition to K Equal Sum Subsets
73. Best Time to Buy and Sell Stock with Cooldown
74. Counting Bits
75. Linked List Cycle II
76. Add Two Numbers
77. Remove Nth Node From End Of List
78. Sort List
79. Reorder List
80. Clone Graph
81. Pacific Atlantic Water Flow
82. Number of Islands
83. Graph Valid Tree
84. Number of Connected Components in an Undirected Graph 85. Reverse Linked List II
86. Rotate List
87. Swap Nodes in Pairs
88. Odd Even Linked List

89. Kth Smallest Element in a Sorted Matrix 90. Find K Pairs with Smallest Sums
91. Merge Intervals
92. Interval List Intersections

93. Non-overlapping Intervals
94. Meeting Rooms II
95. Task Scheduler
96. Minimum Number of Arrows to Burst Balloons 97. Find Minimum in Rotated Sorted Array

98. Find Peak Element
99. Search in Rotated Sorted Array

100. Search in Rotated Sorted Array II

101. Search a 2D Matrix

102. Search a 2D Matrix II

103. Find K Closest Elements

104. Minimum Size Subarray Sum

105. Fruit Into Baskets

106. Permutation in String

107. Longest Repeating Character Replacement

108. Kth Smallest Element in a BST

109. K Closest Points to Origin

110. Top K Frequent Elements

111. Sort Characters By Frequency

112. Kth Largest Element in an Array

113. Reorganize String

114. Course Schedule

115. Course Schedule II

116. Minimum Height Trees

117. Binary Tree Level Order Traversal

118. Binary Tree Zigzag Level Order Traversal

119. Populating Next Right Pointers in Each Node

120. Populating Next Right Pointers in Each Node II

121. Binary Tree Right Side View

122. All Nodes Distance K in Binary Tree

123. Path Sum II

124. Path Sum III

125. Lowest Common Ancestor of a Binary Tree

126. Maximum Binary Tree

127. Maximum Width of Binary Tree

128. Construct Binary Tree from Preorder and Inorder Traversal

129. Validate Binary Search Tree

130. Implement Trie (Prefix Tree)

131. 3 Sum

132. 3 Sum Closest

133. Subarrays with Product Less than K

134. Sort Colours

135. Maximum XOR of Two Numbers in an Array

136. First Missing Positive

137. Longest Consecutive Sequence

138. Sudoku Solver

139. N-Queens

140. Reverse Nodes in k-Group

141. Merge k Sorted Lists

142. Smallest Range Covering Elements from K Lists

143. Insert Interval

144. Employee Free Time

145. Count of Range Sum

146. Sliding Window Maximum

147. Longest Substring Without Repeating Characters

148. Minimum Number of K Consecutive Bit Flips

149. Count Unique Characters of All Substrings of a Given String

150. Minimum Window Substring

151. Substring with Concatenation of All Words

152. Rearrange String k Distance Apart

153. Course Schedule III

154. Maximum Frequency Stack

155. Alien Dictionary

156. Sequence Reconstruction

157. Binary Tree Maximum Path Sum

158. Serialize and Deserialize Binary Tree

159. Word Search II

160. Find Median from Data Stream

161. Sliding Window Median

162. Trapping Rain Water

163. Container With Most Water

164. Concatenated Words

165. Prefix and Suffix Search

166. Palindrome Pairs

167. Design Search Autocomplete System

168. Word Squares

169. Sort Items by Groups Respecting Dependencies

170. Median of Two Sorted Arrays

Live Coding Links

Live Coding FAQ

Live Coding Getting Started Guide

SMIQ

When it comes to preparing for coding interview, what is the single biggest challenge/frustration/question you are running into right now?

Types of Dynamic Programming

For coding interviews, the most common types of DP problems are: 1. Knapsack - 0-1 - Bounded - Unbounded 2. LCS 3. LIS 4. Matrix chain multiplication 5. DP on grid 6. Kadane's algorithm etc Advanced Dynamic Programming 1. Kth lexicographical string 2. DP on Tree 3. DP + bitmasking 4. DP + BIT/Segment tree 5. DP + convex hull Mostly, this is for competitive programming.

Leetcode Live Coding Telegram Group

Join Leetcode Live Coding Telegram group: https://t.me/joinchat/VOy5LhxpFvgV4aJKeMBIRg

Friendly Link to join: https://t.me/livecodingpro

Join Leetcode Live Coding Telegram group: https://t.me/livecodingpro

Edit Distance - Dynamic Programming

 

Data Structure Operations Cheat Sheet