Code Explainers

Code explainers tagged #sorting

python 
import re
from functools import total_ordering
from typing import Optional
 

Parsing and comparing semantic versions

regex operator-overloading sorting
Intermediate 7 steps
java 
public final class ImportOrganizer {
 
    private static final Pattern IMPORT_LINE =
            Pattern.compile("^import\\s+(static\\s+)?([\\w.]+(?:\\.\\*)?)\\s*;\\s*$");

Sorting Java imports with a regex pass

regex sorting text-processing
Intermediate 8 steps
java 
public record TimeSlot(LocalDate day, LocalDateTime start, LocalDateTime end) {}
 
public class ScheduleAnalyzer {
 

Detecting calendar conflicts in Java

streams sorting sweep-line
Intermediate 8 steps
java 
public final class PrefixSearch {
 
    private final String[] words;
 

Prefix search with binary search bounds

binary-search sorting range-query
Intermediate 9 steps
javascript 
function mergeDateRanges(ranges) {
  const parsed = ranges
    .map(({ start, end }) => ({
      start: new Date(start),

Merging overlapping date ranges

intervals sorting dates
Intermediate 8 steps
php 
<?php
 
namespace App\Http;
 

HTTP content negotiation in PHP

http content-negotiation parsing
Intermediate 9 steps
php 
<?php
 
namespace App\Services;
 

Merging overlapping busy time blocks in PHP

interval-merging sorting datetime
Intermediate 8 steps
rust 
use std::time::Duration;
 
#[derive(Debug, Clone, Copy)]
pub struct LatencyStats {

Computing latency percentiles in Rust

percentiles interpolation closures
Intermediate 6 steps
java 
public List<int[]> merge(int[][] intervals) {
    if (intervals.length == 0) {
        return new ArrayList<>();
    }

Merging overlapping intervals in Java

intervals sorting greedy
Intermediate 7 steps
python 
from typing import List, Tuple
 
 
def merge_intervals(intervals: List[Tuple[int, int]]) -> List[Tuple[int, int]]:

How interval merging works

sorting greedy intervals
Intermediate 6 steps
ruby 
class DateRangeMerger
  def initialize(ranges)
    @ranges = ranges
  end

Merging overlapping date ranges in Ruby

sorting interval-merging enumerable
Intermediate 5 steps
php 
function fuzzySearch(string $query, array $items, int $limit = 10): array
{
    $query = mb_strtolower(trim($query));
 

Building a ranked fuzzy search in PHP

fuzzy-search string-matching ranking
Intermediate 7 steps
java 
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

Ranking the most frequent words in Java

streams regex grouping
Intermediate 7 steps
rust 
use std::cmp::Ordering;
 
pub struct PrefixIndex {
    entries: Vec<String>,

Prefix search with binary partitioning in Rust

binary-search sorting case-insensitive
Intermediate 7 steps
typescript 
type SortDirection = "asc" | "desc";
 
interface SortKey<T> {
  selector: (row: T) => string | number | Date | null | undefined;

Multi-column sorting in TypeScript

generics comparators sorting
Intermediate 6 steps
go 
type Employee struct {
	Department string
	LastName   string
	FirstName  string

Multi-key sorting in Go

sorting comparators tie-breaking
Intermediate 6 steps
rust 
pub fn merge_intervals(mut intervals: Vec<(i64, i64)>) -> Vec<(i64, i64)> {
    if intervals.is_empty() {
        return Vec::new();
    }

Merging overlapping intervals in Rust

intervals sorting greedy
Intermediate 7 steps
python 
from operator import itemgetter
 
 
def sort_employees(employees):

Multi-key sorting patterns in Python

sorting tuple-keys itemgetter
Intermediate 5 steps