Here are some useful blogs I found in CodeForces.

Note that:

- This list can be treated as an extension of catalog, since much of these tutorials are included in catalog but the others are collected by myself.
- The same blog may be included in this post twice or more.
- Blogs to ask questions are
**NOT**included in this blog, since they seemed not quite useful to CP. - If there are any blogs that I have missed, please tell me in the comment section. Thank you very much.

Hint: you can use Ctrl+F to search for information here.

# General Advices

## Micellaneous

- How to use Codeforces [GUIDE]
- [Tutorial] The command line: how to read input from file without #ifdef and much more
- After a Round FAQ
- [Tutorial] How to read editorials
- Pro Tips — get them while they are free
- Interactive Problems: Guide for Participants

## How to come up with solutions?

- How to read problem statements
- How to come up with the solutions: techniques
- Characteristics of the optimal solution, a technique for finding observations in a problem
- On "is this greedy or DP", forcing and rubber bands
- How to prove your solutions in Competitive Programming
- How to solve problems

## How to practice?

- F.A.Q. (in PM)
- My opinion on how to practice competitive programming
- Self-deception: maybe why you're still grey after practicing every day
- How to practice Competitive Programming [Um_nik version]
- [Tutorial] A Way to Practice Competitive Programming : From rating 1000 to 2000
- [Tutorial] How to learn better, and what most people don't get about learning

## How to ask for help?

# Algorithms

## Micellaneous

- [Tutorial] Collection of little techniques
- General ideas
- A bit more of general ideas
- Tricks that I learnt while practicing

## Binary and Ternary Searches

- EDU: Binary Search
- The most comprehensive Binary Search lecture
- Binary search implementation
- Binary search on real values
- Bin search and relative error
- [Tutorial] Binary search and other "halving" methods
- Parallel Binary Search [tutorial]
- Tutorial On Tof (Ternary Search)
- Multi-dimensional ternary search
- Binary Lifting, No Memory Wasted

## Constructive Algorithms

## Data Structures

### Micellaneous

- Algorithm Gym :: Data Structures
- [Tutorial] Supporting Queue-like Undoing on DS
- [Tutorial] Supporting Priority-Queue-like Undoing on DS
- [Tutorial] Kinetic Tournament (Used in FBHC Round 2)
- Tutorial on Permutation Tree（析合树）
- Introduction to New Data Structure: Wavelet Trees
- [Tutorial] On Range LIS Queries, Part 1
- [Tutorial] On Range LIS Queries, Part 2
- Sqrt-tree: answering queries in O(1) with O(NloglogN) preprocessing.
- [Tutorial] Minimum Deque
- Palindromic tree: behind the scenes
- A bit more about palindromes
- Unknown Data Structure — (Sqrt Fragmented Tree)
- [Tutorial] Reachability Tree / DSU-tree
- A Well-known Data Structure -- Version Tree

### Fenwick Trees(BIT)

- Binary Indexed Tree
- [Tutorial] Searching Binary Indexed Tree in O(log(N)) using Binary Lifting
- Understanding Fenwick Trees / Binary Indexed Trees
- Nifty implementation of multi-dimensional Binary Indexed Trees using templates.
- [Tutorial] A Bit of Math, Historic Sum, and Range Add Range Sum Binary Indexed Tree (Fenwick Tree)
- [Tutorial] Initializing Binary Indexed Trees in linear time
- Fenwick tree: initialization in O(N)
- [Tutorial] "1354D — Multiset" + A Gentle Introduction to Fenwick Trees

### Segment Trees

#### Ordinary Segment Trees

- EDU: Segment Tree, part 1
- Algorithm Gym :: Everything About Segment Trees
- Segment Tree
- Generalizing Segment Trees with Rust
- Efficient and easy segment trees
- An efficient way to strengthen up your segment tree.
- crazySegmentTree: Segment Tree implementation with 5x faster queries than bottom-up tree
- Segment tree with insertion and deletion operators.
- Push-Free Segment Tree
- Easy and (Semi)Efficient Dynamic Segment Trees (with Policy Hash Tables)
- Compressed segment trees and merging sets in O(N logU)
- using merging segment tree to solve problems about sorted list
- Minimum memory consumption by the segment tree
- Non-recursive segment tree tutorial
- Should you practice segment tree if you are below purple?
- [Video Tutorial] Majority Element Range Queries (Segment Tree)

#### Other Segment Trees

- [Tutorial] XOR Segment Tree
- Modular Segment Tree with Lazy Propagation
- AlgorithmsThread Ep 3: Segment Trees (+ hard ST Problem)

#### Segment Tree Beats

- A simple introduction to "Segment tree beats"
- Video: Segment Tree Beats
- AlgorithmsThread Ep 4: Segment Tree Beats

#### Segment Tree Problems

### Binary Search Trees

#### Balanced Trees

- AVL tree without "big rotations"
- "Merging treaps" -- or how to merge sorted sets in good complexity...
- Algorithms Thread 9: Treaps (+ Gym Contest!)
- [Tutorial] Splay Tree: One Tree to Rule Them All
- Splay tree and its implementation.
- Splay tree tutorial

#### Cartesian Trees

- Cartesian tree
- [Tutorial] Cartesian tree and some related problems
- Implicit cartesian tree in GNU C++ STL.

#### Link-cut Trees

- Link-cut tree tutorial
- Maintain subtree information using link/cut trees
- [Tutorial] Subtree lazy propagation on the link-cut tree

### Disjoint Set Union

- EDU: DSU
- [Tutorial] Proving the inverse Ackermann complexity of Union-Find
- DSU with randomized linking is as fast as with rank heuristic

### Sparse Table (To Solve RMQ Problems)

- [Tutorial] Sparse table
- [Tutorial] Sparse table
- About performance of sparse tables
- [Tutorial] Range minimum query in O(1) with linear time construction
- 2D Range Minimum Query in O(1)
- On Multidimensional Range Queries
- Memory-optimal Range Queries and Updates in logN
- Some method for solving RMQ
- Algorithms Dead Episode 2: RMQ Tricks!

### Persistent Data Structures

### Other Integer Sets

- [Tutorial] A powerful representation of integer sets
- Partially Ordered Sets
- About ordered set
- Venice Technique

### Solving Other Problems Using Data Structures

## Divide-and-conquer

- Dynamic connectivity problem
- Divide and conquer. Dynamic connectivity offline and DP optimization. Divide and conquer by queries.
- [Tutorial] Divide and Conquer Offline Query — A Niche Way to solve Static Range Query
- The Akra-Bazzi theorem — a generalization of the master theorem for recurrences

## Dynamic Programming

### Micellaneous

- Dynamic Programming Type
- Everything About Dynamic Programming
- Dynamic Programming Optimizations
- [Tutorial] Non-trivial DP Tricks and Techniques

### Types of DP

#### Micellaneous

- A little bit of classics: dynamic programming over subsets and paths in graphs
- [Tutorial] Recurrent Sequences — Application of combinatorics in DP (basics)
- Kadane's Algorithm — (Dynamic Programming) — For new Solvers!
- [Tutorial] Dp with connected components, a simple way to understand it.
- [Tutorial] Product Trick
- Tutorial — "Randomized" DP leading to state elimination
- Hirschberg's Algorithm

#### Knapsack

#### DP on Trees

#### SOS DP

#### Digit DP

#### Plug DP

### Optimization

#### Micellaneous

- 1D1D-optimization
- [Tutorial]Using Segment Trees to solve Dynamic Programming problems
- Theoretical grounds of lambda optimization
- Incredibly beautiful DP optimization from N^3 to N log^2 N
- Simple DP optimizations
- DP on Function Calls — Remove a Log Factor
- Dynamic Programming Optimizations ( Problems )

#### Convex Hull Trick

- On convex hull trick and e-maxx-eng
- [Tutorial] Convex Hull Trick — Geometry being useful
- Tiny Dynamic Convex Hull Implementation
- Efficient 3D Convex Hull Tutorial
- Dynamic convex hull implementation
- Fully Persistent Convex Hull Trick
- AlgorithmsThread Episode 6: Convex Hull Tricks

#### Slope Trick

## Geometry

- Geometry: 2D points and lines [Tutorial]
- Geometry: Polygon algorithms
- Easy geometry using std::complex
- [Tutorial] Solving Interval Problems with Geometry
- Some rotational invariants in geometry
- Extremal Triangles
- [Tutorial] Voronoi Diagram and Delaunay Triangulation in O(n log n) with Fortune's Algorithm
- Quaternion algebra and geometry
- Geometry shrink trick
- Pythagorean triples and Pell's equations
- [Tutorial] Nearest Neighbor Search: Locality-Sensitive Hashing, K-Dimensional Tree, Vantage-Point Tree
- AlgorithmsThread 7: All Point Pairs

## Game Theory

- Nim (Algorithmic Game)
- The Intuition Behind NIM and Grundy Numbers in Combinatorial Game Theory
- Nimbers and Sprague-Grundy theorem
- A blog on the Sprague-Grundy Theorem
- [Tutorial] Slight Generalization of Grundy Numbers

## Graph Theory

### Micellaneous

- Algorithm Gym :: Graph Algorithms
- Basic Graph Theory
- Graph Theory Concepts and Problems.
- [Tutorial] 2-SAT
- 2-SAT Tutorial
- Vertex cover and 2-SAT
- Faster Dijkstra on Special Graphs [Tutorial]
- Add edges to a digraph to make it strongly connected
- Articulation points and bridges (Tarjan's Algorithm)
- Online Query Based Rerooting Technique
- Heuristic algorithm for Hamiltonian path in directed graphs
- Traversing the complement graph in linear/near-linear time in multiple ways
- Story about edge coloring of graph
- Merging Queries Trick
- A Brief Inquiry into Online Connectivity

### DFS

- [Tutorial] The DFS tree and its applications: how I found out I really didn't understand bridges
- My own algorithm — offline incremental strongly connected components in O(m*log(m))

### Shortest Paths

- 0-1 BFS [Tutorial]
- [Tutorial] 1-K BFS
- [Tutorial] k shortest paths and Eppstein's algorithm
- Rethink the Dijkstra algorithm -- Let's go deeper
- [Tutorial] The Floyd-Warshall algorithm and its generalizations
- Shortest Path Modelling Tutorial

### Trees

#### Micellaneous

- A list of important concepts in Tree-based Problems
- Algorithms Thread 8: Tree Basics (+ Gym Contest)
- On Euler tour trees
- [Insight] Number of Topological Orderings of a Directed Tree
- [Tutorial] Path sum queries on a tree using a Fenwick tree
- Bridge Trees [Tutorial]
- Finding Bridges Tutorial
- [Tutorial] Binary lifting
- [Tutorial] Tree Isomorphism CSES
- [Tutorial] Diameter of a tree and its applications
- [Tutorial] Fully Dynamic Trees Supporting Path/Subtree Aggregates and Lazy Path/Subtree Updates
- Optimal 2/3 halving in interactive tree problems
- K-th smallest edge on a tree's path, a tutorial about its approaches
- [Tutorial] Boruvka's Algorithm
- The Ultimate Reroot Template

#### Heavy-Light Decomposition

- Hybrid Tutorial #-1: Heavy-Light Decomposition
- Heavy-light decompositon — it can be simple!
- Easiest HLD with subtree queries
- Heavy-light decomposition implementation
- [Idea] Using HLD to reduce memory
- [Tutorial] Theoretically Faster HLD and Centroid Decomposition
- Non-Recursive HLD Implementation
- Tutorial on Heavy Light Decomposition + Problems

#### Centroid Decomposition and similiar

- Centroid Decomposition on a tree(Beginner)
- Hybrid Tutorial #-2: Centroid Decomposition
- [Tutorial] Theoretically Faster HLD and Centroid Decomposition
- Shallowest Decomposition Tree

#### DSU on Trees

#### LCA

##### Micellaneous

- [Tutorial] a few strange lca algorithms with a few strange time complexities pt 1
LCA in logN — Binary lifting, Video tutorial

##### Problems

- LCA problems

#### Tools

### Matching

- [Tutorial] Blossom Algorithm for General Matching in O(n^3)
- Randomized general matching with Tutte matrix

### Flows

- [Tutorial, Flows] Project Selection Problem
- [Tutorial] My way of understanding Dinitz's ("Dinic's") algorithm
- [Tutorial] Minimum cost (maximum) flow
- [Tutorial] More about minimum cost flows: potentials and Dinitz
- [Tutorial] Network simplex
- Kőnig's and Hall's theorems through minimum cut in bipartite graphs
- [Tutorial] Simulating Cost Flow
- Implementing Dinitz on bipartite graphs
- [Tutorial] Graph Potentials, Johnson's Algorithm, and Min Cost Max Flow

## Greedy Algorithms

- [Tutorial] Matroid intersection in simple words
- [Tutorial] Greedoids: a formal way to look at families of greedily-solvable problems

## Hashing

### Micellaneous

- [Tutorial] Rolling hash and 8 interesting problems [Editorial]
- Analysis of polynomial hashing
- Kapun's algorithm
- On the mathematics behind rolling hashes and anti-hash tests
- XOR Hashing [TUTORIAL]

### Hacking about Hashing

- Blowing up unordered_map, and how to stop getting hacked on it
- Anti-hash test.
- [Tutorial] Hacking a weak hash
- On the mathematics behind rolling hashes and anti-hash tests

## Minima/Maxima

## Mathematics

### Micellaneous

- Number of Solutions to a Linear Algebraic Equation
- An interesting algebraic construction
- [Tutorial] 2-SAT
- 2-SAT Tutorial
- [Tutorial] Floors, ceilings and inequalities for beginners (with some programming tips)
- An efficient way to solve some counting problems without matrix multiplication

### Bitwise Operations

- Bitwise operations for beginners
- Bitwise operations 2 — popcount & bitsets
- A Beautiful Technique for Some XOR Related Problems
- XOR basis without linear algebra

### Number Theory

#### Micellaneous

- Essentials of Elementary Number Theory
- Finding minimum residue of a linear function in O(log M) time
- On the Min25 sieve and extensions / SPOJ ASSIEVE
- [Tutorial] Chinese Remainder Theorem
- p-adic exponent or why there is a primitive root modulo powers of prime numbers (except 2)
- [Tutorial] Berlakamp's Algorithm for Polynomial Factorization in a Field (1698G buffed)
- [Tutorial] Euler's phi function, its properties, and how to compute it
- Lucas Theorem is not an equation, it's an operation!
- Recovering rational number from its remainder modulo huge integer
- Integer solutions to x² + y² = z
- Number of positive integral solutions of equation 1/x+1/y=1/n!

#### Modular Arithmetic

#### Modular Inversion

#### Primes & Divisors

- Counting Divisors of a Number in $$$O(N^{\frac{1}{3}}$$$) [tutorial]
- Counting primes in $O(n^{2/3})$
- Implicit Prime Factorisation
- [Tutorial] Number theory — Storing information about multiples/divisors

#### Prime Sieve

- Prime Factorization In log(n) After Sieve
- Extensions of the Prime Sieve
- Sieve Methods : Prime, Divisor, Euler Phi etc.

#### Möbius Inversion

#### Dirichlet Convolution

- [Tutorial] Math note — Dirichlet convolution
- Dirichlet convolution. Part 1: Fast prefix sum computations
- Dirichlet convolution. Part 2: Dirichlet series and prime counting

### Probability Theory

- Sums and Expected Value — part 1
- Sums and Expected Value — part 2
- [Tutorial] Expected number of coin flips required to achieve a given string
- Probability 101, the intuition behind martingales and solving problems with them

### Combinatorics

#### Micellaneous

- [Tutorial] Inclusion-Exclusion Principle
- Young Tableaus and the Hook Length Formula
- [Tutorial] Invariants and Monovariants
- An intuition and simpler proof for Kirchoff's tree theorem
- Lattice paths and Lindström–Gessel–Viennot lemma
- MacMahon's master theorem

#### Burnside Lemma

- [Tutorial] Burnside's lemma (with example)
- [Tutorial] From Burnside to Polya: A Short Introduction to Group Theory

#### Stirling & Catalan Numbers

- Stirling numbers with fixed n and k
- Catalan Numbers and Generating Uniform Balanced Bracket Sequences
- [Tutorial] Catalan Numbers and Catalan Convolution

### Linear Algebra

- A Beautiful Technique for Some XOR Related Problems
- Linear Basis (Xor Basis Extended)
- 2 Special cases of Gaussian [Tutorial]

### Matrix

### Permutations

- [Tutorial] A comprehensive guide to permutations for beginners
- Permutation group basis construction (Schreier–Sims algorithm)
- Derangement Generation of an Array [Tutorial]
- An efficient way to map a permutation (length 11 or 12) to an integer without using std::map

### Polynomials, Series and Recurrences

#### Micellaneous

- Lagrange inversion theorem
- Lagrange interpolation and partial fraction decomposition
- Computing n! modulo pᵏ for small p
- Calculating Series Sums with Binary Exponentiation

#### Generating Functions

- Generating Functions in Competitive Programming (Part 1)
- Generating Functions in Competitive Programming (Part 2)
- A problem collection of ODE and differential technique
- Prefix Sum Polynomial
- Combinatorial species: An intuition behind generating functions
- Unlabeling combinatorial species (cycle index series)
- Moment-generating functions, inversions and q-analogs
- OGFs, EGFs, differentiation and Taylor shifts
- Fast polynomial composition
- Solving the "simple math problem" with generating functions
- Useful substitutions with generating functions
- Partitions and pentagonal number theorem
- Arrow product: How to enumerate directed graphs
- Shift of polynomial sampling points
- Unexpected application of cosines
- [Math note] On the relationship between gf and me

#### FFT and Similar Transformations

- [Tutorial] FFT
- Tutorial on FFT/NTT Part 1
- Tutorial on FFT/NTT Part 2
- Fast Fourier Transform and variations of it
- Operations on Formal Power Series
- Operations on polynomials (on cp-algorithms)
- Fast convolution for 64-bit integers
- CDQ convolution (online FFT) generalization with Newton method
- Notes on FFT / NTT, and the "ultimate" NTT with modulus > 9 * 10^18
- [Tutorial] Generalized Chirp Z-Transform
- Discrete Fourier Transform eigenvalues
- A simple way to understand the transposed algo of multi-eval
- An unexpected D&C with FFT
- Tutorial: A simple O(n log n) polynomial multiplication algorithm
- Introducing the imaginary cyclic convolution, speeding up convolution by a factor of 2

#### Bitwise Convolutions

- Generalized FWHT: How I realized I did not understand FWHT
- Tutorial on Zeta Transform, Mobius Transform and Subset Sum Convolution
- Fast Walsh Hadamard Transforms and it's inner workings
- Subset convolution interpretation
- Optimal Algorithm on Polynomial Composite Set Power Series
- OR Convolution for Common People
- [Tutorial] GCD Convolution
- [Tutorial] Zeta, Mobius Transform to AND, OR, GCD Convolution

#### Linear Recurrences

- Linear Recurrence and Berlekamp-Massey Algorithm
- [Tutorial] Berlekamp-Massey
- On linear recurrences and the math behind them
- Recovering a linear recurrence with the extended Euclidean algorithm
- [Tutorial] Solving Linear Recurrences with various methods, Including O(N logN logK) using FFT
- Hadamard product and binomial convolution of linear recurrences
- Half-GCD algorithm

### Optimizations

- Multi-dimensional ternary search
- Theoretical grounds of lambda optimization
- Duality in linear programming. Part 1 — definition and construction
- Duality in linear programming. Part 2 — in competitive programming

### Abstract Nonsense

- Permutation group basis construction (Schreier–Sims algorithm)
- Associativity and general identity testing

## Non-exact and Randomized Algorithms

- [Tutorial] Simulated Annealing in Competitive Programming
- Randomized algorithms lecture, part 1 & 2
- On the Number of Runs at the Monte-Carlo Method
- Randomized general matching with Tutte matrix
- How randomized solutions can be hacked, and how to make your solution unhackable
- Increase the chance of a random algorithm passing by abusing TLE verdict on Codeforces

## Sortings

## Square Root Techniques

### Micellaneous

- [Tutorial] Square Root Techniques
- Sqrt-tree: answering queries in O(1) with O(NloglogN) preprocessing.
- Sqrt-tree (part 2): modifications in O(sqrtN), lazy propagation
- Unknown Data Structure — (Sqrt Fragmented Tree)
- [Tutorial] Subset Sum Square Root Optimisation

### SQRT Decomposition

- [Tutorial] Square root decomposition and applications
- What's slower than a segment tree and needs some more space to be free ?

### Mo's Algorithm

- Mo's Algorithm
- Mo's Algorithm on Trees [Tutorial]
- An alternative sorting order for Mo's algorithm
- Mo's Algorithm (with update and without update, now you can understand both)
- [Tutorial] Two ways to apply Mo's Algorithm on Trees
- [Video Tutorial] Range Queries with Mo's Algorithm

## Strings

### Micellaneous

- Palindromic tree: behind the scenes
- A bit more about palindromes
- The history of some recurring problem
- [Tutorial] Expected number of coin flips required to achieve a given string
- Random notes on Lyndon decomposition
- Hunt-Szymanski Algorithm Explained (LCS but optimized for special cases)

### KMP Algorithm

### Trie

### AC Automata

### Manacher's Algorithm

### Suffix Automata/Trees/Arrays

- Suffix tree. Basics. Building in O(nlogn)
- Suffix tree. Ukkonen's algorithm
- suffix automata
- A short guide to suffix automata
- [Tutorial] Dynamic Suffix Arrays
- Obtaining suffix array from suffix automaton

### Z Algorithm

### Other Matchings

- [Tutorial] Dictionary of Basic Factors — O(1) String Matching
- [Tutorial] On Variations of String Matching

## Sweeping Line

- How to sweep like a Sir
- [Tutorial] Finding inclusion hierarchy among circles — An implementation of a sweep-line algorithm

## Two Pointers

# C++

## Tips & Tricks

- C++ Tricks
- C++ tips and tricks
- Template Metaprogramming in C++ Part 1 / Infinity
- [Tutorial] On lambdas, C++ and otherwise: the what, the why, and the how
- Competitive C++ Manifesto: A Style Guide
- C++11 for programming contests...
- C++17, competitive programming edition
- N Dimensional Vector (For std::vector Addicts!)
- Don't use rand(): a guide to random number generators in C++
- A way to use C++ iostream for large input (gcc only)
- Explanation to weird/strange floating point behaviour in C++
- How NOT to use macros
- Performance tip : using std::deque as a memory cache
- How to get actual 64 bit bitsets on Codeforces [Not Recommended] [Don't do this at your job]
- [Tutorial] Writing C++ like Python: tricks Python doesn't want you to know
- [C++] Avoiding temporaries — generalizing i++ using std::exchange

## Debugging Tools

## Optimization

- [Tutorial] GCC Optimization Pragmas
- Tutorial on SIMD vectorisation to speed up brute force
- 4-5x Faster Drop-in Replacement for std::lower_bound

## Hacking

## STL & Policy Based Data Structures

- C++ STL: Policy based data structures
- C++ STL: Policy based data structures. Part 2
- Implicit cartesian tree in GNU C++ STL.
- Generic data structure templates via C++ mixins
- About a general reader / writer for STL-Structures,

# Meta

## CodeForces Extensions

- CF-Predictor — Know your rating changes!
- Codeforces Practice Tracker — Browser Extension
- Presenting Codeforces Optimal Theme
- UpSolve.me | Efficient Codeforces Practice
- Colorize standings by used programming language
- Average number of problems solved during a contest per rating
- Multiple rating graph with other accounts
- Have you already seen the history of ratings on clist?
- Codeforces Problem Tracker Chrome Extension
- CF Static Site Enhancer — Browser Extension
- [chrome extension] Codeforces Customizer
- Google Chrome extension for automatic sample case testing on Codeforces
- Dark mode in codeforces
- Chrome/Firefox Extension to analyse Codeforces profiles
- [BrowserExtension] : New Year Before New Year?
- Gym Finder
- Userscript: table view in Catalog
- Finally, semantic search for competitive programming problems
- Codeforces Visulaizer

## Other Tools

## Code Libraries

- AtCoder Library
- New online judge: Library-Checker!
- (The Ultimate) Code Library
- Introduction to CPLib — Modern C++ Library for Test Data in CP

# Problem and Contest Preparation

## Polygon

### Tips

- 10 Reasons to Prepare Problems in Polygon
- [Tutorial] Polygon.Codeforces Tutorial — A Guide to Problem Preparation [Part 1]
- [Tutorial] How to use polygon.codeforces in problem preperation?
- Polygon: Warnings for Packages — Incomplete Tests + Statement/Validator Mismatches
- Polygon: AI-Powered Automatic Tips
- Automatic Translation of Problem Statements in Polygon

### Updates

- Polygon Updates (Fall-Winter 2014)
- Testlib and Polygon Updates (June, 2015)
- Testlib and Polygon Updates [July, 2018]
- Polygon updates (June-October 2019)
- Polygon Updates (June — August 2021)

## Preparing with testlib.h

- Briefly about testlib.h
- Generators with testlib.h
- Validators with testlib.h
- Checkers with testlib.h
- Interactors with testlib.h
- Testlib: Opts — parsing command line options
- Testlib: tests + CI

## Problemsetting

- How to come up with problem ideas
- Way of problemsetter
- What is it like to be a problem writer?
- Problemsetter's Memoir
- On problemsetting
- On problemsetting 2
- About Problemsetting (for AtCoder and Codeforces)
- [Problemsetting] How to write editorials for a contest
- Insights from testing and preparing contests, and why problemsetting trends need to change

Nice and helpful for everyone.

very good

Oh pretty good

Great work!

two pointer method link seems not working

It is working. You have to take part in pilot course beforehand.

Thanks, lad

thanks

Thanks bro

Thank you very much.

Great work, Thank You!!

Bookmarking this!