Skip to content

Commit

Permalink
Add Combine Arrays Problem (#12)
Browse files Browse the repository at this point in the history 
* Add comments

* Add new problem, add comments, add more tests

* Use single class imports
  • Loading branch information
@xtenzQ
xtenzQ authored Jul 3, 2024
1 parent ef23b76 commit ab61b5b
Show file tree
Hide file tree
Showing 2 changed files with 226 additions and 9 deletions.
53 changes: 53 additions & 0 deletions algorithms-and-data-structures/src/main/java/com/xtenzq/arrays/TwoPointers.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,13 @@

public class TwoPointers {

/**
* Checks if the given string is a palindrome.
*
* @param input the string to check for palindrome properties
* @return {@code true} if the input string is a palindrome, false otherwise
* @implNote This method runs in {@code O(n)} time complexity and {@code O(1)} space complexity, where n is the length of the input string.
*/
public static boolean isPalindrome(String input) {
int start = 0;
int end = input.length() - 1;
Expand All @@ -15,6 +22,14 @@ public static boolean isPalindrome(String input) {
return true;
}

/**
* Checks if there are two distinct elements in the sorted array that sum up to the given target.
*
* @param sortedArray an array of integers that is already sorted in ascending order
* @param target the sum to find in the array
* @return {@code true} if there are two distinct elements in the array whose sum is equal to the target, {@code false} otherwise
* @implNote This method runs in {@code O(n)} time complexity and {@code O(1)} space complexity, where n is the length of the sortedArray.
*/
public static boolean canBeSummed(int[] sortedArray, int target) {
int start = 0;
int end = sortedArray.length - 1;
Expand All @@ -31,4 +46,42 @@ public static boolean canBeSummed(int[] sortedArray, int target) {
}
return false;
}

/**
* Merges two sorted arrays into one sorted array.
*
* @param arr1 the first sorted array
* @param arr2 the second sorted array
* @return a new sorted array containing all elements from both input arrays
* @implNote This method runs in {@code O(n + m)} time complexity and {@code O(1)} space complexity,
* where {@code n} is the length of {@code arr1} and {@code m} is the length of {@code arr2}.
*/
public static int[] mergeSortedArrays(int[] arr1, int[] arr2) {
int[] res = new int[arr1.length + arr2.length];
int i = 0, j = 0, k = 0;
while (i < arr1.length && j < arr2.length) {
if (arr1[i] < arr2[j]) {
res[k] = arr1[i];
i++;
} else {
res[k] = arr2[j];
j++;
}
k++;
}

while (i < arr1.length) {
res[k] = arr1[i];
i++;
k++;
}

while (j < arr2.length) {
res[k] = arr2[j];
j++;
k++;
}

return res;
}
}
182 changes: 173 additions & 9 deletions algorithms-and-data-structures/src/test/java/com/xtenzq/arrays/TwoPointersTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,27 +2,191 @@

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;
import static com.xtenzq.arrays.TwoPointers.canBeSummed;
import static com.xtenzq.arrays.TwoPointers.isPalindrome;
import static com.xtenzq.arrays.TwoPointers.mergeSortedArrays;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

class TwoPointersTest {

@Test
void shouldReturnTrueIfPalindrome() {
assertTrue(TwoPointers.isPalindrome("racecar"));
void testEmptyString() {
assertTrue(isPalindrome(""));
}

@Test
void shouldReturnFalseIfNotPalindrome() {
assertFalse(TwoPointers.isPalindrome("raceacar"));
void testSingleCharacter() {
assertTrue(isPalindrome("a"));
}

@Test
void shouldReturnTrueIfCanBeSummed() {
assertTrue(TwoPointers.canBeSummed(new int[] { 1, 2, 4, 6, 8, 9, 14, 15 }, 13));
void testSimplePalindrome() {
assertTrue(isPalindrome("madam"));
}

@Test
void shouldReturnFalseIfCantBeSummed() {
assertFalse(TwoPointers.canBeSummed(new int[] { 1, 2, 4, 6, 8, 9, 14, 15 }, 30));
void testSimpleNonPalindrome() {
assertFalse(isPalindrome("hello"));
}

@Test
void testPalindromeWithSpaces() {
assertTrue(isPalindrome("a man a plan a canal panama".replace(" ", "")));
}

@Test
void testNonPalindromeWithSpaces() {
assertFalse(isPalindrome("hello world"));
}

@Test
void testPalindromeWithMixedCase() {
assertTrue(isPalindrome("Able was I ere I saw Elba".replace(" ", "").toLowerCase()));
}

@Test
void testPalindromeWithPunctuation() {
assertTrue(isPalindrome("A man, a plan, a canal, Panama".replaceAll("[\\W]", "").toLowerCase()));
}

@Test
void testNonPalindromeWithPunctuation() {
assertFalse(isPalindrome("Hello, world!"));
}

@Test
void testEmptyArray() {
int[] array = {};
int target = 5;
assertFalse(canBeSummed(array, target));
}

@Test
void testSingleElementArray() {
int[] array = {5};
int target = 5;
assertFalse(canBeSummed(array, target));
}

@Test
void testTwoElementsSumToTarget() {
int[] array = {1, 4};
int target = 5;
assertTrue(canBeSummed(array, target));
}

@Test
void testTwoElementsDoNotSumToTarget() {
int[] array = {1, 2};
int target = 5;
assertFalse(canBeSummed(array, target));
}

@Test
void testMultipleElementsSumToTarget() {
int[] array = {1, 2, 3, 4, 5};
int target = 9;
assertTrue(canBeSummed(array, target));
}

@Test
void testMultipleElementsDoNotSumToTarget() {
int[] array = {1, 2, 3, 4, 5};
int target = 10;
assertFalse(canBeSummed(array, target));
}

@Test
void testSumWithNegativeNumbers() {
int[] array = {-3, -1, 1, 2, 4};
int target = 1;
assertTrue(canBeSummed(array, target));
}

@Test
void testNegativeTarget() {
int[] array = {-5, -3, -1, 2, 4};
int target = -4;
assertTrue(canBeSummed(array, target));
}

@Test
void testNoPossibleSum() {
int[] array = {1, 2, 3, 4, 5};
int target = 20;
assertFalse(canBeSummed(array, target));
}

@Test
void testZeroTarget() {
int[] array = {-2, -1, 0, 1, 2};
int target = 0;
assertTrue(canBeSummed(array, target));
}

@Test
void testMergeBothEmptyArrays() {
int[] arr1 = {};
int[] arr2 = {};
int[] expected = {};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeFirstArrayEmpty() {
int[] arr1 = {};
int[] arr2 = {1, 2, 3};
int[] expected = {1, 2, 3};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeSecondArrayEmpty() {
int[] arr1 = {1, 2, 3};
int[] arr2 = {};
int[] expected = {1, 2, 3};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeBothNonEmpty() {
int[] arr1 = {1, 3, 5};
int[] arr2 = {2, 4, 6};
int[] expected = {1, 2, 3, 4, 5, 6};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeArraysWithDuplicates() {
int[] arr1 = {1, 3, 5, 5};
int[] arr2 = {2, 4, 5, 6};
int[] expected = {1, 2, 3, 4, 5, 5, 5, 6};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeArraysWithNegativeNumbers() {
int[] arr1 = {-3, -1, 2};
int[] arr2 = {-2, 0, 3};
int[] expected = {-3, -2, -1, 0, 2, 3};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeArraysWithDifferentLengths() {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = {6, 7};
int[] expected = {1, 2, 3, 4, 5, 6, 7};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}

@Test
void testMergeArraysWithSameElements() {
int[] arr1 = {1, 1, 1};
int[] arr2 = {1, 1, 1};
int[] expected = {1, 1, 1, 1, 1, 1};
assertArrayEquals(expected, mergeSortedArrays(arr1, arr2));
}
}

0 comments on commit ab61b5b

Please sign in to comment.