Archives

Solutions for LeetCode 310, medium, tags: graph, topological sort, BFS.

How Byte Pair Encoding (BPE) tokenization works in large language models: the training algorithm, encoding and decoding, tiktoken and sentencepiece implementations, vocabulary construction, and why subword tokenization strikes the right balance between characters and words.

Solutions for LeetCode 543, easy, tags: tree, depth-first search, binary tree.

How a packet travels from NIC hardware to your application's socket: interrupts, NAPI, sk_buff, protocol layers, and socket receive queues — a walkthrough of the Linux kernel network stack.

Solutions for LeetCode 127, hard, tags: hash table, string, breadth-first search.

Solutions for LeetCode 2131, medium, tags: array, hash table, string, greedy, counting.

How Protocol Buffers encoding works internally: wire types, varint encoding, field tags, length-delimited records, and a byte-level walkthrough showing why protobuf messages are compact and fast to parse.

Solutions for LeetCode 210, medium, tags: depth-first search, breadth-first search, graph, topological sort.

Solutions for LeetCode 2101, medium, tags: array, math, depth-first search, breadth-first search, graph.

How database connection pooling works: the cost of raw connections, pool lifecycle, idle/active management, connection multiplexing modes, HikariCP internals, and PgBouncer architecture with source code walkthrough.

Solutions for LeetCode 4, hard, tags: array, binary search, divide and conquer.

Solutions for LeetCode 752, medium, tags: array, hash table, string, breadth-first search.

Solutions for LeetCode 841, medium, tags: depth-first search, breadth-first search, graph.

Solutions for LeetCode 547, medium, tags: depth-first search, breadth-first search, union find, graph.

How Paxos distributed consensus works: the protocol phases, roles (proposer, acceptor, learner), Multi-Paxos optimization, comparison with Raft, and real-world implementations in Google Chubby, Apache ZooKeeper, and Spanner.

Solutions for LeetCode 494, medium, tags: array, dynamic programming, backtracking.

Solutions for LeetCode 918, medium, tags: array, dynamic programming, divide and conquer, queue, monotonic queue.

How gossip protocols propagate information across distributed systems: epidemic dissemination, SWIM failure detection, push/pull/push-pull strategies, convergence analysis, and real-world implementations in Cassandra, Consul, and Redis Cluster.

Solutions for LeetCode 130, medium, tags: array, depth-first search, breadth-first search, union find, matrix.

How coroutines power async/await: the difference between stackful and stackless coroutines, how Python transforms async functions into state machines, how Go's goroutines use stack-copying, and how the event loop ties it all together.

Solutions for LeetCode 518, medium, tags: array, dynamic programming.

How HTTP/2 multiplexing works: binary framing, streams, flow control, HPACK header compression, and server push — with ASCII diagrams and source code references from the Go net/http2 implementation.

Solutions for LeetCode 75, medium, tags: array, two pointers, sorting.

Solutions for LeetCode 1631, medium, tags: array, binary search, depth-first search, breadth-first search, union find, heap (priority queue), matrix.

Solutions for LeetCode 36, medium, tags: array, hash table, matrix.

How circuit breakers protect distributed systems from cascading failures: state machine design, failure detection, recovery probing, and a source code walkthrough of real implementations.

Solutions for LeetCode 25, hard, tags: linked list, recursion.

How Copy-on-Write works across operating systems, databases, and filesystems: the core mechanism behind fork(), Redis snapshots, LMDB reads, B-tree databases, and modern filesystems like Btrfs and ZFS.

Solutions for LeetCode 329, hard, tags: array, dynamic programming, depth-first search, breadth-first search, graph, topological sort, memoization, matrix.

Solutions for LeetCode 2542, medium, tags: array, greedy, sorting, heap (priority queue).

Solutions for LeetCode 150, medium, tags: array, math, stack.

How databases detect deadlocks: the wait-for graph algorithm, cycle detection via DFS, InnoDB's implementation, victim selection strategies, and how distributed databases like TiDB handle cross-node deadlocks.

Solutions for LeetCode 55, medium, tags: array, dynamic programming, greedy.

How Solid-State Drives work internally: NAND flash physics, pages and blocks, the Flash Translation Layer (FTL), garbage collection, wear leveling, write amplification, TRIM, and why understanding SSDs matters for database engineers.

How modern CPUs predict branch outcomes: pipeline stalls, static vs dynamic prediction, branch history tables, two-level adaptive predictors, branch target buffers, and real-world performance implications with code examples.

Solutions for LeetCode 71, medium, tags: string, stack.

Solutions for LeetCode 31, medium, tags: array, two pointers.

Solutions for LeetCode 57, medium, tags: array.

How JIT compilation works: interpreter warm-up, profiling, tiered compilation in the JVM HotSpot and V8 engines, inline caches, deoptimization, and source code walkthrough.

How the Linux page cache works: the kernel's transparent caching layer that sits between applications and disk. Covers address_space, radix tree (xarray), readahead, dirty page writeback, memory pressure eviction, and source code walkthrough from the Linux kernel.

Solutions for LeetCode 695, medium, tags: array, depth-first search, breadth-first search, union find, matrix.

Solutions for LeetCode 115, hard, tags: string, dynamic programming.

How Prometheus stores time-series data: the in-memory head block, Write-Ahead Log, chunk encoding, compaction into persistent blocks, and how queries traverse the layered architecture. Source code walkthrough from the prometheus/prometheus repository.

Solutions for LeetCode 73, medium, tags: array, hash table, matrix.

Solutions for LeetCode 98, medium, tags: tree, depth-first search, binary search tree, binary tree.

Solutions for LeetCode 516, medium, tags: string, dynamic programming.

Solutions for LeetCode 380, medium, tags: array, hash table, math, design, randomized.

How Merkle trees work: hash tree structure, efficient data verification, applications in git, blockchains, distributed databases (Cassandra, DynamoDB), and certificate transparency.

Solutions for LeetCode 297, hard, tags: string, tree, binary tree, design, dfs, bfs.

How vectorized query execution works in modern databases: the Volcano model's limitations, batch-at-a-time processing, columnar memory layout, SIMD exploitation, and source code walkthrough from DuckDB and Apache DataFusion.

Solutions for LeetCode 34, medium, tags: array, binary search.

How the Raft consensus algorithm works: leader election, log replication, safety guarantees, membership changes, and a source code walkthrough from etcd's raft library.

Solutions for LeetCode 102, medium, tags: tree, breadth-first search, depth-first search, binary tree.

Solutions for LeetCode 402, medium, tags: string, stack, monotonic stack, greedy.

Solutions for LeetCode 684, medium, tags: tree, union find, graph, depth-first search.

Solutions for LeetCode 525, medium, tags: array, hash table, prefix sum.

How lock-free data structures work: CAS operations, memory ordering, the ABA problem, lock-free stacks and queues, and source code walkthrough from the Linux kernel and Java's java.util.concurrent.

Solutions for LeetCode 567, medium, tags: hash table, two pointers, string, sliding window.

Solutions for LeetCode 1249, medium, tags: string, stack.

How zero-copy I/O works in Linux: the cost of traditional read/write, how sendfile() and splice() eliminate copies, how mmap fits in, and why Kafka and nginx are fast — with ASCII diagrams and kernel source code references.

Solutions for LeetCode 438, medium, tags: hash table, string, sliding window.

Solutions for LeetCode 153, medium, tags: array, binary search.

Solutions for LeetCode 787, medium, tags: dynamic programming, BFS, graph, heap, shortest path.

Solutions for LeetCode 114, medium, tags: tree, depth-first search, linked list, stack, binary tree.

Solutions for LeetCode 236, medium, tags: tree, dfs, binary tree.

How Go's goroutine scheduler works: the GMP model (Goroutines, OS Threads, Processors), work stealing, preemption, netpoller integration, and a source code walkthrough from the Go runtime.

Solutions for LeetCode 1143, medium, tags: string, dynamic programming.

Solutions for LeetCode 312, hard, tags: array, dynamic programming.

Solutions for LeetCode 62, medium, tags: math, dynamic programming, combinatorics.

How columnar storage works: row vs column layout, compression techniques, vectorized execution, Apache Parquet internals, and why modern analytics engines like ClickHouse and DuckDB are so fast.

Solutions for LeetCode 1091, medium, tags: array, breadth-first search, matrix, shortest path.

Solutions for LeetCode 138, medium, tags: hash table, linked list.

Solutions for LeetCode 239, hard, tags: array, queue, sliding window, heap, monotonic queue.

Solutions for LeetCode 78, medium, tags: array, backtracking, bit manipulation.

Solutions for LeetCode 647, medium, tags: string, dynamic programming, two pointers.

How eBPF works in the Linux kernel: architecture, program types, the verifier, JIT compilation, maps for state sharing, helper functions, and real-world use cases in observability, networking, and security.

Solutions for LeetCode 199, medium, tags: tree, depth-first search, breadth-first search, binary tree.

Solutions for LeetCode 417, medium, tags: array, depth-first search, breadth-first search, matrix.

Solutions for LeetCode 124, hard, tags: tree, depth-first search, dynamic programming, binary tree.

Solutions for LeetCode 973, medium, tags: array, math, divide and conquer, geometry, sorting, heap, quickselect.

Solutions for LeetCode 162, medium, tags: array, binary search.

How Google's MapReduce programming model works: the map and reduce phases, data shuffling, fault tolerance, locality optimization, and a walkthrough of the execution model with real code examples.

Solutions for LeetCode 981, medium, tags: hash table, string, binary search, design.

Solutions for LeetCode 287, medium, tags: array, two pointers, binary search, bit manipulation.

How database replication works: physical vs logical replication, MySQL binlog and PostgreSQL WAL streaming, replication lag, semi-synchronous commit, and the CAP trade-offs in real systems.

Solutions for LeetCode 743, medium, tags: graph, heap, shortest path, Dijkstra, Bellman-Ford.

Solutions for LeetCode 134, medium, tags: array, greedy.

Solutions for LeetCode 763, medium, tags: hash table, two pointers, string, greedy.

Solutions for LeetCode 74, medium, tags: array, binary search, matrix.

How distributed tracing works: trace/span model, context propagation, sampling strategies, and how systems like Jaeger, Zipkin, and OpenTelemetry implement end-to-end request tracking across microservices.

Solutions for LeetCode 853, medium, tags: array, sorting, monotonic stack.

How CRDTs enable conflict-free replication in distributed systems: state-based vs operation-based approaches, G-Counter, PN-Counter, LWW-Register, OR-Set, and real-world usage in collaborative editing, databases, and caches.

Solutions for LeetCode 435, medium, tags: array, dynamic programming, greedy, sorting.

Solutions for LeetCode 621, medium, tags: array, hash table, greedy, sorting, heap, counting.

Solutions for LeetCode 79, medium, tags: array, string, backtracking, matrix.

Solutions for LeetCode 5, medium, tags: string, dynamic programming.

How virtual memory and paging works in modern operating systems: address translation, page tables, TLB, page faults, multi-level page tables, and a walkthrough of Linux's implementation.

Solutions for LeetCode 2462, medium, tags: array, two pointers, heap (priority queue), simulation.

How modern CPU caches work: the memory hierarchy from registers to DRAM, cache lines, associativity, write policies, coherence protocols (MESI), and false sharing — with source code examples showing real performance impact.

Solutions for LeetCode 48, medium, tags: array, math, matrix.

Solutions for LeetCode 994, medium, tags: array, breadth-first search, matrix.

How database sharding works: partitioning strategies (hash, range, directory), routing mechanisms, resharding challenges, and how real systems (Vitess, TiDB, DynamoDB, CockroachDB) implement it.

Solutions for LeetCode 105, medium, tags: array, hash table, divide and conquer, tree, binary tree.

Solutions for LeetCode 133, medium, tags: hash table, depth-first search, breadth-first search, graph.

Solutions for LeetCode 424, medium, tags: string, sliding window, hash table, binary search.

Solutions for LeetCode 2583, medium, tags: tree, breadth-first search, sorting, binary tree.

Solutions for LeetCode 46, medium, tags: array, backtracking.

How memory allocators work under the hood: malloc/free internals, free lists, splitting and coalescing, the buddy system, arena-based allocators like tcmalloc and jemalloc, and how modern allocators reduce lock contention in multi-threaded programs.

Solutions for LeetCode 198, medium, tags: array, dynamic programming.

Solutions for LeetCode 17, medium, tags: hash table, string, backtracking.

Solutions for LeetCode 54, medium, tags: array, matrix, simulation.

How Linux's Completely Fair Scheduler (CFS) works: virtual runtime, red-black tree scheduling, nice values, CPU bandwidth control, and source code walkthrough from the kernel's sched/fair.c.

How Linux io_uring works: the submission and completion ring buffers, zero-copy I/O without system call overhead, kernel polling mode, and source code walkthrough from the liburing library.

How two-phase commit (2PC) works in distributed databases: the coordinator/participant model, prepare and commit phases, failure handling, recovery via write-ahead logging, and real-world implementations in PostgreSQL, MySQL, and TiDB.

Solutions for LeetCode 209, medium, tags: array, binary search, sliding window, prefix sum.

Solutions for LeetCode 121, easy, tags: array, dynamic programming.

Solutions for LeetCode 143, medium, tags: linked list, two pointers, stack, recursion.

How vector databases work: embedding vectors, similarity search, indexing with HNSW and IVF, distance metrics, quantization, and a look at how Milvus organizes its storage engine.

Solutions for LeetCode 295, hard, tags: two pointers, design, sorting, heap, data stream.

How TCP congestion control works: slow start, congestion avoidance, fast retransmit, fast recovery, and modern algorithms like CUBIC and BBR — explained with ASCII diagrams and Linux kernel source references.

Solutions for LeetCode 139, medium, tags: dynamic programming, hash table, string, trie, memoization.

Solutions for LeetCode 11, medium, tags: array, two pointers, greedy.

Solutions for LeetCode 84, hard, tags: array, stack, monotonic stack.

Solutions for LeetCode 22, medium, tags: string, dynamic programming, backtracking.

How Git works under the hood: the four object types (blob, tree, commit, tag), content-addressable storage, refs and branches, the staging area (index), packfiles and delta compression, and merge strategies — with ASCII diagrams and source code walkthrough from the git/git repository.

Solutions for LeetCode 207, medium, tags: depth-first search, breadth-first search, graph, topological sort.

Solutions for LeetCode 735, medium, tags: array, stack, simulation.

How Linux epoll works: the evolution from select/poll, epoll's internal architecture with red-black trees and ready lists, level-triggered vs edge-triggered modes, and a source code walkthrough from the Linux kernel.

Solutions for LeetCode 322, medium, tags: array, dynamic programming, breadth-first search.

Solutions for LeetCode 895, hard, tags: hash table, stack, design, ordered set.

How Redis persists data to disk: RDB snapshots via fork() and copy-on-write, AOF (Append Only File) logging, fsync policies, AOF rewriting, and the hybrid RDB+AOF approach. Source code walkthrough from the redis/redis repository.

Solutions for LeetCode 39, medium, tags: array, backtracking.

How Linux containers work: namespaces for isolation, cgroups for resource limits, union filesystems for layered images, and how container runtimes like runc tie it all together.

Solutions for LeetCode 72, medium, tags: string, dynamic programming.

Solutions for LeetCode 128, medium, tags: array, hash table, union find.

A practical explanation of common memory terms: physical RAM, container cgroup memory limit/cap, and RSS (resident set size), with diagrams and examples for Linux systems.

How rate limiting works: token bucket, leaky bucket, fixed window counter, and sliding window log/counter algorithms with ASCII diagrams, source code walkthrough from Nginx, Guava, and Redis, and practical trade-offs.

Solutions for LeetCode 2452, medium, tags: array, string, trie.

How DNS resolution works: the recursive and iterative query process, DNS record types, caching layers, TTL mechanics, and how the global DNS hierarchy routes billions of lookups every day.

Solutions for LeetCode 907, medium, tags: array, dynamic programming, stack, monotonic stack.

Solutions for LeetCode 300, medium, tags: array, binary search, dynamic programming.

Solutions for LeetCode 15, medium, tags: array, two pointers, sorting, hash table.

Solutions for LeetCode 33, medium, tags: array, binary search.

How database query optimizers work: parsing SQL into trees, generating candidate plans, cost estimation, join ordering with dynamic programming and genetic algorithms, and a source code walkthrough of the PostgreSQL optimizer.

How the Transformer attention mechanism works: intuition behind queries/keys/values, scaled dot-product attention, multi-head attention, positional encoding, and a source code walkthrough from PyTorch and the original paper.

Solutions for LeetCode 230, medium, tags: tree, depth-first search, binary search tree, binary tree.

Solutions for LeetCode 347, medium, tags: array, hash table, divide and conquer, sorting, heap, bucket sort, counting, quickselect.

How TLS (Transport Layer Security) works: the handshake protocol, certificate verification, key exchange with Diffie-Hellman, symmetric encryption, TLS 1.2 vs 1.3, and a source code walkthrough from Go's crypto/tls package.

How Apache Kafka works internally: the distributed commit log, partitions, replication with ISR, producer batching, consumer groups, zero-copy transfer, and source code walkthrough from the apache/kafka repository.

Solutions for LeetCode 49, medium, tags: array, hash table, string, sorting.

Solutions for LeetCode 155, medium, tags: stack, design.

How gRPC works under the hood: Protocol Buffers serialization, HTTP/2 framing, the four RPC patterns (unary, server streaming, client streaming, bidirectional), channel and transport architecture, interceptors, and a source code walkthrough from the grpc/grpc-go repository.

Solutions for LeetCode 238, medium, tags: array, prefix sum.

Solutions for LeetCode 560, medium, tags: array, hash table, prefix sum.

How garbage collection works in practice: reference counting vs. tracing, mark-and-sweep fundamentals, tri-color marking, Go's concurrent collector, write barriers, GC pacing, and source code walkthrough from the Go runtime.

Solutions for LeetCode 76, hard, tags: hash table, string, sliding window.

Solutions for LeetCode 416, medium, tags: array, dynamic programming, bit manipulation.

How Bloom filters work: the probabilistic data structure behind fast membership testing in databases, with a source code walkthrough of LevelDB and RocksDB implementations.

Solutions for LeetCode 42, hard, tags: array, two pointers, dynamic programming, stack, monotonic stack.

How skip lists work: the probabilistic data structure behind Redis sorted sets, LevelDB memtables, and Java's ConcurrentSkipListMap. Covers the layered linked-list architecture, search/insert/delete algorithms, probabilistic balancing, and real-world source code walkthrough.

Solutions for LeetCode 152, medium, tags: array, dynamic programming.

How MVCC works in databases: the concurrency problem it solves, snapshot isolation, PostgreSQL's tuple versioning with xmin/xmax, MySQL InnoDB's undo log and ReadView, garbage collection, and source code walkthrough.

How Kubernetes schedules pods: the default kube-scheduler's filter-score pipeline, the scheduling framework's extension points, custom schedulers (TiDB scheduler as case study), and how Karpenter complements scheduling by provisioning nodes.

How to set up a local Kubernetes cluster with k3d for development: cluster creation, port mapping with NodePort, Mac vs Linux access patterns, kubectl port-forward vs NodePort, and why ctr digest errors are harmless.

Solutions for LeetCode 1848, easy, tags: array.

Solutions for LeetCode 394, medium, tags: string, stack, recursion.

How B+ trees work: node structure, search, insertion with splits, deletion with merges, disk I/O optimization, and why virtually every relational database uses them for indexing.

How Write-Ahead Logging (WAL) works: the core protocol behind database durability and crash recovery. Covers the WAL principle, record structure, buffer management, checkpoints, crash recovery, and a source code walkthrough from PostgreSQL.

Solutions for LeetCode 56, medium, tags: array, sorting.

Solutions for LeetCode 215, medium, tags: array, divide and conquer, sorting, heap, quick select.

How Log-Structured Merge Trees (LSM Trees) work: the write-optimized data structure behind RocksDB, LevelDB, Cassandra, and TiKV. Covers memtable, WAL, SSTables, compaction strategies, bloom filters, and a source code walkthrough from the facebook/rocksdb repository.

How consistent hashing works: the problem with naive hashing, the hash ring, virtual nodes, real-world usage in DynamoDB and Memcached, and a source code walkthrough of Go's jump consistent hash and ketama implementations.

Solutions for LeetCode 200, medium, tags: array, depth-first search, breadth-first search, union find, matrix.

Solutions for LeetCode 739, medium, tags: array, stack, monotonic stack.

artificial intelligence machine learning, understanding precision, recall, accuracy, confusion matrix, and the tradeoffs between them in classification problems

Solutions for LeetCode 3, medium, tags: hash table, string, sliding window.

Solutions for LeetCode 378 and LintCode 1272, medium, tags: array, binary search, heap, matrix.

Solutions for LeetCode 3653, medium, tags: array, simulation.

system design basics - Envoy proxy, north-south vs east-west traffic, its operating modes, how it competes with Nginx, and its relationship with Istio.

system design basics - forward proxy vs reverse proxy, differences, use cases, and examples

Solutions for LeetCode 874, medium, tags: array, hash table, simulation.

Solutions for LeetCode 631, hard, tags: design, graph, depth-first search, topological sort.

Solutions for LeetCode 721, medium, tags: array, hash table, string, depth-first search, breadth-first search, union find, sorting.

How TiDB's Timestamp Oracle (TSO) works: architecture, 64-bit timestamp layout, allocation algorithm, etcd persistence, client batching, and source code walkthrough from the tikv/pd repository.

Solutions for LeetCode 638, medium, tags: array, dynamic programming, backtracking, bitmask, memoization.

Solutions for LeetCode 1298, hard, tags: array, breadth-first search, graph.

Solutions for LeetCode 1235, hard, tags: array, binary search, dynamic programming, sorting.

Solutions for LeetCode 3212, medium, tags: array, matrix, prefix sum.

Solutions for LeetCode 1727, medium, tags: array, matrix, sorting.

Solutions for LeetCode 1980, medium, tags: array, hash table, string.

Shamma Elite Warriors Sandals Review

Xero DIY Sandal Review

system design basics - load balancing

Solutions for LeetCode 23 and LintCode 104, hard, tags: heap, divide and conquer, linked list, merge sort.

system design basics, all about caching (cache)

Solutions for LeetCode 21 and LintCode 165, easy, tags: heap, divide and conquer, linked list, merge sort, companies: microsoft

Solutions for LeetCode 658 LintCode 460, medium, tags: array, binary-search, sliding-window, sorting, heap; companies: google.

Solutions for LeetCode 2539 LintCode 3855, hard, tags: enumerate, string, hash table, math, combinatorics, counting.

How do websockets work comparing to http? System Design Basics, websockets

Solutions for LeetCode 2450 LintCode 3841, medium, tags: math, string.

Solutions for LeetCode 206 LintCode 35, easy, tags: linked list, recursion; companies: bytedance.

Solutions for LeetCode 1166 LintCode 3677, medium, tags: hash table, trie, string, design.

how should we interview other job candidates to find the teammates we like? tips and suggestions on how to interview teammate or junior engineers.

Solutions for LeetCode 2017, medium, tags: array, prefix sum, dynamic programming, matrix.

Solutions for LeetCode 542, LeetCode 1765, and LintCode 974, hard, tags: array, queue, sliding window, heap, monotonic queue.

Solutions for LeetCode 532 LintCode 1187, medium, tags: array, hash table, counting, two-pointers, binary-search; companies: nvidia, amazon.

Solutions for meeting rooms derivative question, hard, tags: heap, line sweep, ordered map; companies: salesforce.

Solutions for LeetCode 1400, medium, tags: hash table, string, greedy, counting.

Solutions for LeetCode 916 LintCode 1726, medium, tags: array, hash table, string.

event loop system design pattern/construct event loop (message dispatcher), reactor/actor pattern, non-blocking mechanism for concurrent applications

Solutions for LeetCode 1930, medium, tags: hash table, string, bit manipulation, prefix sum.

Solutions for , easy, tags: array, sliding window; companies: salesforce.

Solutions for LeetCode 2559, medium, tags: array, string, prefix-sum.

Solutions for LeetCode 1422, easy, tags: string, prefix sum.

Solutions for HackerRank Programmer Strings, hard, tags: string, hash table.

Solutions for LeetCode 2466 LintCode 3854, medium, tags: array, dynamic programming.

tips for using java

Solutions for LeetCode 875 LintCode 1492, medium, tags: array, binary search; companies: facebook, salesforce.

Solutions for LeetCode 423 LintCode 1247, medium, tags: hash table, simulation, math, string.

Solutions for LeetCode 239, hard, tags: array, queue, sliding window, heap, monotonic queue.

Solutions for LintCode 2503, tags: lock, re-entrant lock.

Solutions for LeetCode 239, hard, tags: array, queue, sliding window, heap, monotonic queue.

Solutions for LeetCode 339 LintCode 551, medium, tags: dfs, bfs; companies: salesforce.

Analyze Recursive Algorithm Time Complexity for LeetCode Questions with Substitution, Recursion Tree and Master Theorem

generative AI (artificial intelligence) machine learning with large language models

Solutions for LeetCode 994 LintCode 3726, medium, tags: graph, bfs, array; companies: tiktok.

Solutions for LeetCode 520 LintCode 1202, hard, tags: array, heap, greedy, sorting, binary search, dynamic programming, quick select.

Explanation for rust data structure for tree node and linked list node. What is Rc and RefCell? Why Option<Rc<RefCell>>> three wrappers? How to avoid circular reference?

Solutions for LeetCode 2558, easy, tags: array, heap, simulation.

Solutions for LeetCode 713 and LintCode 1075, medium, tags: sliding window, two pointers, prefix sum; companies: salesforce, yatra.

Solutions for LeetCode 1650 LintCode 474, medium, tags: binary tree, hash table, two pointers; companies: microsoft.

Solutions for LeetCode 408 LintCode 637, easy, tags: two pointers, string, companies: facebook, google.

tips for using AWS

Solutions for LintCode 26, hard, tags: dynamic programming.

tips for matplotlib python draw arcs, robot walks, project euler 208

Solutions for LeetCode 540 LintCode 1183, medium, tags: array, binary search.

tips for linux commands and tips

Solutions for LeetCode 1 LintCode 56, easy, tags: array, hash table.

Solutions for project euler 208 and hackerrank question robot walks, hard, tags: math, simulation.

Solutions for LeetCode 53 and LintCode 41, medium, tags: array, divide and conquer, dynamic programming, prefix sum, companies: ltk.

tips for installing sortedcontainers in a python shell

Solutions for LeetCode 1041 LintCode 1345 GFG HackerRank, medium, tags: math, string, simulation, companies: linkedin, salesforce.

Solutions for LintCode 3127, easy, tags: math, bit.

Solutions for LeetCode 1346, easy, tags: array, hash table, two pointers, binary search, sorting.

Solutions for LeetCode 91, medium, tags: string, dynamic programming, companies: goldman sachs, vmware, salesforce.

cheatsheet for math knowledge needed for leetcode algorithm questions, geometric series sum

Solutions for hackerrank bitwise xor operations, medium, tags: bit, companies: salesforce.

Fun bitwise tricks such as count set bits, negate, ilog2, xor swap, .etc.

Solutions for LeetCode 3167 HackerRank Better Compression, tags: string, hash table, companies: salesforce.

Solutions for LeetCode 239, LintCode 678, medium, tags: two pointers, string, kmp, rabin-karp, rolling hash.

Solutions for LeetCode 146 LintCode 134, medium, tags: hash, linked list, design, doubly linked list, companies: amazon, openai.

Solutions for LeetCode 487, LintCode 833, medium, tags: array, dynamic programming, sliding window, two pointers, companies: google.

Solutions for LeetCode 1 similar, medium, tags: array, hash table, companies: salesforce.

Solutions for LeetCode 811 and LintCode 1006, medium, tags: array, hash, string, counting, companies: salesforce.

Solutions for LeetCode 1804 LintCode 3729, medium, tags: design, trie, hash, string.

Solutions for LeetCode 38, LintCode 420, medium, tags: math, string, simulation, companies: facebook, pinterest.

Solutions for LeetCode 38, LintCode 420, medium, tags: math, string, simulation, companies: facebook, pinterest.

three main ways to embed an SVG image or picture as a file or using html code on a website

tips for using vim

Solutions for LeetCode 465 LintCode 707, hard, tags: bit, array, dynamic programming, backtracking, bitmask.

Solutions for Elevator Shortest Path, medium, tags: array, binary search.

Solutions for LeetCode 2257, medium, tags: array, graph, simulation.

tips for using google voice, mark all as read

Solutions for LeetCode 2461, medium, tags: array, sliding window, hash.

Solutions for LeetCode 1652, easy, tags: array, sliding window.

Solutions for LeetCode 1055 LintCode 3652, hard, tags: greedy, two pointers, string.

Solutions for LintCode 2894, medium, tags: map, sort. Related to LeetCode 884 and 451.

Solutions for LeetCode 862, LintCode 1507, hard, tags: array, queue, sliding window, heap, monotonic queue, binary search, prefix sum.

Solutions for LeetCode 3254, medium, tags: array, sliding window.

Solutions for LeetCode 125, LintCode 415, easy, tags: two pointers, string. Companies: LinkedIn, Facebook, Uber, Zenefits, Microsoft.

Solutions for LeetCode 1930, medium, tags: hash, string, bit, prefix sum.

Solutions for LeetCode 2064, medium, tags: array, binary search, heap.

Solutions for LeetCode 2563, medium, tags: array, two pointers, binary search, sorting.

solutions for LeetCode 3043, hard, tags: trie, string, array, hash.

solution for lintcode 179 update bits, tags: bit

add discord and disqus to this site

solutions for LeetCode 314 LintCode 651 Binary Tree Vertical Order Traversal, tags: hash, bfs, tree, companies: facebook google

solutions for LeetCode 1192, LintCode 1271, hard, tags: dfs, graph, bi-connected component. Companies: Amazon.

solutions for LeetCode 239, LintCode 362, hard, tags: array, queue, sliding window, heap, monotonic queue. Companies: Amazon, Zenefits, Microsoft, Google.

Solutions for LeetCode 1574, medium, tags: array, binary-search, two-pointers.

Solution for leetcode 3133 Minimum Array End, tags: bit

solution for leetcode 3097 Shortest Subarray With OR at Least K II, tags: bit, sliding-window, array

solution for LeetCode 20 LintCode 423 valid parentheses, tags: stack, string; companies: goldman sachs, twitter, airbnb, amazon, facebook, microsoft, bloomberg, uber, google.

tips for using databases including mongodb, microsoft sql server, mysql

tips for software development in Windows Operating System

tips and cheatsheet for python data/AI projects using conda, docker, and jupyter notebook

tips for using mac