Dsa

app/src/main/java/AceTheJavaCodingInterview/module1_big_o_notation/BigONestedLoopWithAddition.java → app/src/main/java/AceTheJavaCodingInterview/big_o_notation/BigONestedLoopWithAddition.java

@@ -1,12 +1,11 @@
 /**
- * Big (O) of Nested Loop With Addition
- * Compute the Big O complexity of the code snippet given below.
+ * Big (O) of Nested Loop With Addition Compute the Big O complexity of the code snippet given
+ * below.
  *
  * @authr David Kariuki
  * @since 10/8/2022
  */
-
-package AceTheJavaCodingInterview.module1_big_o_notation;
+package AceTheJavaCodingInterview.big_o_notation;
 
 public class BigONestedLoopWithAddition {
 

app/src/main/java/AceTheJavaCodingInterview/module1_big_o_notation/BigONestedLoopWithMultiplication.java → app/src/main/java/AceTheJavaCodingInterview/big_o_notation/BigONestedLoopWithMultiplication.java

@@ -1,12 +1,11 @@
 /**
- * Big (O) of Nested Loop With Multiplication
- * Compute the Big O complexity of the code snippet given below.
+ * Big (O) of Nested Loop With Multiplication Compute the Big O complexity of the code snippet given
+ * below.
  *
  * @authr David Kariuki
  * @since 12/8/2022
  */
-
-package AceTheJavaCodingInterview.module1_big_o_notation;
+package AceTheJavaCodingInterview.big_o_notation;
 
 @SuppressWarnings("ALL")
 public class BigONestedLoopWithMultiplication {

app/src/main/java/AceTheJavaCodingInterview/module1_big_o_notation/BigONestedLoopWithSubtraction.java → app/src/main/java/AceTheJavaCodingInterview/big_o_notation/BigONestedLoopWithSubtraction.java

@@ -1,12 +1,11 @@
 /**
- * Big (O) of Nested Loop With Subtraction
- * Compute the Big O complexity of the code snippet given below.
+ * Big (O) of Nested Loop With Subtraction Compute the Big O complexity of the code snippet given
+ * below.
  *
  * @authr David Kariuki
  * @since 11/8/2022
  */
-
-package AceTheJavaCodingInterview.module1_big_o_notation;
+package AceTheJavaCodingInterview.big_o_notation;
 
 public class BigONestedLoopWithSubtraction {
 

app/src/main/java/AceTheJavaCodingInterview/module1_big_o_notation/problem_sets/ProblemSet1.java → app/src/main/java/AceTheJavaCodingInterview/big_o_notation/problem_sets/ProblemSet1.java

@@ -1,10 +1,10 @@
 /**
  * Problem set 1
+ *
  * @author David Kariuki
  * @since 14/8/2022
  */
-
-package AceTheJavaCodingInterview.module1_big_o_notation.problem_sets;
+package AceTheJavaCodingInterview.big_o_notation.problem_sets;
 
 @SuppressWarnings("unused")
 public class ProblemSet1 {

app/src/main/java/AceTheJavaCodingInterview/module1_big_o_notation/problem_sets/ProblemSet2.java → app/src/main/java/AceTheJavaCodingInterview/big_o_notation/problem_sets/ProblemSet2.java

@@ -1,11 +1,10 @@
 /**
  * Problem set 2
+ *
  * @author David Kariuki
  * @since 14/8/2022
  */
-
-package AceTheJavaCodingInterview.module1_big_o_notation.problem_sets;
-
+package AceTheJavaCodingInterview.big_o_notation.problem_sets;
 
 /**
  * <p>

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/ClassTemplate.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/ClassTemplate.java

@@ -4,14 +4,16 @@
  * <p>
  *
  * @question Problem Statement -
- * @example
+ * @example Example 1:
+ * @example Example 2:
+ * @example Example 3:
  * @note Solution -
  * @note Time Complexity -
  * @note Space Complexity -
  * @author David Kariuki
- * @since /8/2022
+ * @since /9/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures;
+package AceTheJavaCodingInterview.data_structures;
 
 public class ClassTemplate {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/FindMaximumInSlidingWindow.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/FindMaximumInSlidingWindow.java

@@ -11,9 +11,9 @@
  * @author David Kariuki
  * @since 17/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
-import AceTheJavaCodingInterview.module2_data_structures.utils.DataStructuresUtils;
+import AceTheJavaCodingInterview.data_structures.utils.DataStructuresUtils;
 
 import java.util.ArrayDeque;
 import java.util.Deque;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/FindTheSmallestCommonNumber.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/FindTheSmallestCommonNumber.java

@@ -3,14 +3,14 @@
  *
  * <p>
  *
- * @question Given three integer arrays sorted in ascending order, return the smallest number found
- * in all three arrays.
+ * @question Given three integer array sorted in ascending order, return the smallest number found
+ * in all three array.
  * @author David Kariuki
  * @since 18/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
-import AceTheJavaCodingInterview.module2_data_structures.utils.DataStructuresUtils;
+import AceTheJavaCodingInterview.data_structures.utils.DataStructuresUtils;
 
 public class FindTheSmallestCommonNumber {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/MaximumSumSubarrayOfSizeK.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/MaximumSumSubarrayOfSizeK.java

@@ -22,7 +22,7 @@
  * @author David Kariuki
  * @since 23/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 public class MaximumSumSubarrayOfSizeK {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/MergeAnArrayWithOverlappingIntervals.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/MergeAnArrayWithOverlappingIntervals.java

@@ -17,9 +17,9 @@
  * @author David Kariuki
  * @since 22/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
-import AceTheJavaCodingInterview.module2_data_structures.tuples.Interval;
+import AceTheJavaCodingInterview.data_structures.tuple.Interval;
 
 import java.util.ArrayList;
 import java.util.Arrays;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/OneDimensionalArrays.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/OneDimensionalArrays.java

@@ -7,7 +7,7 @@
  * @author David Kariuki
  * @since 14/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 @SuppressWarnings({"ForLoopReplaceableByForEach", "SameParameterValue"})
 public class OneDimensionalArrays {

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/PairWithTargetSum.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/PairWithTargetSum.java

@@ -36,7 +36,7 @@
  * @author David Kariuki
  * @since 24/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 public class PairWithTargetSum {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/Permutations.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/Permutations.java

@@ -9,9 +9,9 @@
  * <p>{1, 2, 3} {1, 3, 2} {2, 1, 3} {2, 3, 1} {3, 1, 2} {3, 2, 1}
  * <p>If a set has n distinct elements it will have n! n! permutations.
  * @note Solution This problem follows the Subsets pattern ({@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.Subset}) and, we can follow a
- * similar Breadth First Search (BFS) approach. However, unlike Subsets, every permutation must
- * contain all the numbers.
+ * AceTheJavaCodingInterview.data_structures.array.Subset}) and, we can follow a similar Breadth
+ * First Search (BFS) approach. However, unlike Subsets, every permutation must contain all the
+ * numbers.
  * <p>Let’s take the example-1 mentioned above to generate all the permutations. Following a BFS
  * approach, we will consider one number at a time:
  * <p>1. If the given set is empty then we have only an empty permutation set: []
@@ -39,12 +39,12 @@
  * and the queue to store the intermediate permutations. If you see closely, at any time, we
  * don’t have more than N! permutations between the result list and the queue. Therefore, the
  * overall space complexity to store N! permutations each containing N elements will be O(N*N!).
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.Subset
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.SubsetsWithDuplicates
+ * @see AceTheJavaCodingInterview.data_structures.array.Subset
+ * @see AceTheJavaCodingInterview.data_structures.array.SubsetsWithDuplicates
  * @author David Kariuki
  * @since 24/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.LinkedList;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/SmallestSubarrayWithAGreaterSum.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/SmallestSubarrayWithAGreaterSum.java

@@ -31,7 +31,7 @@
  * @author David Kariuki
  * @since 23/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 public class SmallestSubarrayWithAGreaterSum {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/SquaringASortedArray.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/SquaringASortedArray.java

@@ -18,7 +18,7 @@
  * @author David Kariuki
  * @since 23/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 public class SquaringASortedArray {
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/SubArraysWithProductLessThanTarget.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/SubArraysWithProductLessThanTarget.java

@@ -4,31 +4,33 @@
  * <p>
  *
  * @question Problem Statement - Given an array with positive numbers and a positive target number,
- * find all of its contiguous sub-arrays whose product is less than the target number.
+ * find all of its contiguous sub-array whose product is less than the target number.
  * @example Example 1:
  * <p>Input: [2, 5, 3, 10], target=30 Output: [2], [5], [2, 5], [3], [5, 3], [10] Explanation:
- * There are six contiguous sub-arrays whose product is less than the target.
+ * There are six contiguous sub-array whose product is less than the target.
  * @example Example 2:
  * <p>Input: [8, 2, 6, 5], target=50 Output: [8], [2], [8, 2], [6], [2, 6], [5], [6, 5]
- * Explanation: There are seven contiguous sub-arrays whose product is less than the target.
+ * Explanation: There are seven contiguous sub-array whose product is less than the target.
  * @note Solution - This problem follows the Sliding Window and the Two Pointers pattern and shares
  * similarities with Triplets with Smaller Sum
  * <p>({@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.TripletsWithSmallerSum_ReturnCount},
- * {@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.TripletsWithSmallerSum_ReturnList})
- * with two differences:
+ * AceTheJavaCodingInterview.data_structures.array.TripletsWithSmallerSum_ReturnCount}, {@link
+ * AceTheJavaCodingInterview.data_structures.array.TripletsWithSmallerSum_ReturnList}) with two
+ * differences:
  * <p>In this problem, the input array is not sorted. Instead of finding triplets with sum less
- * than a target, we need to find all sub-arrays having a product less than the target. The
+ * than a target, we need to find all sub-array having a product less than the target. The
  * implementation will be quite similar to Triplets with Smaller Sum.
- * @note Time Complexity -
- * @note Space Complexity -
+ * @note Time Complexity - The main for-loop managing the sliding window takes O(N) but creating
+ * sub-array can take up to O(N^2) in the worst case. Therefore overall, our algorithm will take
+ * O(N^3).
+ * @note Space Complexity - Ignoring the space required for the output list, the algorithm runs in
+ * O(N) space which is used for the temp list.
  * @author David Kariuki
  * @since 26/8/2022
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.TripletsWithSmallerSum_ReturnCount
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.TripletsWithSmallerSum_ReturnList
+ * @see AceTheJavaCodingInterview.data_structures.array.TripletsWithSmallerSum_ReturnCount
+ * @see AceTheJavaCodingInterview.data_structures.array.TripletsWithSmallerSum_ReturnList
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
@@ -49,7 +51,7 @@ public static void main(String[] args) {
  }
 
  /**
- * Method to find sub arrays
+ * Method to find sub array
  *
  * @param arr - int[]
  * @param target - int
@@ -72,7 +74,7 @@ public static List<List<Integer>> findSubArrays(int[] arr, int target) {
  }
 
  // Since the product of all numbers from left to right is less than the
- // target therefore, all sub-arrays from left to right will have a
+ // target therefore, all sub-array from left to right will have a
  // product less than the target too; to avoid duplicates, we will start
  // with a sub-array containing only arr[right] and then extend it.
  List<Integer> tempList = new LinkedList<>();

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/Subset.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/Subset.java

@@ -28,7 +28,7 @@
  * @author David Kariuki
  * @since 23/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.List;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/SubsetsWithDuplicates.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/SubsetsWithDuplicates.java

@@ -42,7 +42,7 @@
  * @author David Kariuki
  * @since 24/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.Arrays;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/TripletSumCloseToTarget.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/TripletSumCloseToTarget.java

@@ -8,8 +8,7 @@
  * of the triplet. If there are more than one such triplet, return the sum of the triplet with
  * the smallest sum.
  * @note Solution - This problem follows the Two Pointers pattern and is quite similar to Triplet
- * Sum to Zero({@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.TripletSumToZero}).
+ * Sum to Zero({@link AceTheJavaCodingInterview.data_structures.array.TripletSumToZero}).
  * <p>We can follow a similar approach to iterate through the array, taking one number at a
  * time. At every step, we will save the difference between the triplet and the target number,
  * so that in the end, we can return the triplet with the closest sum.
@@ -19,9 +18,9 @@
  * for sorting.
  * @author David Kariuki
  * @since 25/8/2022
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.TripletSumToZero
+ * @see AceTheJavaCodingInterview.data_structures.array.TripletSumToZero
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.Arrays;
 

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/TripletSumToZero.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/TripletSumToZero.java

@@ -14,31 +14,31 @@
  * unique triplets whose sum is equal to zero.
  * @solution Solution - This problem follows the Two Pointers pattern and shares similarities with
  * Pair with Target Sum ({@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.PairWithTargetSum}). A couple of
- * differences are that the input array is not sorted and instead of a pair we need to find
- * triplets with a target sum of zero.
+ * AceTheJavaCodingInterview.data_structures.array.PairWithTargetSum}). A couple of differences
+ * are that the input array is not sorted and instead of a pair we need to find triplets with a
+ * target sum of zero.
  * <p>To follow a similar approach, first, we will sort the array and then iterate through it
  * taking one number at a time. Let’s say during our iteration we are at number ‘X’, so we need
  * to find ‘Y’ and ‘Z’ such that X + Y + Z == 0. At this stage, our problem translates into
  * finding a pair whose sum is equal to -X (as from the above equation Y + Z == -X).
  * <p>
  * <p>Another difference from Pair with Target Sum({@link
- * AceTheJavaCodingInterview.module2_data_structures.arrays.PairWithTargetSum}) is that we need
- * to find all the unique triplets. To handle this, we have to skip any duplicate number. Since
- * we will be sorting the array, so all the duplicate numbers will be next to each other and are
- * easier to skip.
+ * AceTheJavaCodingInterview.data_structures.array.PairWithTargetSum}) is that we need to find
+ * all the unique triplets. To handle this, we have to skip any duplicate number. Since we will
+ * be sorting the array, so all the duplicate numbers will be next to each other and are easier
+ * to skip.
  * @note Time complexity - Sorting the array will take O(N * logN). The searchPair() function will
  * take O(N). As we are calling searchPair() for every number in the input array, this means
  * that overall searchTriplets() will take O(N * logN + N^2), which is asymptotically equivalent
  * to O(N^2).
  * @note Space complexity - Ignoring the space required for the output array, the space complexity
  * of the above algorithm will be O(N) which is required for sorting.
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.PairWithTargetSum
- * @see AceTheJavaCodingInterview.module2_data_structures.hash_tables.PairWithTargetSum
+ * @see AceTheJavaCodingInterview.data_structures.array.PairWithTargetSum
+ * @see AceTheJavaCodingInterview.data_structures.hash_table.PairWithTargetSum
  * @author David Kariuki
  * @since 25/8/2022
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.Arrays;

app/src/main/java/AceTheJavaCodingInterview/module2_data_structures/arrays/TripletsWithSmallerSum_ReturnCount.java → app/src/main/java/AceTheJavaCodingInterview/data_structures/array/TripletsWithSmallerSum_ReturnCount.java

@@ -17,9 +17,9 @@
  * of the above algorithm will be O(N) which is required for sorting.
  * @author David Kariuki
  * @since 26/8/2022
- * @see AceTheJavaCodingInterview.module2_data_structures.arrays.TripletSumToZero
+ * @see AceTheJavaCodingInterview.data_structures.array.TripletSumToZero
  */
-package AceTheJavaCodingInterview.module2_data_structures.arrays;
+package AceTheJavaCodingInterview.data_structures.array;
 
 import java.util.ArrayList;
 import java.util.Arrays;