Public Preview + Member Training Tool

The CCF Dictionary

A reasoning language for algorithms, data structures, and proof.

The public Dictionary introduces the core CCF vocabulary. Master DSA members unlock applied examples, Case File references, proof translations, and code-level usage.

Public Preview

More Than a Glossary

A glossary defines words. A reasoning dictionary explains how each concept helps you think, decide, repair, prove, and build correct solutions. In the CCF, terms are not labels to memorize; they are tools for seeing the structure of a problem.

How to Use the Dictionary

Move from language to practice.

1

Learn the language

Start with the terms the CCF uses to name reasoning decisions.

2

Study the pipeline

See how Intent, Frames, Constraints, Invariants, and Proof connect.

3

Apply the terms

Use case files to practice the language inside real investigations.

4

Train with guidance

Move into membership when you want structured practice and progression.

Role-Based Taxonomy

Structures, Recorders, and Algorithms

Name what information is, what must survive, and how lawful movement occurs before choosing a familiar technique.

Why separate structure from role?

A container is not a strategy. The same structure can hold original evidence, record facts for later frames, enforce an access law, or represent the answer. CCF classifies tools by the job they perform so selection follows evidence instead of pattern memory.

A data structure defines a form of evidence control. An algorithm defines the lawful procedure that operates on that evidence.

Evidence Space Structures

These structures contain the evidence the scanner must inspect.

  • Array: indexed, ordered evidence.
  • String: ordered character evidence.
  • Linked List: node evidence joined by explicit links.
  • Matrix / Grid: evidence arranged by row, column, and neighborhood.

Relationship Space Structures

These structures make relationships—not positions—the primary evidence.

  • Tree: hierarchical parent-child relationships.
  • Binary Tree: at most two child routes per node.
  • Binary Search Tree: a tree with a comparison invariant.
  • Graph: general node-and-edge relationships.
  • Trie: shared-prefix relationships.

Access-Law Structures

These structures restrict which recorded item may be accessed next.

  • Stack: last in, first out.
  • Queue: first in, first out.
  • Deque: insertion and removal at both ends.
  • Priority Queue: highest-priority item first.

Recorder and Lookup Structures

These preserve facts later frames cannot afford to rediscover.

  • HashMap / Dictionary: key-to-evidence lookup.
  • HashSet / Set: membership without duplicates.
  • Counter / Frequency Map: occurrence counts.
  • Visited Set: discovered or completed states.
  • Memo Table: solved subproblems.
  • Cache / LRU: reusable results under an eviction law.

Optimization and Query Structures

These maintain enough organization to answer repeated selection, connectivity, or range questions efficiently.

Heap: maintains an extremum under updates.
Union-Find: maintains changing connectivity.
Segment Tree: records hierarchical range aggregates.
Fenwick Tree: records prefix aggregates with compact update paths.

Algorithms Are Procedures, Not Containers

An algorithm defines movement, decisions, repair, or construction. It acts on structures; it is not the structure itself.

Linear Scan: evaluates evidence in sequence.
Binary Search: eliminates half of a monotonic space.
Two Pointers: coordinates two positions.
Sliding Window: expands evidence and repairs a contiguous frame.
BFS: explores relationships level by level.
DFS: follows one route deeply before returning.
Backtracking: chooses, tests, and reverses decisions.
Dynamic Programming: records reusable dependent-frame results.
Greedy: commits to a locally lawful choice supported by proof.
Sorting: reorganizes evidence to expose order.
Divide and Conquer: splits, solves, and combines regions.
CategoryPrimary questionExamples
Evidence SpaceWhere does the original evidence live?Array, String, List, Grid
Relationship SpaceWhich relationships define lawful routes?Tree, Graph, Trie
Access LawWhich recorded item may be accessed next?Stack, Queue, Deque
Recorder / LookupWhat fact must survive this frame?Map, Set, Memo, Cache
Optimization / QueryWhat repeated query must stay efficient?Heap, Union-Find, Range Trees
Algorithm / ProcedureHow will the solution move and decide?Scan, Search, BFS, DP
Dictionary Entries

Core CCF Reasoning Terms

Study the full pipeline
Core Reasoning

Base Container

The foundational wrapper of a CCF solution. It establishes the identity of the solution and holds every reasoning component added during the Reasoning Pipeline. At the Base layer, only the solution name is defined. No data structure, algorithm, pattern, operation, scanner, recorder, finalizer, or implementation decision is selected at this stage.

Read Entry
Core Reasoning

Reasoning Pipeline

The ordered analysis process used to build a solution: Base Container, Answer Space, Problem Space, Decision Space, and Implementation. The Reasoning Pipeline describes how the learner moves through analysis.

Read Entry
Core Reasoning

Reasoning Stack

The completed reasoning structure produced by the Reasoning Pipeline. Conceptually, Decision Space is stacked on Problem Space, Problem Space on Answer Space, and Answer Space on the Base Container. The Reasoning Pipeline builds the Reasoning Stack.

Read Entry
Core Reasoning

Invariant

In a sliding window, the invariant might be that the current window contains no duplicate characters.

Read Entry
Spaces

Problem Space

The part of an algorithm's reasoning signature that defines what the solution receives, including the inputs, parameters, data structures, values, and constraints that describe the problem.

Read Entry
Core Reasoning

Context Clue

A word, phrase, constraint, guarantee, or relationship inside the Problem Statement that tells the learner what must be returned, what structure is being inspected, which movements are legal, or when failure is allowed.

Read Entry
Spaces

Answer Space

The part of an algorithm's reasoning signature that defines what the solution must produce, including the output value, return type, shape, and required result.

Read Entry
Movement

Scanner

A two-pointer scanner can move inward from both ends of a sorted array.

Read Entry
State and Memory

Recorder

In Two Sum, a hash map records numbers already seen and their indices.

Read Entry
Correction

Repair

When a sliding window contains a duplicate, moving the left pointer repairs the window.

Read Entry
Proof and Finalization

Finalization

After collecting a reversed list of characters, finalization may join them into the returned string.

Read Entry
Proof and Finalization

Proof

For binary search, proof explains why the discarded half cannot contain the answer.

Read Entry
Spaces

Evidence Space Structure

An array is the Evidence Space Structure in Two Sum.

Read Entry
Spaces

Relationship Space Structure

A graph represents cities and the routes connecting them.

Read Entry
Movement

Access-Law Structure

A queue enforces level-order access during BFS.

Read Entry
State and Memory

Recorder Structure

A hash map records seen values and their indices in Two Sum.

Read Entry
Core Reasoning

Algorithm

Binary search repeatedly eliminates an illegal half of a monotonic search space.

Read Entry
Core Reasoning

Operation

Moving the left boundary is a repair operation in a sliding window.

Read Entry
Starter
Expanded Dictionary

Connect the language to the first 25 investigations.

Starter members unlock expanded definitions and Case File references for the first 25 investigations.

Applied examples reveal where the Scanner moves, what the Recorder preserves, and how the Invariant controls each decision.
Compare Membership Plans
Master DSA

Translate reasoning into proof and code.

Master DSA unlocks proof translations, code-level usage, common mistakes, and advanced decision checklists.

Initialization establishes the truth. Maintenance preserves it. Termination connects the maintained state to the required answer.
Compare Membership Plans
Next Step

Learn the Language. Then Train the Reasoning.

The dictionary gives you the language. CCF case files teach you how to apply that language to real algorithm, system, and software design problems.