text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>/**
* Solve a set of congruence equations using the Chinese Remainder Theorem (CRT).
*
* Given a system of simultaneous congruences:
*
* x ≡ a_0 (mod m_0)
* x ≡ a_1 (mod m_1)
* ...
* x ≡ a_{n-1} (mod m_{n-1})
*
* where all moduli m_i are pairwise coprime (gcd(m_i, m_j) = 1 for i ≠ j), th... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Generates a compressed prime sieve using bit manipulation. Each bit represents whether an odd
* number is prime or not. Even numbers are omitted (except 2, handled as a special case), so each
* long covers a range of 128 numbers.
*
* <p>Time: ~O(n log(log(n)))
*
* <p>Space: O(n / 128) longs
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Computes Euler's totient function phi(n), which counts the number of integers in [1, n] that are
* relatively prime to n.
*
* <p>Uses trial division to find prime factors and applies the product formula:
* phi(n) = n * product of (1 - 1/p) for each distinct prime factor p of n.
*
* <p>Time: O... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Extended Euclidean Algorithm. Given two integers a and b, computes gcd(a, b) and finds integers x
* and y such that ax + by = gcd(a, b). Useful for finding modular inverses and solving linear
* Diophantine equations.
*
* <p>Time: ~O(log(a + b))
*
* @author William Fiset, william.alexandre.fis... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* This snippet multiplies 2 polynomials with possibly negative coefficients very efficiently using
* the Fast Fourier Transform. NOTE: This code only works for polynomials with coefficients in the
* range of a signed integer.
*
* <p>Time Complexity: O( nlogn )
*
* @author David Brink
*/
packag... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* This snippet multiplies 2 complex polynomials very efficiently using the Fast Fourier Transform.
*
* <p>Time Complexity: O(nlogn)
*/
package com.williamfiset.algorithms.math;
public class FastFourierTransformComplexNumbers {
public static Complex[] fft(Complex[] x) {
int n = x.length;
... | fim | williamfiset/algorithms | java |
<|fim_suffix|>(0, -5)); // 5
System.out.println(gcd(0, 0)); // 0
}
}
<|fim_prefix|>/**
* Computes the Greatest Common Divisor (GCD) of two numbers using the Euclidean algorithm.
*
* <p>Time: ~O(log(a + b))
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.m... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Computes the Least Common Multiple (LCM) of two numbers using the relation LCM(a, b) = |a /
* gcd(a, b) * b|.
*
* <p>Time: ~O(log(a + b))
*
* @author William F<|fim_suffix|>common multiple of a and b. The result is always non-negative. */
public static long lcm(long a, long b) {
return M... | fim | williamfiset/algorithms | java |
/**
* Computes modular exponentiation: a^n mod m.
*
* Supports negative exponents via modular inverse (requires gcd(a, m) = 1) and negative bases.
* Uses overflow-safe modular multiplication to handle the full range of long values.
*
* Time Complexity: O(log(n))
*
* @author William Fiset, william.alexandre.fise... | fim | williamfiset/algorithms | java |
<|fim_suffix|>gcd(4, 18) != 1, so no inverse exists.
System.out.println(modInv(4, 18));
}
}
<|fim_prefix|>/**
* Computes the modular inverse of a number using the Extended Euclidean Algorithm.
*
* <p>The modular inverse of 'a' mod 'm' is a value x such that a*x ≡ 1 (mod m). It exists if and
* only if gcd(a, m... | fim | williamfiset/algorithms | java |
<|fim_suffix|> if (n < 2)
return false;
if (n == 2 || n == 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
long limit = (long) Math.sqrt(n);
for (long i = 5; i <= limit; i += 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
/**
... | fim | williamfiset/algorithms | java |
<|fim_suffix|>e static boolean isPrime(long n) {
if (n < 2)
return false;
if (n < 4)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
// Write n-1 as 2^r * d
long d = n - 1;
int r = Long.numberOfTrailingZeros(d);
d >>= r;
for (long a : new long[]{2, 3, 5, 7, 1... | fim | williamfiset/algorithms | java |
/**
* Test to see whether two numbers are relatively prime (coprime)
*
* <p>Time Complexity: O(log(a+b))
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.math;
public class RelativelyPrime {
// Find the greatest common factor between two numbers
private sta... | fim | williamfiset/algorithms | java |
<|fim_suffix|>limit) {
if (limit <= 2) return new int[0];
// Find an upper bound on the number of prime numbers up to our limit.
// https://en.wikipedia.org/wiki/Prime-counting_function#Inequalities
final int numPrimes = (int) (1.25506 * limit / Math.log((double) limit));
int[] primes = new int[nu... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Fundamental bit manipulation operations you must know Time Complexity: O(1)
*
* @author Micah Stairs
*/
package com.wil<|fim_suffix|> public static int toggleBit(int set, int i) {
return set ^ (1 << i);
}
// Returns a number with the first n bits set to 1
public static int setAll(int... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Here we present two methods (recursive and iterative) of generating all the combinations of a set
* by choosing only r of n elements.
*
* <p>Time Complexity: O( n choose r )
*
* @author William Fiset, Micah Stairs
*/
package com.williamfiset.algorithms.other;
public class Combinations {
/... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Here I show how you can generate all the combinations of a sequence of size r which are repeated
* at most k times.
*
* <p>Time Complexity: O(n+r-1 choose r) = O((n+r-1)!/(r!(n-1)<|fim_suffix|>n we're at in the sequence
* @param r - The number of elements we're choosing
* @param k - The ma... | fim | williamfiset/algorithms | java |
<|fim_suffix|>]
// [D, B, C, A]
// [D, C, A, B]
// [D, C, B, A]
}
}
<|fim_prefix|>/**
* Here we present two methods (recursive and iterative) of generating all the permutations of a
* list of elements.
*
* <p>Time Complexity: O(n!)
*
* @author William Fiset, Micah Stairs
*/
package com.williamfise... | fim | williamfiset/algorithms | java |
<|fim_suffix|>ntln("\nRecursive method:");
for (List<Integer> subset : powerSetRecursive(set))
System.out.println(subset);
}
}
<|fim_prefix|>/**
* Generates the power set of a set, which is the set of all subsets.
*
* Two approaches are provided: an iterative method using binary representation of numbers... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* This file contain an implementation of the maximum sliding window problem. This code has been
* tes<|fim_suffix|>on();
this.values = values;
N = values.length;
}
// Advances the front of the window by one unit
public void advance() {
// Remove all the worse values in the back o... | fim | williamfiset/algorithms | java |
<|fim_suffix|>id main(String[] args) {
int[] values = {1, 2, 3, 4, 5, 6, 7, 8, 9};
SquareRootDecomposition range = new SquareRootDecomposition(values);
// Prints: The sum from [0,8] is: 45
System.out.printf("The sum from [%d,%d] is: %d\n", 0, 8, range.query(0, 8));
// Prints: The sum from [2,2] i... | fim | williamfiset/algorithms | java |
<|fim_suffix|>1, 2, 3]
// [1, 2, 4]
// [1, 3, 3]
// [1, 3, 4]
// [1, 4, 4]
// [2, 2, 2]
// [2, 2, 3]
// [2, 2, 4]
// [2, 3, 3]
// [2, 3, 4]
// [2, 4, 4]
// [3, 3, 4]
// [3, 4, 4]
}
}
<|fim_prefix|>/**
* This file shows you how to generate all the unique combinations of... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* If ever you need to do a binary search on discrete values you should use Java's binary search:
* java.util.Arrays.binarySearch(int[] ar, int key) However, in the event that you need to do a
* binary search on the real numbers you can resort to this implementation.
*
* <p>Time Complexity: O(log(... | fim | williamfiset/algorithms | java |
<|fim_suffix|> int lo = 0, mid = 0, hi = nums.length - 1;
while (nums[lo] <= val && nums[hi] >= val) {
mid = lo + ((val - nums[lo]) * (hi - lo)) / (nums[hi] - nums[lo]);
if (nums[mid] < val) {
lo = mid + 1;
} else if (nums[mid] > val) {
hi = mid - 1;
} else return mid;
}... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Ternary search is similar to binary search except that it works on a function which decreases and
* then increases. This implementation of ternary search returns the input value corresponding with
* the minimum output value of the function you're searching on.
*
* <p>Time Complexity: O(log(high... | fim | williamfiset/algorithms | java |
<|fim_suffix|>{
lo = mid1;
hi = mid2;
} else if (res1 > res2) lo = mid1;
else hi = mid2;
}
return f(lo);
}
public static void main(String[] args) {
int lo = 0;
int hi = function.length - 1;
// Use ternary search to find the minimum value on the
// whole interva... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Bubble sort implementation
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.sorting;
public class BubbleSort implements InplaceSort {
@Override
public void sort(int[] values) {
BubbleSort.bubbleSort(values);
}
// Sort the array us... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Bucket sort implementation
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.sorting;
import java.util.*;
public class BucketSort implements InplaceSort {
@Override
public void sort(int[] values) {
int minValue = Integer.MAX_VALUE;
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* An implementation of counting sort!
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.sorting;
public class CountingSort implements InplaceSort {
@Override
public void sort(int[] values) {
int minValue = Integer.MAX_VALUE;
int maxVa... | fim | williamfiset/algorithms | java |
<|fim_suffix|>t[] ar) {
if (ar == null)
return;
int n = ar.length;
// Build max-heap from the array bottom-up in O(n).
for (int i = n / 2 - 1; i >= 0; i--)
sink(ar, n, i);
// Extract elements one by one: move the root (max element) to the end of the unsorted
// region, shrink the h... | fim | williamfiset/algorithms | java |
<|fim_prefix|>pa<|fim_suffix|>terface amongst sorting algorithms which
public interface InplaceSort {
public void sort(int[] values);
}
<|fim_middle|>ckage com.williamfiset.algorithms.sorting;
// A shared in<|endoftext|> | fim | williamfiset/algorithms | java |
<|fim_suffix|> return;
}
for (int i = 1; i < ar.length; i++) {
for (int j = i; j > 0 && ar[j] < ar[j - 1]; j--) {
swap(ar, j - 1, j);
}
}
}
private static void swap(int[] ar, int i, int j) {
int tmp = ar[i];
ar[i] = ar[j];
ar[j] = tmp;
}
public static void main(Str... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Mergesort implementation
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.sorting;
import java.util.Arrays;
// Mergesort implements InplaceSort for ease of testings, but in reality
// it is not really a good fit for an inplace sorting algorith... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.sorting;
public class QuickSelect {
public Integer quickSelect(int[] ar, int k) {
if (ar == null) return null;
if (k > ar.length) return null;
if (k < 1) return null;
return quickSelect(ar, k, 0, ar.length - 1);
}
// Sort interval [lo, hi] inpla... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Quicksort implementation using Hoare partitioning
*
* @author William Fis<|fim_suffix|>Sort();
int[] array = {10, 4, 6, 4, 8, -13, 2, 3};
sorter.sort(array);
// Prints:
// [-13, 2, 3, 4, 4, 6, 8, 10]
System.out.println(java.util.Arrays.toString(array));
}
}
<|fim_middle|>et,... | fim | williamfiset/algorithms | java |
<|fim_suffix|>ew QuickSort3();
int[] array = {10, 4, 6, 4, 8, -13, 2, 3};
sorter.sort(array);
// Prints:
// [-13, 2, 3, 4, 4, 6, 8, 10]
System.out.println(java.util.Arrays.toString(array));
}
}
<|fim_prefix|>/**
* QuickSort3 or Dutch National Flag algorithm is similar to the QuickSort algorithm b... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* An implementation of Radix Sort.
*
* <p>See https://en.wikipedia.org/wiki/Radix_sort for details on runtime and complexity Radix sorts
* operates in O(nw) time, where n is the number of keys, and w is the key length where w is
* constant on primitive types like Integer which gives it a better p... | fim | williamfiset/algorithms | java |
<|fim_suffix|>j) {
int tmp = ar[i];
ar[i] = ar[j];
ar[j] = tmp;
}
public static void main(String[] args) {
InplaceSort sorter = new SelectionSort();
int[] array = {10, 4, 6, 8, 13, 2, 3};
sorter.sort(array);
// Prints:
// [2, 3, 4, 6, 8, 10, 13]
System.out.println(java.util.Arra... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Tim sort implementation — a hybrid sorting algorithm combining merge sort and insertion sort.
*
* Tim sort divides the array into small chunks called "runs" and sorts each run using insertion
* sort (which is efficient for small or nearly-sorted data). It then merges the runs using a
* merge st... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* This file contains an implementation of Booths algorithms which finds the lexicographically
* smallest string rotation.
*/
package com.williamfiset.algorithms.strings;
public class BoothsAlgorithm {
// Performs Booths algorithm returning the earliest index of the
// lexicographically smalle... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* Performs Boyer-Moore search on a given string with a given pattern
*
* <p>bazel run //src/main/java/com/williamfiset/algorithms/strings:BoyerMooreStringSearch
*/
package com.williamfiset.algorithms.strings;
import static java.lang.Math.max;
import static java.lang<|fim_suffix|>String text, Stri... | fim | williamfiset/algorithms | java |
<|fim_suffix|>d the proper suffix starting at i
private static int[] kmpHelper(String pat, int m) {
int[] arr = new int[m];
for (int i = 1, len = 0; i < m; ) {
if (pat.charAt(i) == pat.charAt(len)) {
arr[i++] = ++len;
} else {
if (len > 0) len = arr[len - 1];
else i++;
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* This file shows you how to use a suffix array to construct the Longest Common Prefix (LCP) array
* using the kasai algorithm.
*
* <p>Time complexity: O(nlogn) for suffix array <|fim_suffix|> for (int i = 0; i < N; i++) {
int suffixLen = N - sa[i];
String suffix = new String(T, sa... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* An implementation of the k Longest Common Substring problem.
*
* <p>Video: https://youtu.be/Ic80xQFWevc Time complexity: O(nlog^2(n))
*
* <p>Run on command line:
*
* <p>Compile: $ javac -d src/main/java
* src/main/java/com/williamfiset/algorithms/strings/LongestCommonSubstring.java
*
* <p>... | fim | williamfiset/algorithms | java |
<|fim_suffix|>ivate void kasai() {
lcp = new int[N];
int[] inv = new int[N];
for (int i = 0; i < N; i++) inv[sa[i]] = i;
for (int i = 0, len = 0; i < N; i++) {
if (inv[i] > 0) {
int k = sa[inv[i] - 1];
while ((i + len < N) && (k + len < N) && T[i + len] == T[k + len])... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* An implementation of Manacher's algorithm which can be used to find/count palindromic strings in
* linear time. In particular, it finds the length of the maximal palindrome centered at each index.
*/
package com.williamfiset.algorithms.strings;
public class ManachersAlgorithm {
// Manacher's ... | fim | williamfiset/algorithms | java |
<|fim_suffix|>// alphabetBasePower - A^n
private static long removeLeft(
long rollingHash, long alphabetBasePower, char firstValue, int modIndex) {
rollingHash = (rollingHash - ALPHABET[firstValue] * alphabetBasePower) % MODS[modIndex];
return (rollingHash + MODS[modIndex]) % MODS[modIndex];
}
// C... | fim | williamfiset/algorithms | java |
/**
* This file shows you how to use a suffix array to determine if a pattern exists within a text.
* This implementation has the advantage that once the suffix array is built queries can be very
* fast.
*
* <p>Time complexity: O(nlogn) for suffix array construction and O(mlogn) time for individual
* queries (whe... | fim | williamfiset/algorithms | java |
package com.williamfiset.algorithms.strings;
import static java.util.Objects.isNull;
public class ZAlgorithm {
/**
* Calculates the Z-array of a given string
*
* @param text the string on which Z-array is computed
* @return An int-array which is the Z-array of text
*/
public int[] calculateZ(Strin... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.utils;
import java.util.*;
public final class TestUtils {
// Generates an array of random values where every number is between
// [min, max) and there are possible repeats.
public static int[] randomIntegerArray(int sz, int min, int max) {
int[] ar = new in... | fim | williamfiset/algorithms | java |
<|fim_suffix|>args) {
DagGenerator gen = new DagGenerator(10, 10, 5, 5, 0.9);
gen.createDag();
}
}
<|fim_prefix|>package com.williamfiset.algorithms.utils.graphutils;
import java.util.*;
public class GraphGenerator {
public static class DagGenerator {
double edgeProbability;
int minLevels, maxLev... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* A set of common graph theory functions.
*
* @author William Fiset, william.alexandre.fiset@gmail.com
*/
package com.williamfiset.algorithms.utils.graphutils;
import java.util.ArrayList;
import java.util.List;
public final class Utils {
/**
* Creates an empty graph represented as an adjac... | fim | williamfiset/algorithms | java |
package com.williamfiset.algorithms.datastructures.balancedtree;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
i... | fim | williamfiset/algorithms | java |
<|fim_suffix|>edBlackTree.BLACK);
assertThat(tree.root.left.color).isEqualTo(RedBlackTree.RED);
assertThat(tree.root.right.color).isEqualTo(RedBlackTree.RED);
assertThat(tree.root).isEqualTo(tree.root.left.parent);
assertThat(tree.root).isEqualTo(tree.root.right.parent);
assertNullChildren(tree, t... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.balancedtree;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.TreeSet;
import org.juni... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.binarysearchtree;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.ConcurrentModi... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.binarysearchtree;
import static com.google.common.truth.Truth.assertT<|fim_suffix|>blic void splayInsertDeleteSearch() {
SplayTree<Integer> splayTree = new SplayTree<>();
List<Integer> data =
TestUtils.randomUniformUniqueIntegerList(
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.bloomfilter;
import static com.google.common.truth.Truth.assertThat;
import java.security.SecureRandom;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import org.junit.jupiter.api.*;
public class BloomFilterTest {
static fi... | fim | williamfiset/algorithms | java |
<|fim_suffix|>ay ar = new IntArray(new int[] {1, 2, 3, 4, 5});
ar.reverse();
assertThat(ar.get(0)).isEqualTo(5);
assertThat(ar.get(1)).isEqualTo(4);
assertThat(ar.get(2)).isEqualTo(3);
assertThat(ar.get(3)).isEqualTo(2);
assertThat(ar.get(4)).isEqualTo(1);
}
@Test
public void testReverseE... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.fenwicktree;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.*;
public class FenwickTreeRangeQueryPointUpdateTest {
static final int MIN_RAND_NUM = -10... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.fenwicktree;
import static com.google.common.truth.Truth.assertThat;
import<|fim_suffix|>ndValue() {
return (long) (Math.random() * MAX_RAND_NUM * 2) + MIN_RAND_NUM;
}
}
<|fim_middle|> static org.junit.jupiter.api.Assertions.assertThrows;
import o... | fim | williamfiset/algorithms | java |
<|fim_suffix|>isEqualTo(4);
}
@Test
public void elementThrowsException() {
assertThrows(NoSuchElementException.class, () -> queue.element());
}
}
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.fibonacciheap;
import static com.google.common.truth.Truth.assertThat;
import static java.util.... | fim | williamfiset/algorithms | java |
<|fim_suffix|>System.out.println("Not good..");
}
long end = System.nanoTime();
System.out.println("Double hashing: " + (end - start) / 1e9);
}
public static void testHashMapSpeed() {
HashMap<Integer, Integer> jmap = new HashMap<>();
long start = System.nanoTime();
for (int i = 0; i < N; ... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.hashtable;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.*;
import java.util.*;
import org.junit.jupiter.api.*;
public class HashTableDoubleHashingTest {
static final Random RANDOM = new Rando... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.hashtable;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.*;
import java.util.*;
import org.junit.jupiter.api.*;
public class HashTableLinearProbingTest {
// You can set the hash value of this ... | fim | williamfiset/algorithms | java |
<|fim_suffix|>)).isEqualTo(map.size());
map = new HashTableQuadraticProbing<>();
final double probability1 = Math.random();
final double probability2 = Math.random();
List<Integer> nums = genRandList(MAX_SIZE);
for (int i = 0; i < MAX_SIZE; i++) {
double r = Math.random();
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.hashtable;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.*;
import java.util.*;
import org.junit.jupiter.api.*;
<|fim_suffix|>);
for (int i = 0; i < MAX_SIZE; i++) {
double r = Math... | fim | williamfiset/algorithms | java |
<|fim_suffix|>eeBarren.delete(rootPoint) == rootPoint).isTrue();
// Left child test
kdTreeLeft.insert(rootPoint);
kdTreeLeft.insert(leftPoint);
assertThat(kdTreeLeft.delete(rootPoint) == rootPoint).isTrue();
// Right child test
kdTreeRight.insert(rootPoint);
kdTreeRight.insert(rightPoint);
... | fim | williamfiset/algorithms | java |
<|fim_suffix|>0);
list.add(30);
List<Integer> result = new ArrayList<>();
for (int v : list) result.add(v);
assertThat(result).containsExactly(10, 20, 30).inOrder();
}
@Test
public void testRandomizedRemoving() {
LinkedList<Integer> javaLinkedList = new LinkedList<>();
for (int loops = 0;... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.priorityqueue;
import static com.google.common.truth.Truth.assertThat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;
import org.junit.jupiter.api.*;
public class BinaryHeapQuickRemovals... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.priorityqueue;
import static com.google.common.truth.Truth.assertThat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;
import org.junit.jupiter.api.*;
public class BinaryHeapTest {
sta... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.priorityqueue;
import static com.google.common.truth.Truth.assertThat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;
import org.junit.jupiter.api.*;
public class MinDHeapTest {
stati... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.priorityqueue;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import ja... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.quadtree;
import static com.google.common.truth.Truth.assertThat;
import org.junit.jupiter.api.*;
public class QuadTreeTest {
static final int LOOPS = 50;
static final int TEST_SZ = 1000;
static final int MAX_RAND_NUM = +2000;
@BeforeEach
p... | fim | williamfiset/algorithms | java |
<|fim_suffix|> n; i++) {
assertThat((int) queue.peek()).isEqualTo(i);
assertThat((int) queue.poll()).isEqualTo(i);
assertThat(queue.size()).isEqualTo(n - i);
}
assertThat(queue.isEmpty()).isTrue();
n = 8;
for (int i = 1; i <= n; i++) {
queue.offer(i);
assertThat(queue.isEmp... | fim | williamfiset/algorithms | java |
<|fim_suffix|>ze()).isEqualTo(1);
}
@ParameterizedTest
@MethodSource("inputs")
public void testPeek(Queue<Integer> queue) {
queue.offer(2);
assertThat((int) queue.peek()).isEqualTo(2);
assertThat(queue.size()).isEqualTo(1);
}
@ParameterizedTest
@MethodSource("inputs")
public void testPoll(... | fim | williamfiset/algorithms | java |
package com.williamfiset.algorithms.datastructures.segmenttree;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class CompactSegmentTreeTest {
@Test
public void testSumQueryBasic() {
long[] values ... | fim | williamfiset/algorithms | java |
<|fim_suffix|>sEqualTo(10);
// Assign [2,4] = -5 -> {10, 10, -5, -5, -5}
st.rangeUpdate(2, 4, -5);
assertThat(st.rangeQuery(0, 4)).isEqualTo(10);
assertThat(st.rangeQuery(2, 4)).isEqualTo(-5);
assertThat(st.rangeQuery(0, 1)).isEqualTo(10);
}
// =================================================... | fim | williamfiset/algorithms | java |
<|fim_suffix|>void bruteForceMulRangeUpdate(long[] values, int l, int r, long x) {
for (int i = l; i <= r; i++) {
values[i] *= x;
}
}
private static void bruteForceAssignRangeUpdate(long[] values, int l, int r, long x) {
for (int i = l; i <= r; i++) {
values[i] = x;
}
}
}
<|fim_prefix... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* bazel test //src/test/java/com/williamfiset/algorithms/datastructures/segmenttree:MinQueryAssignUpdateSegmentTreeTest
*/
package com.williamfiset.algorithms.datastructures.segmenttree;
import static com.google.common.truth.Truth.assertThat;
import com.williamfiset.algorithms.utils.TestUtils;
imp... | fim | williamfiset/algorithms | java |
<|fim_prefix|>/**
* bazel test //src/test/java/com/williamfiset/algorithms/datastructures/segmenttree:MinQuerySumUpdateSegmentTreeTest
*/
package com.williamfiset.algorithms.datastructures.segmenttree;
import static com.google.common.truth.Truth.assertThat;
import com.williamfiset.algorithms.utils.TestUtils;
import... | fim | williamfiset/algorithms | java |
<|fim_prefix|>// bazel test //src/test/java/com/williamfiset/algorithms/datastructures/segmenttree:SegmentTreeWithPointersTest
package com.williamfiset.algorithms.datastructur<|fim_suffix|> assertThat(tree.sum(0, 5)).isEqualTo(15);
}
@Test
public void testMinQuerySingleElements() {
int[] values = {5, 1, 3,... | fim | williamfiset/algorithms | java |
<|fim_suffix|>uteForceAssignRangeUpdate(ar, i3, i4, randValue);
}
}
}
// Finds the sum in an array between [l, r] in the `values` array
private static long bruteForceSum(long[] values, int l, int r) {
long s = 0;
for (int i = l; i <= r; i++) {
s += values[i];
}
return s;
}
//... | fim | williamfiset/algorithms | java |
<|fim_suffix|>lues, int l, int r, long x) {
for (int i = l; i <= r; i++) {
values[i] *= x;
}
}
private static void bruteForceAssignRangeUpdate(long[] values, int l, int r, long x) {
for (int i = l; i <= r; i++) {
values[i] = x;
}
}
}
<|fim_prefix|>/**
* bazel test //src/test/java/com... | fim | williamfiset/algorithms | java |
/**
* bazel test //src/test/java/com/williamfiset/algorithms/datastructures/segmenttree:SumQuerySumUpdateSegmentTreeTest
*/
package com.williamfiset.algorithms.datastructures.segmenttree;
import static com.google.common.truth.Truth.assertThat;
import com.williamfiset.algorithms.utils.TestUtils;
import org.junit.jup... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.set;
import static com.google.common.truth.Truth.assertThat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import org.junit.jupiter.api.*;
// You can set the hash val... | fim | williamfiset/algorithms | java |
<|fim_suffix|>alse(sl.find(43), "Object with key 43 shouldn't be found");
}
@Test
// Insert shall return false if trying to insert an object with the
// same key as an already existing object
public void testDuplicate() {
SkipList sl = new SkipList(2, 2, 5);
sl.insert(4);
assertFalse(sl.insert(4... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.sparsetable;
import static com.google.common.truth.Truth.assertThat;
import java.util.*;
import org.junit.jupiter.api.*;
public class SparseTableTest {
private void queryResultTest(
long[] values, int l, int r, long actual, int index, SparseTa... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.stack;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.Parameteriz... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.suffixarray;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Random;
import org.junit.jupiter.api.Test;
public class SuffixArrayTest {
static final String ASCII_LE... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.datastructures.trie;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class TrieTest {
@Test
public void testBadTrieDelete1() {
assertThrows(
... | fim | williamfiset/algorithms | java |
package com.williamfiset.algorithms.datastructures.unionfind;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.dp;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.primitives.Ints;
import com.williamfiset.algorithms.utils.TestUtils;
import java.util.*;
import org.junit.jupiter.api.*;
public class CoinChangeTest {
static final int LOOPS = 100... | fim | williamfiset/algorithms | java |
<|fim_suffix|>st<DagDynamicProgramming.Edge>> graph = createGraph(n);
graph.get(0).add(new DagDynamicProgramming.Edge(1));
graph.get(1).add(new DagDynamicProgramming.Edge(2));
graph.get(2).add(new DagDynamicProgramming.Edge(0)); // cycle
long[] dp = DagDynamicProgramming.countWaysDAG(graph, 0, n);
... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.dp;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class EditDistanceIterativeTest {
@Test
public void testNullInputA() {
assertThrows(
Il... | fim | williamfiset/algorithms | java |
<|fim_suffix|>napsack(capacity, W, V);
List<Integer> items = Knapsack_01.knapsackItems(capacity, W, V);
int totalWeight = 0, totalValue = 0;
for (int idx : items) {
totalWeight += W[idx];
totalValue += V[idx];
}
assertThat(totalValue).isEqualTo(maxValue);
assertThat(totalWeight).is... | fim | williamfiset/algorithms | java |
<|fim_suffix|>("ABCDE");
}
@Test
public void testOneIsSubsequence() {
assertThat(LongestCommonSubsequence.lcs("abcde", "ace")).isEqualTo("ace");
}
@Test
public void testPrefixMatch() {
assertThat(LongestCommonSubsequence.lcs("ABCXYZ", "ABC")).isEqualTo("ABC");
}
@Test
public void testSuffix... | fim | williamfiset/algorithms | java |
<|fim_suffix|>o(0);
}
@Test
public void testNullInputs() {
assertThat(LongestPalindromeSubsequence.lpsRecursive(null)).isEqualTo(0);
assertThat(LongestPalindromeSubsequence.lpsIterative(null)).isEqualTo(0);
}
}
<|fim_prefix|>package com.williamfiset.algorithms.dp;
import static com.google.common.truth... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.dp;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class MaximumSubarrayTest {
@Test
public void testNullInput() {
assertThrows(
IllegalAr... | fim | williamfiset/algorithms | java |
<|fim_prefix|>package com.williamfiset.algorithms.dp;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class MinimumWeightPerfectMatchingTest {
@Test
public void testNullInput() {
assertThrows(Illeg... | fim | williamfiset/algorithms | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.