Browse the library

class Typed:
    """A data descriptor that enforces a type and optional validation."""
 
    def __init__(self, expected_type, validator=None):

import java.util.*;
 
public class TopologicalSort {
 

package handlers
 
import (
	"net/http"

// Sliding window maximum using a monotonic decreasing deque.
// Returns an array of the maximum value within each window of size k.
function maxSlidingWindow(nums, k) {
  const result = [];

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 

interface RetryOptions {
  retries?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;

from collections import Counter
 
 
def word_frequencies(text):

function debounce(fn, delay) {
  let timeoutId = null;
 
  function debounced(...args) {

package main
 
import "fmt"
 

use std::thread;
 
pub fn parallel_map_reduce<T, M, R, F, G, H>(
    data: &[T],

import java.util.Arrays;
 
public class SlidingWindow {
    // Returns the maximum sum of any contiguous subarray of length k.

def two_sum_sorted(numbers, target):
    """Find indices of two values that sum to target in a sorted array."""
    left, right = 0, len(numbers) - 1
    while left < right:

package main
 
import "sync"
 

# Binary search using Ruby's built-in Array#bsearch.
#
# There are two modes:
#   1. find-minimum mode  -> block returns true/false (monotonic)

type NestedArray<T> = Array<T | NestedArray<T>>;
 
function flatten<T>(input: NestedArray<T>): T[] {
  const result: T[] = [];

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

function flatten(arr) {
  const result = [];
  for (const item of arr) {
    if (Array.isArray(item)) {

class LinkedList
  include Enumerable
 
  Node = Struct.new(:value, :next_node)