Skip to content

Commit f3578c7

Browse files
manojbaishyamanojbaishya
committed
Added BasicMaths and HashTables migration
1 parent c6b6376 commit f3578c7

5 files changed

Lines changed: 360 additions & 13 deletions

File tree

‎README.md‎

Lines changed: 10 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2,19 +2,16 @@ Computer Science problems in Java.
22

33
### Migration status - dojo.net
44
Combine single method classes in one file
5-
1. TwoSum.cs [WIP]
6-
2. BasicMaths.cs [WIP]
7-
3. GiftingGroups.cs [WIP]
8-
4. Hashing.cs [WIP]
9-
5. ItemsInContainers.cs [WIP]
10-
6. LongestSubstringWithoutRepeatingCharacters.cs [WIP]
11-
7. MedianOfTwoSortedArrays.cs [WIP]
12-
8. OptimizingBoxWeights.cs [WIP]
13-
9. PatternsIterationsAndConditionals.cs [WIP]
14-
10. Recursion.cs [WIP]
15-
11. SlidingWindow.cs [WIP]
16-
17-
## Important and Useful Libraries
5+
1. GiftingGroups.cs [WIP]
6+
2. ItemsInContainers.cs [WIP]
7+
3. LongestSubstringWithoutRepeatingCharacters.cs [WIP]
8+
4. MedianOfTwoSortedArrays.cs [WIP]
9+
5. OptimizingBoxWeights.cs [WIP]
10+
6. PatternsIterationsAndConditionals.cs [WIP]
11+
7. Recursion.cs [WIP]
12+
8. SlidingWindow.cs [WIP]
13+
14+
## Important and Useful LibrariesX
1815
* JDK Standard Library — https://docs.oracle.com/en/java/javase/24/docs/api/index.html
1916
* Checker Framework — https://checkerframework.org/manual/
2017
* Nullness Checker example — https://checkerframework.org/tutorial/webpages/get-started-cmd.html

‎src/main/java/org/dojo/leetcode/BasicMaths.java‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
package org.dojo.leetcode;
2+
3+
import java.util.ArrayList;
4+
import java.util.Collections;
5+
import java.util.List;
6+
7+
public class BasicMaths {
8+
public int evenlyDivides(int n) {
9+
int num = n;
10+
int count = 0;
11+
while (num > 0) {
12+
int lastDigit = num % 10;
13+
if (lastDigit != 0 && n % lastDigit == 0) {
14+
count++;
15+
}
16+
num /= 10;
17+
}
18+
return count;
19+
}
20+
21+
public int reverseInteger(int x) {
22+
int reverseNumber = 0;
23+
int num = x;
24+
int lastDigit;
25+
26+
while (num != 0) {
27+
lastDigit = num % 10;
28+
try {
29+
// Check for overflow before performing the operation
30+
if (reverseNumber > Integer.MAX_VALUE / 10 ||
31+
(reverseNumber == Integer.MAX_VALUE / 10 && lastDigit > Integer.MAX_VALUE % 10) ||
32+
reverseNumber < Integer.MIN_VALUE / 10 ||
33+
(reverseNumber == Integer.MIN_VALUE / 10 && lastDigit < Integer.MIN_VALUE % 10)) {
34+
return 0;
35+
}
36+
reverseNumber = reverseNumber * 10 + lastDigit;
37+
} catch (ArithmeticException e) {
38+
return 0;
39+
}
40+
num /= 10;
41+
}
42+
43+
return reverseNumber;
44+
}
45+
46+
public boolean isPalindrome(int x) {
47+
return x >= 0 && reverseInteger(x) == x;
48+
}
49+
50+
public boolean isArmstrongNumber(int num) {
51+
int copy = num;
52+
int sum = 0;
53+
while (copy != 0) {
54+
int lastDigit = copy % 10;
55+
sum += lastDigit * lastDigit * lastDigit;
56+
copy /= 10;
57+
}
58+
59+
return sum == num;
60+
}
61+
62+
public List<Integer> getAllDivisorsDesc(int N) {
63+
List<Integer> divisors = new ArrayList<>();
64+
double upperBound = Math.sqrt(N);
65+
for (int i = 1; i <= upperBound; i++) {
66+
if (N % i == 0) {
67+
divisors.add(i);
68+
int complement = N / i;
69+
if (complement != i) divisors.add(complement);
70+
}
71+
}
72+
73+
divisors.sort(Collections.reverseOrder());
74+
return divisors;
75+
}
76+
77+
public boolean isPrime(int N) {
78+
List<Integer> factors = getAllDivisorsDesc(N);
79+
return factors.size() == 2 && factors.contains(1) && factors.contains(N);
80+
}
81+
82+
public int highestCommonFactor(int M, int N) {
83+
List<Integer> factorsM = getAllDivisorsDesc(M);
84+
List<Integer> factorsN = getAllDivisorsDesc(N);
85+
86+
return factorsM.stream()
87+
.filter(factorsN::contains)
88+
.max(Integer::compareTo)
89+
.orElse(1);
90+
}
91+
92+
public int highestCommonFactorEuclidean(int M, int N) {
93+
while (M > 0 && N > 0) {
94+
if (M > N) M %= N;
95+
else N %= M;
96+
}
97+
98+
return M == 0 ? N : M;
99+
}
100+
101+
public int leastCommonMultiple(int M, int N) {
102+
int HCF = highestCommonFactorEuclidean(M, N);
103+
return (M * N) / HCF;
104+
}
105+
}

‎src/main/java/org/dojo/leetcode/HashTables.java‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
package org.dojo.leetcode;
2+
3+
import java.util.HashMap;
4+
import java.util.Map;
5+
import java.util.TreeMap;
6+
7+
public class HashTables {
8+
public int[] countFrequencies(int[] arr) {
9+
TreeMap<Integer, Integer> frequencies = new TreeMap<>();
10+
for (int j : arr) frequencies.merge(j, 1, Integer::sum);
11+
int[] freqArray = new int[arr.length];
12+
for (int key : frequencies.keySet()) freqArray[key - 1] = frequencies.get(key);
13+
return freqArray;
14+
}
15+
16+
public int[] twoSum(int[] nums, int target) {
17+
Map<Integer, Integer> map = new HashMap<>();
18+
for (int i = 0; i < nums.length; i++) {
19+
int complement = target - nums[i];
20+
if (map.containsKey(complement)) return new int[] {map.get(complement), i};
21+
map.put(nums[i], i);
22+
}
23+
return new int[] {};
24+
}
25+
}

‎src/test/java/org/dojo/leetcode/BasicMathsTests.java‎

Lines changed: 164 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
package org.dojo.leetcode;
2+
3+
import org.junit.jupiter.api.BeforeEach;
4+
import org.junit.jupiter.params.ParameterizedTest;
5+
import org.junit.jupiter.params.provider.Arguments;
6+
import org.junit.jupiter.params.provider.MethodSource;
7+
8+
import java.util.Arrays;
9+
import java.util.List;
10+
import java.util.stream.Stream;
11+
12+
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
13+
import static org.junit.jupiter.api.Assertions.assertEquals;
14+
15+
class BasicMathsTest {
16+
private BasicMaths sut;
17+
18+
@BeforeEach
19+
void setUp() {
20+
sut = new BasicMaths();
21+
}
22+
23+
static Stream<Arguments> evenlyDividesData() {
24+
return Stream.of(
25+
Arguments.of(12, 2)
26+
);
27+
}
28+
29+
@ParameterizedTest
30+
@MethodSource("evenlyDividesData")
31+
void evenlyDivides(int number, int expected) {
32+
int actual = sut.evenlyDivides(number);
33+
System.out.printf("Expected: %d%n", expected);
34+
System.out.printf("Actual: %d%n", actual);
35+
assertEquals(expected, actual);
36+
}
37+
38+
static Stream<Arguments> reverseIntegerData() {
39+
return Stream.of(
40+
Arguments.of(9854, 4589),
41+
Arguments.of(1534236469, 0),
42+
Arguments.of(-9854, -4589)
43+
);
44+
}
45+
46+
@ParameterizedTest
47+
@MethodSource("reverseIntegerData")
48+
void reverseInteger(int number, int expected) {
49+
int actual = sut.reverseInteger(number);
50+
System.out.printf("Expected: %d%n", expected);
51+
System.out.printf("Actual: %d%n", actual);
52+
assertEquals(expected, actual);
53+
}
54+
55+
static Stream<Arguments> isPalindromeData() {
56+
return Stream.of(
57+
Arguments.of(121, true),
58+
Arguments.of(-121, false),
59+
Arguments.of(10, false)
60+
);
61+
}
62+
63+
@ParameterizedTest
64+
@MethodSource("isPalindromeData")
65+
void isPalindrome(int number, boolean expected) {
66+
boolean actual = sut.isPalindrome(number);
67+
System.out.printf("Expected: %b%n", expected);
68+
System.out.printf("Actual: %b%n", actual);
69+
assertEquals(expected, actual);
70+
}
71+
72+
static Stream<Arguments> isArmstrongNumberData() {
73+
return Stream.of(
74+
Arguments.of(371, true),
75+
Arguments.of(1634, false),
76+
Arguments.of(35, false)
77+
);
78+
}
79+
80+
@ParameterizedTest
81+
@MethodSource("isArmstrongNumberData")
82+
void isArmstrongNumber(int number, boolean expected) {
83+
boolean actual = sut.isArmstrongNumber(number);
84+
System.out.printf("Expected: %b%n", expected);
85+
System.out.printf("Actual: %b%n", actual);
86+
assertEquals(expected, actual);
87+
}
88+
89+
static Stream<Arguments> getAllDivisorsData() {
90+
return Stream.of(
91+
Arguments.of(36, new int[] {36, 18, 12, 9, 6, 4, 3, 2, 1})
92+
);
93+
}
94+
95+
@ParameterizedTest
96+
@MethodSource("getAllDivisorsData")
97+
void getAllDivisors(int number, int[] expected) {
98+
List<Integer> actual = sut.getAllDivisorsDesc(number);
99+
System.out.printf("Expected: %s%n", Arrays.toString(expected));
100+
System.out.printf("Actual: %s%n", actual);
101+
assertArrayEquals(expected, actual.stream().mapToInt(i -> i).toArray());
102+
}
103+
104+
static Stream<Arguments> isPrimeData() {
105+
return Stream.of(
106+
Arguments.of(36, false),
107+
Arguments.of(13, true),
108+
Arguments.of(11, true),
109+
Arguments.of(1, false)
110+
);
111+
}
112+
113+
@ParameterizedTest
114+
@MethodSource("isPrimeData")
115+
void isPrime(int number, boolean expected) {
116+
boolean actual = sut.isPrime(number);
117+
System.out.printf("Expected: %b%n", expected);
118+
System.out.printf("Actual: %b%n", actual);
119+
assertEquals(expected, actual);
120+
}
121+
122+
static Stream<Arguments> highestCommonFactorData() {
123+
return Stream.of(
124+
Arguments.of(12, 6, 6),
125+
Arguments.of(27, 18, 9),
126+
Arguments.of(11, 13, 1)
127+
);
128+
}
129+
130+
@ParameterizedTest
131+
@MethodSource("highestCommonFactorData")
132+
void highestCommonFactor(int M, int N, int expected) {
133+
int actual = sut.highestCommonFactor(M, N);
134+
System.out.printf("Expected: %d%n", expected);
135+
System.out.printf("Actual: %d%n", actual);
136+
assertEquals(expected, actual);
137+
}
138+
139+
@ParameterizedTest
140+
@MethodSource("highestCommonFactorData")
141+
void highestCommonFactorEuclidean(int M, int N, int expected) {
142+
int actual = sut.highestCommonFactorEuclidean(M, N);
143+
System.out.printf("Expected: %d%n", expected);
144+
System.out.printf("Actual: %d%n", actual);
145+
assertEquals(expected, actual);
146+
}
147+
148+
static Stream<Arguments> leastCommonMultipleData() {
149+
return Stream.of(
150+
Arguments.of(12, 6, 12),
151+
Arguments.of(27, 18, 54),
152+
Arguments.of(11, 13, 143)
153+
);
154+
}
155+
156+
@ParameterizedTest
157+
@MethodSource("leastCommonMultipleData")
158+
void leastCommonMultiple(int M, int N, int expected) {
159+
int actual = sut.leastCommonMultiple(M, N);
160+
System.out.printf("Expected: %d%n", expected);
161+
System.out.printf("Actual: %d%n", actual);
162+
assertEquals(expected, actual);
163+
}
164+
}

‎src/test/java/org/dojo/leetcode/HashTablesTests.java‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
package org.dojo.leetcode;
2+
3+
import org.junit.jupiter.api.BeforeEach;
4+
import org.junit.jupiter.params.ParameterizedTest;
5+
import org.junit.jupiter.params.provider.Arguments;
6+
import org.junit.jupiter.params.provider.MethodSource;
7+
8+
import java.util.Arrays;
9+
import java.util.stream.Stream;
10+
11+
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
12+
13+
class HashTablesTests {
14+
private HashTables sut;
15+
@BeforeEach
16+
void setUp() {
17+
sut = new HashTables();
18+
}
19+
20+
private static Stream<Arguments> countFrequenciesTestData() {
21+
return Stream.of(
22+
Arguments.of(new int[] {2, 3, 2, 3, 5}, new int[] {0, 2, 2, 0, 1}),
23+
Arguments.of(new int[] {3, 3, 3, 3}, new int[] {0, 0, 4, 0}),
24+
Arguments.of(new int[] {1}, new int[] {1})
25+
);
26+
}
27+
28+
@ParameterizedTest
29+
@MethodSource("countFrequenciesTestData")
30+
void countFrequencies(int[] input, int[] expected) {
31+
int[] actual = sut.countFrequencies(input);
32+
assertArrayEquals(expected, actual);
33+
}
34+
35+
private static Stream<Arguments> testData() {
36+
return Stream.of(
37+
Arguments.of(new int[] {2, 7, 11, 15}, 9, new int[] {0, 1}),
38+
Arguments.of(new int[] {3, 2, 4}, 6, new int[] {1, 2}),
39+
Arguments.of(new int[] {3, 3}, 6, new int[] {0, 1}),
40+
Arguments.of(new int[] {3, 2, 3}, 6, new int[] {0, 2}),
41+
Arguments.of(new int[] {0, 4, 3, 0}, 0, new int[] {0, 3}),
42+
Arguments.of(new int[] {-3, 4, 3, 90}, 0, new int[] {0, 2}),
43+
Arguments.of(new int[] {-1, -2, -3, -4, -5}, -8, new int[] {2, 4}),
44+
Arguments.of(new int[] {-10, -1, -18, -19}, -19, new int[] {1, 2})
45+
);
46+
}
47+
48+
@ParameterizedTest
49+
@MethodSource("testData")
50+
public void testTwoSum(int[] inputArray, int inputTarget, int[] expected) {
51+
int[] actual = sut.twoSum(inputArray, inputTarget);
52+
System.out.printf("%s%n", Arrays.toString(expected));
53+
System.out.printf("%s%n", Arrays.toString(actual));
54+
assertArrayEquals(expected, actual);
55+
}
56+
}

0 commit comments

Comments
 (0)