repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/QueueUsingTwoStacksTest.java | src/test/java/com/thealgorithms/others/QueueUsingTwoStacksTest.java | package com.thealgorithms.others;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.EmptyStackException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/TwoPointersTest.java | src/test/java/com/thealgorithms/others/TwoPointersTest.java | package com.thealgorithms.others;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/NewManShanksPrimeTest.java | src/test/java/com/thealgorithms/others/NewManShanksPrimeTest.java | package com.thealgorithms.others;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.thealgorithms.dynamicprogramming.NewManShanksPrime;
import org.junit.jupiter.api.Test;
public class NewManShanksPrimeTest {
@Test
void testOne() {
assertTrue(NewManShanksPrime.nthManShanksPrime(1,... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/IterativeFloodFillTest.java | src/test/java/com/thealgorithms/others/IterativeFloodFillTest.java | package com.thealgorithms.others;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import org.junit.jupiter.api.Test;
class IterativeFloodFillTest {
@Test
void testForEmptyImage() {
int[][] image = {};
int[][... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/LowestBasePalindromeTest.java | src/test/java/com/thealgorithms/others/LowestBasePalindromeTest.java | package com.thealgorithms.others;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.p... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/others/cn/HammingDistanceTest.java | src/test/java/com/thealgorithms/others/cn/HammingDistanceTest.java | package com.thealgorithms.others.cn;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
public class HammingDistanceTest {
@Test
public void checkForDifferentBits() {
int answer = HammingDistance.compute("000", "011");
Assertions.assertThat(answer).isEqualTo(2);
}
... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/LongestSubstringWithoutRepeatingCharactersTest.java | src/test/java/com/thealgorithms/slidingwindow/LongestSubstringWithoutRepeatingCharactersTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the LongestSubstringWithoutRepeatingCharacters class.
*
* @author (https://github.com/Chiefpatwal)
*/
public class LongestSubstringWithoutRepeatingCharact... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/MinSumKSizeSubarrayTest.java | src/test/java/com/thealgorithms/slidingwindow/MinSumKSizeSubarrayTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the MinSumKSizeSubarray class.
*
* @author Rashi Dashore (https://github.com/rashi07dashore)
*/
class MinSumKSizeSubarrayTest {
/**
* Test for th... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/MinimumWindowSubstringTest.java | src/test/java/com/thealgorithms/slidingwindow/MinimumWindowSubstringTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Finds the minimum window substring in {@code s} that contains all characters of {@code t}.
*
* @param s The input string to search within
* @param t The string with requi... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/MaxSumKSizeSubarrayTest.java | src/test/java/com/thealgorithms/slidingwindow/MaxSumKSizeSubarrayTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the MaxSumKSizeSubarray class.
*
* @author Your Name (https://github.com/Chiefpatwal)
*/
class MaxSumKSizeSubarrayTest {
/**
* Test for the basic... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/LongestSubarrayWithSumLessOrEqualToKTest.java | src/test/java/com/thealgorithms/slidingwindow/LongestSubarrayWithSumLessOrEqualToKTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the LongestSubarrayWithSumLessOrEqualToK algorithm.
*/
public class LongestSubarrayWithSumLessOrEqualToKTest {
/**
* Tests for the longest subarray... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/MaximumSlidingWindowTest.java | src/test/java/com/thealgorithms/slidingwindow/MaximumSlidingWindowTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class MaximumSlidingWindowTest {
MaximumSlidingWindow msw;
int[] nums;
int k;
@BeforeEach
void setUp() {
... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/slidingwindow/ShortestCoprimeSegmentTest.java | src/test/java/com/thealgorithms/slidingwindow/ShortestCoprimeSegmentTest.java | package com.thealgorithms.slidingwindow;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
/**
* Unit tests for ShortestCoprimeSegment algorithm
*
* @author DomTr (<a href="https://github.com/DomTr">...</a>)
*/
public class ShortestCopri... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/TilingProblemTest.java | src/test/java/com/thealgorithms/divideandconquer/TilingProblemTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import org.junit.jupiter.api.Test;
public class TilingProblemTest {
@Test
public void testTilingSize2() {
int[][] expected = {{1, 1}, {1, 0}};
int[][] result = TilingProblem.solveTil... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/ClosestPairTest.java | src/test/java/com/thealgorithms/divideandconquer/ClosestPairTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.api.Test;
public class ClosestPairTest {
@Test
public void testBuildLocation() {
ClosestPair cp = new Closes... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArraysTest.java | src/test/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArraysTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class MedianOfT... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplicationTest.java | src/test/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplicationTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import org.junit.jupiter.api.Test;
class StrassenMatrixMultiplicationTest {
StrassenMatrixMultiplication smm = new StrassenMatrixMultiplication();
// Strassen Matrix Multiplication can only be allp... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/BinaryExponentiationTest.java | src/test/java/com/thealgorithms/divideandconquer/BinaryExponentiationTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class BinaryExponentiationTest {
@Test
public void testCalculatePower() {
assertEquals(1, BinaryExponentiation.calculatePower(1, 10000000));
asse... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/CountingInversionsTest.java | src/test/java/com/thealgorithms/divideandconquer/CountingInversionsTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class CountingInversionsTest {
@Test
public void testCountInversions() {
int[] arr = {2, 3, 8, 6, 1};
assertEquals(5, CountingInversions.countInv... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/divideandconquer/SkylineAlgorithmTest.java | src/test/java/com/thealgorithms/divideandconquer/SkylineAlgorithmTest.java | package com.thealgorithms.divideandconquer;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class SkylineAlgorithmTest {
private SkylineAlgorithm skylineAlgorithm;
@BeforeEach
pub... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/PowerSum.java | src/main/java/com/thealgorithms/backtracking/PowerSum.java | package com.thealgorithms.backtracking;
/**
* Problem Statement:
* Find the number of ways that a given integer, N, can be expressed as the sum of the Xth powers
* of unique, natural numbers.
* For example, if N=100 and X=3, we have to find all combinations of unique cubes adding up to 100.
* The only solution is... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/KnightsTour.java | src/main/java/com/thealgorithms/backtracking/KnightsTour.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* The KnightsTour class solves the Knight's Tour problem using backtracking.
*
* Problem Statement:
* Given an N*N board with a knight placed on the first block, the knight must
* move acco... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/ArrayCombination.java | src/main/java/com/thealgorithms/backtracking/ArrayCombination.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.List;
/**
* This class provides methods to find all combinations of integers from 0 to n-1
* of a specified length k using backtracking.
*/
public final class ArrayCombination {
private ArrayCombination() {
}
/**
... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/MColoring.java | src/main/java/com/thealgorithms/backtracking/MColoring.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
/**
* Node class represents a graph node. Each node is associated with a color
* (initially 1) and contains a set of edges representing its adjacen... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/FloodFill.java | src/main/java/com/thealgorithms/backtracking/FloodFill.java | package com.thealgorithms.backtracking;
/**
* Java program for Flood fill algorithm.
* @author Akshay Dubey (<a href="https://github.com/itsAkshayDubey">Git-Akshay Dubey</a>)
*/
public final class FloodFill {
private FloodFill() {
}
/**
* Get the color at the given coordinates of a 2D image
*... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/ParenthesesGenerator.java | src/main/java/com/thealgorithms/backtracking/ParenthesesGenerator.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.List;
/**
* This class generates all valid combinations of parentheses for a given number of pairs using backtracking.
*/
public final class ParenthesesGenerator {
private ParenthesesGenerator() {
}
/**
* Generate... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/Combination.java | src/main/java/com/thealgorithms/backtracking/Combination.java | package com.thealgorithms.backtracking;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.TreeSet;
/**
* Finds all combinations of a given array using backtracking algorithm * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Pia... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/SudokuSolver.java | src/main/java/com/thealgorithms/backtracking/SudokuSolver.java | package com.thealgorithms.backtracking;
/**
* Sudoku Solver using Backtracking Algorithm
* Solves a 9x9 Sudoku puzzle by filling empty cells with valid digits (1-9)
*
* @author Navadeep0007
*/
public final class SudokuSolver {
private static final int GRID_SIZE = 9;
private static final int SUBGRID_SIZE ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java | src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.List;
/**
* Class generates all subsequences for a given list of elements using backtracking
*/
public final class SubsequenceFinder {
private SubsequenceFinder() {
}
/**
* Find all subsequences of given list usin... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/Permutation.java | src/main/java/com/thealgorithms/backtracking/Permutation.java | package com.thealgorithms.backtracking;
import java.util.LinkedList;
import java.util.List;
/**
* Finds all permutations of given array
* @author Alan Piao (<a href="https://github.com/cpiao3">Git-Alan Piao</a>)
*/
public final class Permutation {
private Permutation() {
}
/**
* Find all permutat... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java | src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* A class to solve a crossword puzzle using backtracking.
* Example:
* Input:
* puzzle = {
* {' ', ' ', ' '},
* {' ', ' ', ' '},
* {' ', ' ', ' '}
* }
* words = List.o... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/AllPathsFromSourceToTarget.java | src/main/java/com/thealgorithms/backtracking/AllPathsFromSourceToTarget.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.List;
/**
* Program description - To find all possible paths from source to destination
* <a href="https://en.wikipedia.org/wiki/Shortest_path_problem">Wikipedia</a>
*
* @author <a href="https://github.com/siddhant2002">Siddhant ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/WordPatternMatcher.java | src/main/java/com/thealgorithms/backtracking/WordPatternMatcher.java | package com.thealgorithms.backtracking;
import java.util.HashMap;
import java.util.Map;
/**
* Class to determine if a pattern matches a string using backtracking.
*
* Example:
* Pattern: "abab"
* Input String: "JavaPythonJavaPython"
* Output: true
*
* Pattern: "aaaa"
* Input String: "JavaJavaJavaJava"
* Out... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/UniquePermutation.java | src/main/java/com/thealgorithms/backtracking/UniquePermutation.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Generates all UNIQUE permutations of a string, even when duplicate characters exist.
*
* Example:
* Input: "AAB"
* Output: ["AAB", "ABA", "BAA"]
*
* Time Complexity: O(n! * n)
*/
publi... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/NQueens.java | src/main/java/com/thealgorithms/backtracking/NQueens.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.List;
/**
* Problem statement: Given a N x N chess board. Return all arrangements in
* which N queens can be placed on the board such no two queens attack each
* other. Ex. N = 6 Solution= There are 4 possible ways Arrangement: 1 ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/WordSearch.java | src/main/java/com/thealgorithms/backtracking/WordSearch.java | package com.thealgorithms.backtracking;
/**
* Word Search Problem
*
* This class solves the word search problem where given an m x n grid of characters (board)
* and a target word, the task is to check if the word exists in the grid.
* The word can be constructed from sequentially adjacent cells (horizontally or ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/CombinationSum.java | src/main/java/com/thealgorithms/backtracking/CombinationSum.java | package com.thealgorithms.backtracking;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/** Backtracking: pick/not-pick with reuse of candidates. */
public final class CombinationSum {
private CombinationSum() {
throw new UnsupportedOperationException("Utility class");
}
... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/backtracking/MazeRecursion.java | src/main/java/com/thealgorithms/backtracking/MazeRecursion.java | package com.thealgorithms.backtracking;
/**
* This class contains methods to solve a maze using recursive backtracking.
* The maze is represented as a 2D array where walls, paths, and visited/dead
* ends are marked with different integers.
*
* The goal is to find a path from a starting position to the target posi... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/DampedOscillator.java | src/main/java/com/thealgorithms/physics/DampedOscillator.java | package com.thealgorithms.physics;
/**
* Models a damped harmonic oscillator, capturing the behavior of a mass-spring-damper system.
*
* <p>The system is defined by the second-order differential equation:
* x'' + 2 * gamma * x' + omega₀² * x = 0
* where:
* <ul>
* <li><b>omega₀</b> is the natural (undamped... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/GroundToGroundProjectileMotion.java | src/main/java/com/thealgorithms/physics/GroundToGroundProjectileMotion.java | package com.thealgorithms.physics;
/**
* Ground to ground projectile motion calculator
*
* Ground to ground projectile motion is when a projectile's trajectory
* starts at the ground, reaches the apex, then falls back on the ground.
*
* @author [Yash Rajput](https://github.com/the-yash-rajput)
*/
public final c... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/ThinLens.java | src/main/java/com/thealgorithms/physics/ThinLens.java | package com.thealgorithms.physics;
/**
* Implements the Thin Lens Formula used in ray optics:
*
* <pre>
* 1/f = 1/v + 1/u
* </pre>
*
* where:
* <ul>
* <li>f = focal length</li>
* <li>u = object distance</li>
* <li>v = image distance</li>
* </ul>
*
* Uses the Cartesian sign convention.
*
* @se... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/SimplePendulumRK4.java | src/main/java/com/thealgorithms/physics/SimplePendulumRK4.java | package com.thealgorithms.physics;
/**
* Simulates a simple pendulum using the Runge-Kutta 4th order method.
* The pendulum is modeled with the nonlinear differential equation.
*
* @author [Yash Rajput](https://github.com/the-yash-rajput)
*/
public final class SimplePendulumRK4 {
private SimplePendulumRK4() ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/Kinematics.java | src/main/java/com/thealgorithms/physics/Kinematics.java | package com.thealgorithms.physics;
/**
* Implements the fundamental "SUVAT" equations for motion
* under constant acceleration.
*
* @author [Priyanshu Kumar Singh](https://github.com/Priyanshu1303d)
* @see <a href="https://en.wikipedia.org/wiki/Equations_of_motion#Uniform_acceleration">Wikipedia</a>
*/
public fin... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/Gravitation.java | src/main/java/com/thealgorithms/physics/Gravitation.java | package com.thealgorithms.physics;
/**
* Implements Newton's Law of Universal Gravitation.
* Provides simple static methods to calculate gravitational force and circular orbit velocity.
*
* @author [Priyanshu Kumar Singh](https://github.com/Priyanshu1303d)
* @see <a href="https://en.wikipedia.org/wiki/Newton%27s_... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/SnellLaw.java | src/main/java/com/thealgorithms/physics/SnellLaw.java | package com.thealgorithms.physics;
/**
* Calculates refraction angle using Snell's Law:
* n1 * sin(theta1) = n2 * sin(theta2)
* @see <a href="https://en.wikipedia.org/wiki/Snell%27s_law">Snell's Law</a>
*/
public final class SnellLaw {
private SnellLaw() {
throw new AssertionError("No instances.");
... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/ElasticCollision2D.java | src/main/java/com/thealgorithms/physics/ElasticCollision2D.java | package com.thealgorithms.physics;
/**
* 2D Elastic collision between two circular bodies
* Based on principles of conservation of momentum and kinetic energy.
*
* @author [Yash Rajput](https://github.com/the-yash-rajput)
*/
public final class ElasticCollision2D {
private ElasticCollision2D() {
throw... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/ProjectileMotion.java | src/main/java/com/thealgorithms/physics/ProjectileMotion.java | package com.thealgorithms.physics;
/**
*
* This implementation calculates the flight path of a projectile launched from any INITIAL HEIGHT.
* It is a more flexible version of the ground-to-ground model.
*
* @see <a href="https://en.wikipedia.org/wiki/Projectile_motion">Wikipedia - Projectile Motion</a>
* @author... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/physics/CoulombsLaw.java | src/main/java/com/thealgorithms/physics/CoulombsLaw.java | package com.thealgorithms.physics;
/**
* Implements Coulomb's Law for electrostatics.
* Provides simple static methods to calculate electrostatic force and circular orbit velocity.
*
* @author [Priyanshu Singh](https://github.com/Priyanshu1303d)
* @see <a href="https://en.wikipedia.org/wiki/Coulomb%27s_law">Wikip... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java | src/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java | package com.thealgorithms.misc;
import java.util.Stack;
/**
* A simple way of knowing if a singly linked list is palindrome is to push all
* the values into a Stack and then compare the list to popped vales from the
* Stack.
*
* See more:
* https://www.geeksforgeeks.org/function-to-check-if-a-singly-linked-list... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArrayInteger.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArrayInteger.java | package com.thealgorithms.misc;
public final class MedianOfRunningArrayInteger extends MedianOfRunningArray<Integer> {
@Override
public Integer calculateAverage(final Integer a, final Integer b) {
return (a + b) / 2;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/ThreeSumProblem.java | src/main/java/com/thealgorithms/misc/ThreeSumProblem.java | package com.thealgorithms.misc;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class ThreeSumProblem {
public List<List<Integer>> bruteForce(... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/RangeInSortedArray.java | src/main/java/com/thealgorithms/misc/RangeInSortedArray.java | package com.thealgorithms.misc;
/**
* Utility class for operations to find the range of occurrences of a key
* in a sorted (non-decreasing) array, and to count elements less than or equal to a given key.
*/
public final class RangeInSortedArray {
private RangeInSortedArray() {
}
/**
* Finds the f... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArrayByte.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArrayByte.java | package com.thealgorithms.misc;
public final class MedianOfRunningArrayByte extends MedianOfRunningArray<Byte> {
@Override
public Byte calculateAverage(final Byte a, final Byte b) {
return (byte) ((a + b) / 2);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MapReduce.java | src/main/java/com/thealgorithms/misc/MapReduce.java | package com.thealgorithms.misc;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* MapReduce is a programming model for processing and generating large data sets
* using a parallel, distr... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArray.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArray.java | package com.thealgorithms.misc;
import java.util.Collections;
import java.util.PriorityQueue;
/**
* A generic abstract class to compute the median of a dynamically growing stream of numbers.
*
* @param <T> the number type, must extend Number and be Comparable
*
* Usage:
* Extend this class and implement {@code ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/PalindromePrime.java | src/main/java/com/thealgorithms/misc/PalindromePrime.java | package com.thealgorithms.misc;
import java.util.ArrayList;
import java.util.List;
public final class PalindromePrime {
private PalindromePrime() {
}
public static boolean prime(int num) {
if (num < 2) {
return false; // Handle edge case for numbers < 2
}
if (num == 2)... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/ShuffleArray.java | src/main/java/com/thealgorithms/misc/ShuffleArray.java | package com.thealgorithms.misc;
import java.util.Random;
/**
* The Fisher-Yates (Knuth) Shuffle algorithm randomly permutes an array's
* elements, ensuring each permutation is equally likely.
*
* <p>
* Worst-case performance O(n)
* Best-case performance O(n)
* Average performance O(n)
* Worst-case space compl... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/TwoSumProblem.java | src/main/java/com/thealgorithms/misc/TwoSumProblem.java | package com.thealgorithms.misc;
import java.util.HashMap;
import java.util.Optional;
import org.apache.commons.lang3.tuple.Pair;
public final class TwoSumProblem {
private TwoSumProblem() {
}
/**
* The function "twoSum" takes an array of integers and a target integer as input, and returns an
* ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArrayFloat.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArrayFloat.java | package com.thealgorithms.misc;
public final class MedianOfRunningArrayFloat extends MedianOfRunningArray<Float> {
@Override
public Float calculateAverage(final Float a, final Float b) {
return (a + b) / 2.0f;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArrayDouble.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArrayDouble.java | package com.thealgorithms.misc;
public final class MedianOfRunningArrayDouble extends MedianOfRunningArray<Double> {
@Override
public Double calculateAverage(final Double a, final Double b) {
return (a + b) / 2.0d;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/Sparsity.java | src/main/java/com/thealgorithms/misc/Sparsity.java | package com.thealgorithms.misc;
/**
* Utility class for calculating the sparsity of a matrix.
* A matrix is considered sparse if a large proportion of its elements are zero.
* Typically, if more than 2/3 of the elements are zero, the matrix is considered sparse.
*
* Sparsity is defined as:
* sparsity = (number o... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/ColorContrastRatio.java | src/main/java/com/thealgorithms/misc/ColorContrastRatio.java | package com.thealgorithms.misc;
import java.awt.Color;
/**
* @brief A Java implementation of the official W3 documented procedure to
* calculate contrast ratio between colors on the web. This is used to calculate
* the readability of a foreground color on top of a background color.
* @since 2020-10-15
* @see <a ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/misc/MedianOfRunningArrayLong.java | src/main/java/com/thealgorithms/misc/MedianOfRunningArrayLong.java | package com.thealgorithms.misc;
public final class MedianOfRunningArrayLong extends MedianOfRunningArray<Long> {
@Override
public Long calculateAverage(final Long a, final Long b) {
return (a + b) / 2L;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java | src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java | package com.thealgorithms.scheduling;
import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
/**
* Preemptive Priority Scheduling Algorithm
*
* @author [Bama Charan Chhan... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/LotteryScheduling.java | src/main/java/com/thealgorithms/scheduling/LotteryScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* The LotteryScheduling class implements the Lottery Scheduling algorithm, which is
* a probabilistic CPU scheduling algorithm. Processes are assigned tickets, and
* the CPU is allocated to a rando... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/ProportionalFairScheduling.java | src/main/java/com/thealgorithms/scheduling/ProportionalFairScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.List;
/**
* ProportionalFairScheduling allocates resources to processes based on their
* proportional weight or importance. It aims to balance fairness with
* priority, ensuring that higher-weight processes receive a larger share of... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/SelfAdjustingScheduling.java | src/main/java/com/thealgorithms/scheduling/SelfAdjustingScheduling.java | package com.thealgorithms.scheduling;
import java.util.PriorityQueue;
/**
* SelfAdjustingScheduling is an algorithm where tasks dynamically adjust
* their priority based on real-time feedback, such as wait time and CPU usage.
* Tasks that wait longer will automatically increase their priority,
* allowing for bett... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java | src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java | package com.thealgorithms.scheduling;
import java.util.Arrays;
import java.util.Comparator;
/**
* The {@code HighestResponseRatioNextScheduling} class implements the
* Highest Response Ratio Next (HRRN) scheduling algorithm.
* HRRN is a non-preemptive scheduling algorithm that selects the process with
* the highe... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/JobSchedulingWithDeadline.java | src/main/java/com/thealgorithms/scheduling/JobSchedulingWithDeadline.java | package com.thealgorithms.scheduling;
import java.util.Arrays;
import java.util.Comparator;
/**
* A class that implements a job scheduling algorithm to maximize profit
* while adhering to job deadlines and arrival times.
*
* This class provides functionality to schedule jobs based on their profit,
* arrival time... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/EDFScheduling.java | src/main/java/com/thealgorithms/scheduling/EDFScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* The Earliest Deadline First (EDF) Scheduling class implements a dynamic scheduling algorithm.
* It assigns the CPU to processes with the earliest deadlines, ensuring that deadlines are met if ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/SlackTimeScheduling.java | src/main/java/com/thealgorithms/scheduling/SlackTimeScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* SlackTimeScheduling is an algorithm that prioritizes tasks based on their
* slack time, which is defined as the difference between the task's deadline
* and the time required to execute it. T... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/FairShareScheduling.java | src/main/java/com/thealgorithms/scheduling/FairShareScheduling.java | package com.thealgorithms.scheduling;
import java.util.HashMap;
import java.util.Map;
/**
* FairShareScheduling allocates CPU resources equally among users or groups
* instead of individual tasks. Each group gets a proportional share,
* preventing resource hogging by a single user's processes.
*
* Use Case: Mult... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/MultiAgentScheduling.java | src/main/java/com/thealgorithms/scheduling/MultiAgentScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* MultiAgentScheduling assigns tasks to different autonomous agents
* who independently decide the execution order of their assigned tasks.
* The focus is on collaboration be... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/MLFQScheduler.java | src/main/java/com/thealgorithms/scheduling/MLFQScheduler.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* The Multi-Level Feedback Queue (MLFQ) Scheduler class.
* This class simulates scheduling using multiple queues, where processes move
* between queues depending on thei... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/RandomScheduling.java | src/main/java/com/thealgorithms/scheduling/RandomScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* RandomScheduling is an algorithm that assigns tasks in a random order.
* It doesn't consider priority, deadlines, or burst times, making ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/FCFSScheduling.java | src/main/java/com/thealgorithms/scheduling/FCFSScheduling.java | package com.thealgorithms.scheduling;
import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.List;
/**
* Non-pre-emptive First Come First Serve scheduling. This can be understood here -
* https://www.scaler.com/topics/first-come-first-serve/
*/
public class FCFSScheduling {
private List<P... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/NonPreemptivePriorityScheduling.java | src/main/java/com/thealgorithms/scheduling/NonPreemptivePriorityScheduling.java | package com.thealgorithms.scheduling;
import java.util.Collections;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
/**
* This class implements the Non-Preemptive Priority Scheduling algorithm.
* Processes are executed in order of their priority. The process with the
* highest ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/GangScheduling.java | src/main/java/com/thealgorithms/scheduling/GangScheduling.java | package com.thealgorithms.scheduling;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* GangScheduling groups related tasks (gangs) to run simultaneously on multiple processors.
* All tasks in a gang are executed together or not at all.
*
* Use Case: Parallel... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/SJFScheduling.java | src/main/java/com/thealgorithms/scheduling/SJFScheduling.java | package com.thealgorithms.scheduling;
import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
/**
* Shortest Job First (SJF) Scheduling Algorithm:
* Executes processes with the ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/AgingScheduling.java | src/main/java/com/thealgorithms/scheduling/AgingScheduling.java | package com.thealgorithms.scheduling;
import java.util.LinkedList;
import java.util.Queue;
/**
* AgingScheduling is an algorithm designed to prevent starvation
* by gradually increasing the priority of waiting tasks.
* The longer a process waits, the higher its priority becomes.
*
* Use Case: Useful in systems w... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/RRScheduling.java | src/main/java/com/thealgorithms/scheduling/RRScheduling.java | package com.thealgorithms.scheduling;
import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @author Md Asif Joardar
* The Round-robin scheduling algorithm is a kind of preemptive First come, First Serve C... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/SRTFScheduling.java | src/main/java/com/thealgorithms/scheduling/SRTFScheduling.java | package com.thealgorithms.scheduling;
import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.ArrayList;
import java.util.List;
/**
* Implementation of Shortest Remaining Time First Scheduling Algorithm.
* In the SRTF scheduling algorithm, the process with the smallest amount of time remaining u... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/diskscheduling/LookScheduling.java | src/main/java/com/thealgorithms/scheduling/diskscheduling/LookScheduling.java | package com.thealgorithms.scheduling.diskscheduling;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* https://en.wikipedia.org/wiki/LOOK_algorithm
* Look Scheduling algorithm implementation.
* The Look algorithm moves the disk arm to the closest request in the current directio... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/diskscheduling/CircularScanScheduling.java | src/main/java/com/thealgorithms/scheduling/diskscheduling/CircularScanScheduling.java | package com.thealgorithms.scheduling.diskscheduling;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Circular Scan Scheduling (C-SCAN) is a disk scheduling algorithm that
* works by moving the disk arm in one direction to service requests until
* it reaches the end of the dis... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/diskscheduling/ScanScheduling.java | src/main/java/com/thealgorithms/scheduling/diskscheduling/ScanScheduling.java | package com.thealgorithms.scheduling.diskscheduling;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* https://en.wikipedia.org/wiki/Elevator_algorithm
* SCAN Scheduling algorithm implementation.
* The SCAN algorithm moves the disk arm towards one end of the disk, servicing all... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/diskscheduling/CircularLookScheduling.java | src/main/java/com/thealgorithms/scheduling/diskscheduling/CircularLookScheduling.java | package com.thealgorithms.scheduling.diskscheduling;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Circular Look Scheduling (C-LOOK) is a disk scheduling algorithm similar to
* the C-SCAN algorithm but with a key difference. In C-LOOK, the disk arm also
* moves in one direc... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/scheduling/diskscheduling/SSFScheduling.java | src/main/java/com/thealgorithms/scheduling/diskscheduling/SSFScheduling.java | package com.thealgorithms.scheduling.diskscheduling;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
*https://en.wikipedia.org/wiki/Shortest_seek_first
* Shortest Seek First (SFF) Scheduling algorithm implementation.
* The SFF algorithm selects the next request to be serviced ba... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/GreatestElementConstantTime.java | src/main/java/com/thealgorithms/stacks/GreatestElementConstantTime.java | package com.thealgorithms.stacks;
import java.util.NoSuchElementException;
import java.util.Stack;
/**
* A class that implements a stack that gives the maximum element in O(1) time.
* The mainStack is used to store the all the elements of the stack
* While the maxStack stores the maximum elements
* When we want t... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/SmallestElementConstantTime.java | src/main/java/com/thealgorithms/stacks/SmallestElementConstantTime.java | package com.thealgorithms.stacks;
import java.util.NoSuchElementException;
import java.util.Stack;
/**
* A class that implements a stack that gives the minimum element in O(1) time.
* The mainStack is used to store the all the elements of the stack
* While the minStack stores the minimum elements
* When we want t... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/DuplicateBrackets.java | src/main/java/com/thealgorithms/stacks/DuplicateBrackets.java | package com.thealgorithms.stacks;
import java.util.Stack;
/**
* Class for detecting unnecessary or redundant brackets in a mathematical expression.
* Assumes the expression is balanced (i.e., all opening brackets have matching closing brackets).
*/
public final class DuplicateBrackets {
private DuplicateBracke... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/NextSmallerElement.java | src/main/java/com/thealgorithms/stacks/NextSmallerElement.java | package com.thealgorithms.stacks;
import java.util.Arrays;
import java.util.Stack;
/**
* Utility class to find the next smaller element for each element in a given integer array.
*
* <p>The next smaller element for an element x is the first smaller element on the left side of x in the array.
* If no such element ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java | src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java | package com.thealgorithms.stacks;
import java.util.Stack;
/**
* Utility class for converting a non-negative decimal (base-10) integer
* to its representation in another radix (base) between 2 and 16, inclusive.
*
* <p>This class uses a stack-based approach to reverse the digits obtained from
* successive divisio... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/PostfixEvaluator.java | src/main/java/com/thealgorithms/stacks/PostfixEvaluator.java | package com.thealgorithms.stacks;
import java.util.Set;
import java.util.Stack;
/**
* Evaluate a postfix (Reverse Polish) expression using a stack.
*
* <p>Example: Expression "5 6 + 2 *" results in 22.
* <p>Applications: Used in calculators and expression evaluation in compilers.
*
* @author Hardvan
*/
public ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/PalindromeWithStack.java | src/main/java/com/thealgorithms/stacks/PalindromeWithStack.java | package com.thealgorithms.stacks;
import java.util.LinkedList;
/**
* A class that implements a palindrome checker using a stack.
* The stack is used to store the characters of the string,
* which we will pop one-by-one to create the string in reverse.
*
* Reference: https://www.geeksforgeeks.org/check-whether-th... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/StackUsingTwoQueues.java | src/main/java/com/thealgorithms/stacks/StackUsingTwoQueues.java | package com.thealgorithms.stacks;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
/**
* A class that implements a stack using two queues.
* This approach ensures that the stack's LIFO (Last In, First Out) behavior
* is maintained by utilizing two queues for storage.
*... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/CelebrityFinder.java | src/main/java/com/thealgorithms/stacks/CelebrityFinder.java | package com.thealgorithms.stacks;
import java.util.Stack;
/**
* Solves the celebrity problem using a stack-based algorithm.
*
* <p>Celebrity is someone known by everyone but doesn't know anyone else.
* <p>Applications: Graph theory and social network analysis.
*
* @author Hardvan
*/
public final class Celebrit... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/PostfixToInfix.java | src/main/java/com/thealgorithms/stacks/PostfixToInfix.java | package com.thealgorithms.stacks;
import java.util.Stack;
/**
* Postfix to Infix implementation via Stack
*
* Function: String getPostfixToInfix(String postfix)
* Returns the Infix Expression for the given postfix parameter.
*
* Avoid using parentheses/brackets/braces for the postfix string.
* Postfix Expressi... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/PrefixToInfix.java | src/main/java/com/thealgorithms/stacks/PrefixToInfix.java | package com.thealgorithms.stacks;
import java.util.Stack;
/**
* Converts a prefix expression to an infix expression using a stack.
*
* The input prefix expression should consist of
* valid operands (letters or digits) and operators (+, -, *, /, ^).
* Parentheses are not required in the prefix string.
*/
public ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/MinStackUsingSingleStack.java | src/main/java/com/thealgorithms/stacks/MinStackUsingSingleStack.java | package com.thealgorithms.stacks;
import java.util.EmptyStackException;
import java.util.Stack;
/**
* Min-Stack implementation using a single stack.
*
* This stack supports push, pop, and retrieving the minimum element
* in constant time (O(1)) using a modified approach where the stack
* stores both the element ... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/main/java/com/thealgorithms/stacks/ValidParentheses.java | src/main/java/com/thealgorithms/stacks/ValidParentheses.java | package com.thealgorithms.stacks;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* Valid Parentheses Problem
*
* Given a string containing just the characters '(', ')', '{', '}', '[' and ']',
* determine if the input string is valid.
*
* An input string is valid if:
* 1. Open brack... | java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.