[LEET-000] clean up comments

Author: fishercoder1534

leetcode-algorithms/src/main/java/com/stevesun/solutions/BSTIterator_using_q.java

@@ -5,10 +5,7 @@
 import java.util.LinkedList;
 import java.util.Queue;
 
-/**173. Binary Search Tree Iterator  QuestionEditorial Solution  My Submissions
-Total Accepted: 56053
-Total Submissions: 154876
-Difficulty: Medium
+/**173. Binary Search Tree Iterator
 Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.
 
 Calling next() will return the next smallest number in the BST.

leetcode-algorithms/src/main/java/com/stevesun/solutions/CombinationSumIII.java

@@ -2,6 +2,24 @@
 
 import java.util.*;
 
+/**Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
+
+
+ Example 1:
+
+ Input: k = 3, n = 7
+
+ Output:
+
+ [[1,2,4]]
+
+ Example 2:
+
+ Input: k = 3, n = 9
+
+ Output:
+
+ [[1,2,6], [1,3,5], [2,3,4]]*/
 public class CombinationSumIII {
     public List<List<Integer>> combinationSum3(int k, int n) {
         List<List<Integer>> result = new ArrayList();

leetcode-algorithms/src/main/java/com/stevesun/solutions/Combinations.java

@@ -1,10 +1,20 @@
 package com.stevesun.solutions;
 import java.util.*;
 
-public class Combinations {
-    //I'm glad that I made this one AC'ed the first time I submitted it.
-    //After finishing three similar problems! Cool!
+/**Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.
+
+ For example,
+ If n = 4 and k = 2, a solution is:
 
+ [
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
+ ]*/
+public class Combinations {
     public List<List<Integer>> combine(int n, int k) {
         List<List<Integer>> result = new ArrayList();
         int[] nums = new int[n];

leetcode-algorithms/src/main/java/com/stevesun/solutions/DecodeWays.java

@@ -1,7 +1,18 @@
 package com.stevesun.solutions;
 import  java.util.*;
 /**
- * Created by fishercoder1534 on 10/3/16.
+ * A message containing letters from A-Z is being encoded to numbers using the following mapping:
+
+ 'A' -> 1
+ 'B' -> 2
+ ...
+ 'Z' -> 26
+ Given an encoded message containing digits, determine the total number of ways to decode it.
+
+ For example,
+ Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+
+ The number of ways decoding "12" is 2.
  */
 public class DecodeWays {
     /**Then I found this post is very concise: https://discuss.leetcode.com/topic/35840/java-clean-dp-solution-with-explanation*/

leetcode-algorithms/src/main/java/com/stevesun/solutions/DesignPhoneDirectory.java

@@ -5,6 +5,37 @@
 import java.util.Queue;
 import java.util.Set;
 
+/**Design a Phone Directory which supports the following operations:
+
+ get: Provide a number which is not assigned to anyone.
+ check: Check if a number is available or not.
+ release: Recycle or release a number.
+ Example:
+
+ // Init a phone directory containing a total of 3 numbers: 0, 1, and 2.
+ PhoneDirectory directory = new PhoneDirectory(3);
+
+ // It can return any available phone number. Here we assume it returns 0.
+ directory.get();
+
+ // Assume it returns 1.
+ directory.get();
+
+ // The number 2 is available, so return true.
+ directory.check(2);
+
+ // It returns 2, the only number that is left.
+ directory.get();
+
+ // The number 2 is no longer available, so return false.
+ directory.check(2);
+
+ // Release number 2 back to the pool.
+ directory.release(2);
+
+ // Number 2 is available again, return true.
+ directory.check(2);
+ */
 public class DesignPhoneDirectory {
 
     private class PhoneDirectory {

leetcode-algorithms/src/main/java/com/stevesun/solutions/RandomPickIndex.java

@@ -5,6 +5,21 @@
 import java.util.List;
 import java.util.Map;
 
+/**Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.
+
+ Note:
+ The array size can be very large. Solution that uses too much extra space will not pass the judge.
+
+ Example:
+
+ int[] nums = new int[] {1,2,3,3,3};
+ Solution solution = new Solution(nums);
+
+ // pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
+ solution.pick(3);
+
+ // pick(1) should return 0. Since in the array only nums[0] is equal to 1.
+ solution.pick(1);*/
 public class RandomPickIndex {
 
 }

leetcode-algorithms/src/main/java/com/stevesun/solutions/RandomizedCollection.java

@@ -4,10 +4,8 @@
 import java.util.Map;
 import java.util.Random;
 
-/**381. Insert Delete GetRandom O(1) - Duplicates allowed  QuestionEditorial Solution  My Submissions
-Total Accepted: 190
-Total Submissions: 613
-Difficulty: Medium
+/**381. Insert Delete GetRandom O(1) - Duplicates allowed
+ *
 Design a data structure that supports all following operations in average O(1) time.
 
 Note: Duplicate elements are allowed.

leetcode-algorithms/src/main/java/com/stevesun/solutions/RandomizedSet.java

@@ -7,11 +7,12 @@
 import java.util.Random;
 import java.util.Set;
 
-/**This solution got AC'ed. Although it's not really doing random 8/4/2016, it got rejected ever since because they added test case 
+
+public class RandomizedSet {
+/**This solution got AC'ed. Although it's not really doing random 8/4/2016, it got rejected ever since because they added test case
  * to see if it's really randomized.
  * Now, they've updated the test case and also the question description: Each element must have the same probability of being returned.*/
-public class RandomizedSet {
-    
+
     Set<Integer> set;
 
     /** Initialize your data structure here. */

leetcode-algorithms/src/main/java/com/stevesun/solutions/RangeAddition.java

@@ -1,5 +1,44 @@
 package com.stevesun.solutions;
 
+/**Assume you have an array of length n initialized with all 0's and are given k update operations.
+
+ Each operation is represented as a triplet: [startIndex, endIndex, inc] which increments each element of subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.
+
+ Return the modified array after all k operations were executed.
+
+ Example:
+
+ Given:
+
+ length = 5,
+ updates = [
+ [1,  3,  2],
+ [2,  4,  3],
+ [0,  2, -2]
+ ]
+
+ Output:
+
+ [-2, 0, 3, 5, 3]
+ Explanation:
+
+ Initial state:
+ [ 0, 0, 0, 0, 0 ]
+
+ After applying operation [1, 3, 2]:
+ [ 0, 2, 2, 2, 0 ]
+
+ After applying operation [2, 4, 3]:
+ [ 0, 2, 5, 5, 3 ]
+
+ After applying operation [0, 2, -2]:
+ [-2, 0, 3, 5, 3 ]
+ Hint:
+
+ Thinking of using advanced data structures? You are thinking it too complicated.
+ For each update operation, do you really need to update all elements between i and j?
+ Update only the first and end element is sufficient.
+ The optimal time complexity is O(k + n) and uses O(1) extra space.*/
 public class RangeAddition {
     /**Previously AC'ed brute force solution results in TLE now.*/
     public static int[] getModifiedArray_TLE(int length, int[][] updates) {

leetcode-algorithms/src/main/java/com/stevesun/solutions/RectangleArea.java

@@ -1,5 +1,11 @@
 package com.stevesun.solutions;
 
+/**Find the total area covered by two rectilinear rectangles in a 2D plane.
+
+ Each rectangle is defined by its bottom left corner and top right corner as shown in the figure.
+
+ Rectangle Area
+ Assume that the total area is never beyond the maximum possible value of int.*/
 public class RectangleArea {
 
     public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {