From fd890ab974a60188b9c53d3e76c01fa0eb511ba1 Mon Sep 17 00:00:00 2001 From: Trishun Date: Sun, 23 Oct 2022 22:47:59 +0200 Subject: [PATCH 01/10] Resolves Java Priority Queue Task --- .../priority_queue/Solution.java | 85 +++++++++++++++++++ .../training/hackerrank/HackerRankTest.java | 7 ++ .../hackerrank/SolutionClassDescription.java | 2 +- .../priority_queue/SolutionTest.java | 47 ++++++++++ 4 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/Solution.java new file mode 100644 index 0000000..f636c45 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/Solution.java @@ -0,0 +1,85 @@ +package eu.ztsh.training.hackerrank.datastructures.priority_queue; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; +import java.util.PriorityQueue; +import java.util.Scanner; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +class Priorities { + + List getStudents(List events) { + var queue = new PriorityQueue<>(events.size(), + Comparator.comparingDouble(Student::getCGPA) + .reversed() // CGPA is the only descending here + .thenComparing(Student::getName) + .thenComparing(Student::getID)); + events.forEach(event -> { + var line = event.split(" "); + switch (line[0]) { + case "ENTER" -> + queue.add(new Student(Integer.parseInt(line[3]), line[1], Double.parseDouble(line[2]))); + case "SERVED" -> queue.poll(); + default -> throw new IllegalArgumentException(); + } + }); + return Stream.generate(queue::poll).takeWhile(Objects::nonNull).collect(Collectors.toList()); + } + +} + +class Student { + + Student(int id, String name, double cgpa) { + this.id = id; + this.name = name; + this.cgpa = cgpa; + } + + int getID() { + return id; + } + + String getName() { + return name; + } + + double getCGPA() { + return cgpa; + } + + private final int id; + private final String name; + private final double cgpa; + +} + +// https://www.hackerrank.com/challenges/java-priority-queue/problem +public class Solution { + + public static void main(String[] args) { + int totalEvents = Integer.parseInt(scan.nextLine()); + List events = new ArrayList<>(); + + while (totalEvents-- != 0) { + String event = scan.nextLine(); + events.add(event); + } + + List students = priorities.getStudents(events); + + if (students.isEmpty()) { + System.out.println("EMPTY"); + } else { + for (Student st : students) { + System.out.println(st.getName()); + } + } + } + private static Scanner scan = new Scanner(System.in); + private final static Priorities priorities = new Priorities(); + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/HackerRankTest.java b/src/test/java/eu/ztsh/training/hackerrank/HackerRankTest.java index cf59987..7c518cc 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/HackerRankTest.java +++ b/src/test/java/eu/ztsh/training/hackerrank/HackerRankTest.java @@ -10,6 +10,8 @@ import java.util.List; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; +import static org.assertj.core.api.Assertions.assertThat; + public abstract class HackerRankTest { @BeforeAll @@ -25,6 +27,11 @@ public abstract class HackerRankTest { System.setIn(originalIn); } + protected void simpleAssert(List input, List expected) { + var result = invoke(input); + assertThat(result).containsExactlyElementsOf(expected); + } + protected List invoke(List input) { try { outContent.reset(); diff --git a/src/test/java/eu/ztsh/training/hackerrank/SolutionClassDescription.java b/src/test/java/eu/ztsh/training/hackerrank/SolutionClassDescription.java index b141262..ced0393 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/SolutionClassDescription.java +++ b/src/test/java/eu/ztsh/training/hackerrank/SolutionClassDescription.java @@ -4,7 +4,7 @@ import java.util.Arrays; public record SolutionClassDescription(Class targetClass, String fieldName, FieldModifier[] modifiers) { - SolutionClassDescription(Class targetClass) { + public SolutionClassDescription(Class targetClass) { this(targetClass, null, null); } diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java new file mode 100644 index 0000000..1e2c7ab --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java @@ -0,0 +1,47 @@ +package eu.ztsh.training.hackerrank.datastructures.priority_queue; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import eu.ztsh.training.hackerrank.SolutionClassDescription.FieldModifier; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("HackerRank chalenges: Java Priority Queue") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + var input = List.of( + "12", + "ENTER John 3.75 50", + "ENTER Mark 3.8 24", + "ENTER Shafaet 3.7 35", + "SERVED", + "SERVED", + "ENTER Samiha 3.85 36", + "SERVED", + "ENTER Ashley 3.9 42", + "ENTER Maria 3.6 46", + "ENTER Anik 3.95 49", + "ENTER Dan 3.95 50", + "SERVED" + ); + var expected = List.of( + "Dan", + "Ashley", + "Shafaet", + "Maria" + ); + simpleAssert(input, expected); + } + + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class, + "scan", + new FieldModifier[]{FieldModifier.PRIVATE, FieldModifier.STATIC}); + } + +} \ No newline at end of file From 4d6be24f496a279bdbf97ca2575adcbe7952929e Mon Sep 17 00:00:00 2001 From: Trishun Date: Sun, 23 Oct 2022 23:08:51 +0200 Subject: [PATCH 02/10] Resolves Java 1D Array Task --- .../datastructures/array_1d/Solution.java | 24 ++++++++++++++ .../datastructures/array_1d/SolutionTest.java | 33 +++++++++++++++++++ .../priority_queue/SolutionTest.java | 2 +- 3 files changed, 58 insertions(+), 1 deletion(-) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java new file mode 100644 index 0000000..c1738e4 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java @@ -0,0 +1,24 @@ +package eu.ztsh.training.hackerrank.datastructures.array_1d; + +import java.util.Scanner; + +// https://www.hackerrank.com/challenges/java-1d-array-introduction/problem +public class Solution { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int n = scan.nextInt(); + int[] a = new int[n]; + int index = 0; + while (scan.hasNext()) { + a[index] = scan.nextInt(); + index++; + } + scan.close(); + // Prints each sequential element in array a + for (int i = 0; i < a.length; i++) { + System.out.println(a[i]); + } + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java new file mode 100644 index 0000000..50193e2 --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java @@ -0,0 +1,33 @@ +package eu.ztsh.training.hackerrank.datastructures.array_1d; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("HackerRank challenges: Java 1D Array") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of("5", "10", "20", "30", "40", "50"), + List.of("10", "20", "30", "40", "50") + ); + } + + @Test + public void testCase1() { + simpleAssert( + List.of("3", "100", "200", "100"), + List.of("100", "200", "100") + ); + } + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} \ No newline at end of file diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java index 1e2c7ab..5110d10 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/priority_queue/SolutionTest.java @@ -7,7 +7,7 @@ import eu.ztsh.training.hackerrank.SolutionClassDescription.FieldModifier; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -@DisplayName("HackerRank chalenges: Java Priority Queue") +@DisplayName("HackerRank challenges: Java Priority Queue") class SolutionTest extends HackerRankTest { @Test From 540a63dbc2318a9c44ea627df97aa82b6546c657 Mon Sep 17 00:00:00 2001 From: Trishun Date: Sun, 23 Oct 2022 23:31:04 +0200 Subject: [PATCH 03/10] Provides custom, modern class for 1D Array task --- .../array_1d/CustomSolution.java | 26 ++++++++++ .../datastructures/array_1d/Solution.java | 8 ++- .../datastructures/array_1d/SolutionTest.java | 50 +++++++++++++------ 3 files changed, 67 insertions(+), 17 deletions(-) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/CustomSolution.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/CustomSolution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/CustomSolution.java new file mode 100644 index 0000000..22ac17d --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/CustomSolution.java @@ -0,0 +1,26 @@ +package eu.ztsh.training.hackerrank.datastructures.array_1d; + +import java.util.Arrays; +import java.util.Scanner; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Stream; + +/** + * Custom modern class for 1D Array task. + */ +public class CustomSolution { + + public static void main(String[] args) { + var scan = new Scanner(System.in); + int n = scan.nextInt(); + // 1. Create an array, a, capable of holding n integers. + int[] a = new int[n]; + var index = new AtomicInteger(0); + // 2. Modify the code in the loop so that it saves each sequential value to its corresponding location in the array. + Stream.generate(scan::nextInt) + .limit(n) // takeWhile doesn't fill last element + .forEachOrdered(item -> a[index.getAndIncrement()] = item); + Arrays.stream(a).forEachOrdered(System.out::println); + } + +} diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java index c1738e4..7db6a4b 100644 --- a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d/Solution.java @@ -2,18 +2,24 @@ package eu.ztsh.training.hackerrank.datastructures.array_1d; import java.util.Scanner; -// https://www.hackerrank.com/challenges/java-1d-array-introduction/problem +/** + * Java 1D Array task. + * Task spec: Java 8 + partially locked editor + * source: https://www.hackerrank.com/challenges/java-1d-array-introduction/problem + */ public class Solution { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int n = scan.nextInt(); + // BEGIN: unlocked editor int[] a = new int[n]; int index = 0; while (scan.hasNext()) { a[index] = scan.nextInt(); index++; } + // END: unlocked editor scan.close(); // Prints each sequential element in array a for (int i = 0; i < a.length; i++) { diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java index 50193e2..7c0b1aa 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d/SolutionTest.java @@ -4,30 +4,48 @@ import java.util.List; import eu.ztsh.training.hackerrank.HackerRankTest; import eu.ztsh.training.hackerrank.SolutionClassDescription; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @DisplayName("HackerRank challenges: Java 1D Array") -class SolutionTest extends HackerRankTest { +class SolutionTest { - @Test - public void testCase0() { - simpleAssert( - List.of("5", "10", "20", "30", "40", "50"), - List.of("10", "20", "30", "40", "50") - ); + @Nested + @DisplayName("Original Solution class") + class OriginalSolutionTest extends Array1DTest { + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } } - @Test - public void testCase1() { - simpleAssert( - List.of("3", "100", "200", "100"), - List.of("100", "200", "100") - ); + @Nested + @DisplayName("Custom Solution class") + class CustomSolutionTest extends Array1DTest { + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(CustomSolution.class); + } } - @Override - protected SolutionClassDescription getSolutionClassDescription() { - return new SolutionClassDescription(Solution.class); + abstract static class Array1DTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of("5", "10", "20", "30", "40", "50"), + List.of("10", "20", "30", "40", "50") + ); + } + + @Test + public void testCase1() { + simpleAssert( + List.of("3", "100", "200", "100"), + List.of("100", "200", "100") + ); + } + } } \ No newline at end of file From 3da2a03859182dcd24c8fc04561526d572d7c998 Mon Sep 17 00:00:00 2001 From: Trishun Date: Mon, 24 Oct 2022 00:18:52 +0200 Subject: [PATCH 04/10] Resolves Java 2D Array Task --- .../datastructures/array_2d/Solution.java | 55 +++++++++++++++ .../training/hackerrank/EnvironmentTest.java | 27 +++++++ .../datastructures/array_2d/SolutionTest.java | 70 +++++++++++++++++++ 3 files changed, 152 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/array_2d/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/array_2d/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_2d/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_2d/Solution.java new file mode 100644 index 0000000..b3c6274 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_2d/Solution.java @@ -0,0 +1,55 @@ +package eu.ztsh.training.hackerrank.datastructures.array_2d; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +/** + * Java 2D Array task. + * source: https://www.hackerrank.com/challenges/java-2d-array/problem + */ +public class Solution { + + public static void main(String[] args) throws IOException { + BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); + + List> arr = new ArrayList<>(); + + IntStream.range(0, 6).forEach(i -> { + try { + arr.add( + Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" ")) + .map(Integer::parseInt) + .collect(Collectors.toList()) + ); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + }); + + var array = arr.stream().map(l -> l.stream().mapToInt(i -> i).toArray()).toArray(int[][]::new); + var max = new AtomicInteger(Integer.MIN_VALUE); + IntStream.range(1, 5).forEach(row -> IntStream.range(1, 5).forEach(col -> { + var result = countHourglass(array, row, col); + if (result > max.get()) { + max.set(result); + } + })); + + System.out.println(max.get()); + bufferedReader.close(); + } + + private static int countHourglass(int[][] array, int row, int col) { + return array[row - 1][col - 1] + array[row - 1][col] + array[row - 1][col + 1] + + array[row][col] + + array[row + 1][col - 1] + array[row + 1][col] + array[row + 1][col + 1]; + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/EnvironmentTest.java b/src/test/java/eu/ztsh/training/hackerrank/EnvironmentTest.java index 5fe0e22..8abed7d 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/EnvironmentTest.java +++ b/src/test/java/eu/ztsh/training/hackerrank/EnvironmentTest.java @@ -1,5 +1,8 @@ package eu.ztsh.training.hackerrank; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; import java.util.List; import java.util.Scanner; import eu.ztsh.training.hackerrank.SolutionClassDescription.FieldModifier; @@ -86,6 +89,17 @@ public class EnvironmentTest { } + @Nested + @DisplayName("Test with BufferedReader created in main(String[]) method") + class EnvironmentReaderTest extends HackerRankEnvironmentTest { + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(SampleSolutionWithInlineBufferedReader.class); + } + + } + } class SampleSolutionWithPrivateStaticScanner { @@ -123,3 +137,16 @@ class SampleSolutionWithInlineScanner { } } + +class SampleSolutionWithInlineBufferedReader { + + public static void main(String... args) throws IOException { + var bufferedReader = new BufferedReader(new InputStreamReader(System.in)); + String line = bufferedReader.readLine(); + do { + System.out.println(line); + line = bufferedReader.readLine(); + } while (line != null); + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_2d/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_2d/SolutionTest.java new file mode 100644 index 0000000..75f8030 --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_2d/SolutionTest.java @@ -0,0 +1,70 @@ +package eu.ztsh.training.hackerrank.datastructures.array_2d; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +@DisplayName("HackerRank challenges: Java 2D Array") +class SolutionTest extends HackerRankTest { + + @Test + public void dummyInitTest() { + assertThat(true).isTrue(); + } + + @Test + public void testCase0() { + simpleAssert( + List.of( + "1 1 1 0 0 0", + "0 1 0 0 0 0", + "1 1 1 0 0 0", + "0 0 2 4 4 0", + "0 0 0 2 0 0", + "0 0 1 2 4 0" + ), + List.of("19") + ); + } + + @Test + public void testCase1() { + simpleAssert( + List.of( + "1 1 1 0 0 0", + "0 1 0 0 0 0", + "1 1 1 0 0 0", + "0 9 2 -4 -4 0", + "0 0 0 -2 0 0", + "0 0 -1 -2 -4 0" + ), + List.of("13") + ); + } + + @Test + public void testCase3() { + simpleAssert( + List.of( + "-1 -1 0 -9 -2 -2", + "-2 -1 -6 -8 -2 -5", + "-1 -1 -1 -2 -3 -4", + "-1 -9 -2 -4 -4 -5", + "-7 -3 -3 -2 -9 -9", + "-1 -3 -1 -2 -4 -5" + ), + List.of("-6") + ); + } + + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} \ No newline at end of file From 1279712a8f68b8983450f68ef21c1ef8531b88be Mon Sep 17 00:00:00 2001 From: Trishun Date: Fri, 28 Oct 2022 21:57:58 +0200 Subject: [PATCH 05/10] Resolves Negative Subarray Task --- .../datastructures/subarray/Solution.java | 30 +++++++++++++++++++ .../datastructures/subarray/SolutionTest.java | 28 +++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/subarray/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/subarray/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/subarray/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/subarray/Solution.java new file mode 100644 index 0000000..8ce8d32 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/subarray/Solution.java @@ -0,0 +1,30 @@ +package eu.ztsh.training.hackerrank.datastructures.subarray; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.Arrays; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.IntStream; + +/** + * Java Subarray task. + * source: https://www.hackerrank.com/challenges/java-negative-subarray/problem + */ +public class Solution { + + public static void main(String[] args) throws IOException { + var reader = new BufferedReader(new InputStreamReader(System.in)); + var n = Integer.parseInt(reader.readLine()); + var array = Arrays.stream(reader.readLine().split(" ")).mapToInt(Integer::parseInt).toArray(); + var counter = new AtomicInteger(0); + IntStream.range(0, n).forEach(begin -> IntStream.range(begin, n + 1) + .forEach(end -> { + if (Arrays.stream(array, begin, end).sum() < 0) { + counter.incrementAndGet(); + } + })); + System.out.println(counter.get()); + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/subarray/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/subarray/SolutionTest.java new file mode 100644 index 0000000..59cc9f8 --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/subarray/SolutionTest.java @@ -0,0 +1,28 @@ +package eu.ztsh.training.hackerrank.datastructures.subarray; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +@DisplayName("HackerRank challenges: Java Subarray") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of("5", "1 -2 4 -5 1"), + List.of("9") + ); + } + + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} \ No newline at end of file From 880f1b2d2c4cb32f9ced98d447e131de57c7e9fb Mon Sep 17 00:00:00 2001 From: Trishun Date: Sat, 5 Nov 2022 21:59:49 +0100 Subject: [PATCH 06/10] Resolves Java 1D Array Pt.2 Task --- .../datastructures/array_1d_pt2/Solution.java | 63 ++++++++++++++ .../array_1d_pt2/SolutionTest.java | 83 +++++++++++++++++++ 2 files changed, 146 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/Solution.java new file mode 100644 index 0000000..7cc86ab --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/Solution.java @@ -0,0 +1,63 @@ +package eu.ztsh.training.hackerrank.datastructures.array_1d_pt2; + +import java.util.Arrays; +import java.util.Scanner; + +public class Solution { + + public static boolean canWin(int leap, int[] game) { + return move(0, leap, game, new int[]{}); + } + + static boolean isWinningMove(int index, int leap, int length) { + return index == length - 1 || index + leap > length - 1; + } + + static boolean canMoveForward(int index, int[] game) { + return game[index + 1] == 0; // We don't check last index as it is considered as winning move + } + + static boolean canMoveBackward(int index, int[] game) { + return index > 0 && game[index - 1] == 0; + } + + static boolean canJump(int index, int leap, int[] game) { + return game[index + leap] == 0; // We don't bother here about index overflow too + } + + private static boolean move(int index, int leap, int[] game, int[] history) { + if (Arrays.stream(history).anyMatch(i -> i == index)) { + return false; + } + var newHistory = Arrays.copyOf(history, history.length + 1); + newHistory[newHistory.length - 1] = index; + if (isWinningMove(index, leap, game.length)) { + return true; + } + if (canMoveForward(index, game) && move(index + 1, leap, game, newHistory)) { + return true; + } + if (canJump(index, leap, game) && move(index + leap, leap, game, newHistory)) { + return true; + } + return canMoveBackward(index, game) && move(index - 1, leap, game, newHistory); + } + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int q = scan.nextInt(); + while (q-- > 0) { + int n = scan.nextInt(); + int leap = scan.nextInt(); + + int[] game = new int[n]; + for (int i = 0; i < n; i++) { + game[i] = scan.nextInt(); + } + + System.out.println((canWin(leap, game)) ? "YES" : "NO"); + } + scan.close(); + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/SolutionTest.java new file mode 100644 index 0000000..542511a --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/array_1d_pt2/SolutionTest.java @@ -0,0 +1,83 @@ +package eu.ztsh.training.hackerrank.datastructures.array_1d_pt2; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class SolutionTest extends HackerRankTest { + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + + @Nested + @DisplayName("Provided test cases") + class TestCases { + + @Test + public void testCase0() { + simpleAssert( + List.of( + "4", + "5 3", + "0 0 0 0 0", + "6 5", + "0 0 0 1 1 1", + "6 3", + "0 0 1 1 1 0", + "3 1", + "0 1 0" + ), + List.of( + "YES", + "YES", + "NO", + "NO" + ) + ); + } + + } + + @Nested + @DisplayName("Unit tests") + class UnitTests { + + @Test + public void winningMoveTest() { + assertThat(Solution.isWinningMove(0, 1, 2)).isFalse(); + assertThat(Solution.isWinningMove(1, 5, 6)).isTrue(); + } + + @Test + public void moveForwardTest() { + var game = new int[]{0, 0, 1}; + assertThat(Solution.canMoveForward(0, game)).isTrue(); + assertThat(Solution.canMoveForward(1, game)).isFalse(); + } + + @Test + public void moveBackwardTest() { + var game = new int[]{0, 1, 0, 0, 1}; + assertThat(Solution.canMoveBackward(0, game)).isFalse(); + assertThat(Solution.canMoveBackward(3, game)).isTrue(); + assertThat(Solution.canMoveBackward(2, game)).isFalse(); + } + + @Test + public void jumpTest() { + var game = new int[]{0, 0, 1, 1, 1, 0}; + assertThat(Solution.canJump(0, 3, game)).isFalse(); + assertThat(Solution.canJump(1, 3, game)).isFalse(); + assertThat(Solution.canJump(1, 4, game)).isTrue(); + } + + } + +} \ No newline at end of file From 6e357de888c61b269840fb290f01c059330ba1c8 Mon Sep 17 00:00:00 2001 From: Trishun Date: Sat, 5 Nov 2022 22:31:46 +0100 Subject: [PATCH 07/10] Resolves Java Stack task --- .../datastructures/stack/Solution.java | 41 ++++++++++++ .../datastructures/stack/SolutionTest.java | 67 +++++++++++++++++++ 2 files changed, 108 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/stack/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/stack/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/stack/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/stack/Solution.java new file mode 100644 index 0000000..00c8102 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/stack/Solution.java @@ -0,0 +1,41 @@ +package eu.ztsh.training.hackerrank.datastructures.stack; + +import java.util.Map; +import java.util.Scanner; +import java.util.Stack; + +/** + * Java Stack task. + * source: https://www.hackerrank.com/challenges/java-stack + */ +public class Solution { + + public static void main(String[] args) { + var scanner = new Scanner(System.in); + while (scanner.hasNext()) { + var stack = new Stack(); + var line = scanner.next(); + for (char input : line.toCharArray()) { + if (stack.empty()) { + stack.push(input); + continue; + } + char head = stack.peek(); + if (closingChars.getOrDefault(input, '0').equals(head)) { + stack.pop(); + } else { + stack.push(input); + } + } + System.out.println(stack.empty()); + } + + } + + private static final Map closingChars = Map.of( + ']', '[', + '}', '{', + ')', '(' + ); + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/stack/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/stack/SolutionTest.java new file mode 100644 index 0000000..0ecec40 --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/stack/SolutionTest.java @@ -0,0 +1,67 @@ +package eu.ztsh.training.hackerrank.datastructures.stack; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("HackerRank challenges: Java Stack") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of( + "{}()", + "({()})", + "{}(", + "[]" + ), + List.of( + "true", + "true", + "false", + "true" + ) + ); + } + + @Test + public void testCase1() { + simpleAssert( + List.of( + "({}[])", + "(({()})))", + "({(){}()})()({(){}()})(){()}", + "{}()))(()()({}}{}", + "}}}}", + "))))", + "{{{", + "(((", + "[]{}(){()}((())){{{}}}{()()}{{}{}}", + "[[]][][]", + "}{" + ), + List.of( + "true", + "false", + "true", + "false", + "false", + "false", + "false", + "false", + "true", + "true", + "false" + ) + ); + } + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} From 5d8a5c9dc956cc6ebf55017b3d750b4dddbe7eb5 Mon Sep 17 00:00:00 2001 From: Piotr Dec Date: Thu, 14 Mar 2024 18:16:17 +0100 Subject: [PATCH 08/10] Work dump --- .../datastructures/dequeue/Solution.java | 65 +++++++++++++++++++ .../datastructures/dequeue/SolutionTest.java | 28 ++++++++ 2 files changed, 93 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/dequeue/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/dequeue/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/dequeue/Solution.java new file mode 100644 index 0000000..2dc02f8 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/dequeue/Solution.java @@ -0,0 +1,65 @@ +package eu.ztsh.training.hackerrank.datastructures.dequeue; + +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.Scanner; +import java.util.SortedMap; +import java.util.TreeMap; +import java.util.TreeSet; + +/** + * Java Dequeue task. + * source: https://www.hackerrank.com/challenges/java-dequeue/problem + */ +public class Solution { + + public static void main(String[] args) { + var in = new Scanner(System.in); + int n = in.nextInt(); + int m = in.nextInt(); + final Deque deque = new ArrayDeque<>(m); + var counter = new Counter(); + for (int i = 0; i < m; i++) { + var content = in.nextInt(); + deque.addLast(content); + counter.add(content); + } + int max = counter.size(); + for (int i = m; i < n; i++) { + var content = in.nextInt(); + counter.pop(deque.removeFirst()); + deque.addLast(content); + counter.add(content); + var newMax = counter.size(); + if (newMax > max) { + max = newMax; + } + } + System.out.println(max); + } + +} + +class Counter { + + public void add(int input) { + var content = map.getOrDefault(input, 0); + map.put(input, content + 1); + } + + public void pop(int input) { + var content = map.get(input); + if (content == 1) { + map.remove(input); + } else { + map.put(input, content - 1); + } + } + + public int size() { + return map.size(); + } + + private final SortedMap map = new TreeMap<>(); + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java new file mode 100644 index 0000000..5432891 --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java @@ -0,0 +1,28 @@ +package eu.ztsh.training.hackerrank.datastructures.dequeue; + +import java.util.List; +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("HackerRank challenges: Java Subarray") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of( + "6 3", + "5 3 5 2 3 2" + ), + List.of("3") + ); + } + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} \ No newline at end of file From c020c11f0c9c9760a6b3e147088774b0cd2ec2fe Mon Sep 17 00:00:00 2001 From: Piotr Dec Date: Fri, 15 Mar 2024 22:15:01 +0100 Subject: [PATCH 09/10] fix: Deque minor fix --- .../datastructures/dequeue/SolutionTest.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java index 5432891..ae89c05 100644 --- a/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/dequeue/SolutionTest.java @@ -6,7 +6,7 @@ import eu.ztsh.training.hackerrank.SolutionClassDescription; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -@DisplayName("HackerRank challenges: Java Subarray") +@DisplayName("HackerRank challenges: Java Dequeue") class SolutionTest extends HackerRankTest { @Test @@ -20,6 +20,17 @@ class SolutionTest extends HackerRankTest { ); } + @Test + public void testCase7() { + simpleAssert( + List.of( + "10 3", + "1 1 1 1 1 1 1 1 1 1" + ), + List.of("1") + ); + } + @Override protected SolutionClassDescription getSolutionClassDescription() { return new SolutionClassDescription(Solution.class); From 9bf93b9d7e897ee77353150bc87a1edde45c8140 Mon Sep 17 00:00:00 2001 From: Piotr Dec Date: Fri, 15 Mar 2024 22:36:16 +0100 Subject: [PATCH 10/10] feat: Comparator --- .../datastructures/comparator/Solution.java | 52 +++++++++++++++++++ .../comparator/SolutionTest.java | 39 ++++++++++++++ 2 files changed, 91 insertions(+) create mode 100644 src/main/java/eu/ztsh/training/hackerrank/datastructures/comparator/Solution.java create mode 100644 src/test/java/eu/ztsh/training/hackerrank/datastructures/comparator/SolutionTest.java diff --git a/src/main/java/eu/ztsh/training/hackerrank/datastructures/comparator/Solution.java b/src/main/java/eu/ztsh/training/hackerrank/datastructures/comparator/Solution.java new file mode 100644 index 0000000..77b6000 --- /dev/null +++ b/src/main/java/eu/ztsh/training/hackerrank/datastructures/comparator/Solution.java @@ -0,0 +1,52 @@ +package eu.ztsh.training.hackerrank.datastructures.comparator; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.Scanner; + +/** + * source: Java Comparator + */ + +class Checker implements Comparator { + + @Override + public int compare(Player o1, Player o2) { + var points = o2.score - o1.score; + return points != 0 ? points : o1.name.compareTo(o2.name); + } + +} + +// Hackerrank code below (slightly modified) +public class Solution { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int n = scan.nextInt(); + + Player[] player = new Player[n]; + Checker checker = new Checker(); + + for (int i = 0; i < n; i++) { + player[i] = new Player(scan.next(), scan.nextInt()); + } + scan.close(); + + Arrays.sort(player, checker); + Arrays.stream(player).forEach(value -> System.out.printf("%s %s%s", value.name, value.score, System.lineSeparator())); + } + +} + +class Player { + + String name; + int score; + + Player(String name, int score) { + this.name = name; + this.score = score; + } + +} diff --git a/src/test/java/eu/ztsh/training/hackerrank/datastructures/comparator/SolutionTest.java b/src/test/java/eu/ztsh/training/hackerrank/datastructures/comparator/SolutionTest.java new file mode 100644 index 0000000..00390fa --- /dev/null +++ b/src/test/java/eu/ztsh/training/hackerrank/datastructures/comparator/SolutionTest.java @@ -0,0 +1,39 @@ +package eu.ztsh.training.hackerrank.datastructures.comparator; + +import eu.ztsh.training.hackerrank.HackerRankTest; +import eu.ztsh.training.hackerrank.SolutionClassDescription; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.List; + +@DisplayName("HackerRank challenges: Java Comparator") +class SolutionTest extends HackerRankTest { + + @Test + public void testCase0() { + simpleAssert( + List.of( + "5", + "amy 100", + "david 100", + "heraldo 50", + "aakansha 75", + "aleksa 150" + ), + List.of( + "aleksa 150", + "amy 100", + "david 100", + "aakansha 75", + "heraldo 50" + ) + ); + } + + @Override + protected SolutionClassDescription getSolutionClassDescription() { + return new SolutionClassDescription(Solution.class); + } + +} \ No newline at end of file