refactor: refactor

refactor package names

Signed-off-by: dk <workplace.davidkariuki@gmail.com>

Author: david-kariuki

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.array.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: []

app/src/main/java/AceTheJavaCodingInterview/data_structures/array/SubArraysWithProductLessThanTarget.java

@@ -14,10 +14,9 @@
  * @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.array.TripletsWithSmallerSum_ReturnCount},
- *     {@link
- *     AceTheJavaCodingInterview.module2_data_structures.array.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-array having a product less than the target. The
  *     implementation will be quite similar to Triplets with Smaller Sum.

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.array.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.

app/src/main/java/AceTheJavaCodingInterview/data_structures/array/TripletSumToZero.java

@@ -14,19 +14,19 @@
  *     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.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.
+ *     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.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.
+ *     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

app/src/main/java/AceTheJavaCodingInterview/data_structures/array/TripletsWithSmallerSum_ReturnList.java

@@ -14,10 +14,10 @@
  *     is less than the target: [-1, 1, 4], [-1, 1, 3], [-1, 1, 2], [-1, 2, 3]
  * @note Solution - This problem follows the Two Pointers pattern and shares similarities with
  *     Triplet Sum to Zero ({@link
- *     AceTheJavaCodingInterview.module2_data_structures.array.TripletSumToZero}). The only
- *     difference is that, in this problem, we need to find the triplets whose sum is less than the
- *     given target. To meet the condition i != j != k we need to make sure that each number is not
- *     used more than once.
+ *     AceTheJavaCodingInterview.data_structures.array.TripletSumToZero}). The only difference is
+ *     that, in this problem, we need to find the triplets whose sum is less than the given target.
+ *     To meet the condition i != j != k we need to make sure that each number is not used more than
+ *     once.
  *     <p>Following a similar approach, first, we can 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 < target X+Y+Z<target . At this stage, our problem