Beta 0.35.0Beta

Dashboard
Learn
Exercises
Challenges
Compete
Visualizer

Dashboard
Learn
Exercises
Challenges
Compete
Visualizer

What's newv0.35.0

Profile

Dashboard Learn Exercises Challenges

SearchSearch for a chapter, module, exercise, challenge, page, or profile

Dashboard
Learn
Exercises
Challenges
Compete
Visualizer

Back to profile

Learn C

ban's path

View graph

66/14266 / 142 required exercises46%

Chapters

Structure your code

You compile, you print, and you read what the compiler tells you.

1 / 5 complete5 modules

First programCompleteThe edit, compile, read the verdict loop.7/77 / 7 required1 to 2

Read the errorIn progressReading a compiler diagnostic and fixing the line it points at.3/5

Structure your code

You split a problem into functions and reach values through pointers.

0 / 4 complete

Text

You read, write and transform text without ever leaving the buffer.

3 / 6 complete

Memory

You own every allocation you make, and you can prove there is no leak.

Your own types

You model data with your own types and hide them behind an interface.

0 / 5 complete

The machine

You reason about bits, cost and files the way the machine does.

0 / 4 complete

The system

You make processes talk to each other without ever blocking.

0 / 1 complete

3 / 5 required

1 to 2

Types and valuesIn progressInteger types, implicit conversions, promotions and overflow.1/71 / 7 required2 to 3

Conditions and loopsIn progressBranching and the three loop forms, chosen on purpose.5/75 / 7 required2 to 3

Command lineIn progressReading `argc` and `argv`, and reporting a bad invocation.5/65 / 6 required2 to 3

4 modules

FunctionsIn progressDeclaration, definition, and the contract a function honours.4/54 / 5 required2 to 4

RecursionIn progressBase case, recursive case, and the call stack underneath.2/62 / 6 required2 to 3

PointersIn progressAddress, dereference, output parameter, and the half-open range.3/73 / 7 required2 to 4

Arrays and matricesIn progressOne and two dimensional arrays, row-major order, and array decay.2/72 / 7 required2 to 4

6 modules

Characters and ASCIICompleteThe byte as a value, the ASCII table, and the classification predicates.4/44 / 4 required2 to 2

Strings: walking and searchingCompleteA string is an array of bytes plus its terminator, and nothing more.6/66 / 6 required2 to 4

Writing text without overflowingCompleteCapacity, termination, and the truncation you have to decide on.4/44 / 4 required3 to 4

Words and tokensIn progressWord boundaries, tokenising, and normalising whitespace.2/42 / 4 required3 to 4

Transforming textIn progressCharacter to character mapping, in place against out of place.4/54 / 5 required3 to 4

Numbers and basesIn progressText to number and back, in any base, without wrapping around.4/64 / 6 required3 to 5

0 / 3 complete

3 modules

Dynamic memoryIn progressAllocating, growing and releasing memory, and who owns what.1/51 / 5 required3 to 5

Bytes and raw memoryIn progressThe untyped byte, `void *`, and regions that overlap.2/42 / 4 required3 to 4

Memory safetyBounds, use after free, double free, and reading a leak report.0/60 / 6 required2 to 3

5 modules

Structs, unions, enumsGrouping fields into a record, and what the compiler does with it.0/60 / 6 required2 to 3

Headers and the preprocessorSplitting a program across files, and what the preprocessor pastes.0/30 / 3 required2 to 4

Linked listsIn progressRe-linking nodes, and walking a chain you cannot index.3/43 / 4 required3 to 4

Stacks, queues, treesAn abstract data type is an interface plus an invariant.0/30 / 3 required4 to 5

Generic codeIn progressFunction pointers, comparators, and a pointer plus a size.0/30 / 3 required4 to 5

4 modules

Bits and representationIn progressBitwise operators, masks, shifts, and how a value is laid out.1/41 / 4 required2 to 4

Sorting and searchingIn progressLoop invariants, halving a range, and what an algorithm costs.3/73 / 7 required2 to 4

Files and streamsReading and writing a stream without loading all of it at once.0/30 / 3 required3 to 5

Parsing and formatsTokenising, state machines, and recursive descent.0/40 / 4 required4 to 5

1 module

Processes and signalsSpawning processes, wiring them together, and staying responsive.0/40 / 4 required5 to 5