Learning a programming language is not just about getting a program to compile. It is about learning to describe a problem precisely, choose a representation, test assumptions, and revise a solution when the first attempt can be improved. My CSE 102 solution collection brings together coursework and practice programs written in C as I work through those habits.
The repository is a work in progress, organized around the kinds of exercises I have been solving rather than presented as a finished textbook or a claim that every solution is optimal.
Inside the repository
The current structure separates several strands of practice:
- Offline exercises: programs involving conditionals, functions, strings, and pointers.
- Online assignments: exercises covering pointer use, jagged arrays, function and string problems, and matrix-related tasks.
- Matrix and array operations: row means, zeroed matrix borders, deep-cloning a matrix, and rectangular subgrid detection.
- Algorithm practice: CSES-style tasks such as Weird Algorithm and Missing Number, including implementations that explore different time-complexity approaches.
- Recursion practice: a dedicated area for experiments with recursive solutions.
From fundamentals to memory
Early exercises focus on the building blocks: conditionals, functions, and string manipulation. Pointer-focused work then asks more demanding questions about addresses, arrays, and how data is represented and accessed in memory. The repository also includes work on dynamically sized jagged arrays, where allocation and the shape of the data structure matter as much as the loop logic.
Matrix exercises provide another useful bridge between abstraction and implementation. Computing means by row, changing matrix borders, cloning a matrix, and detecting a rectangular region each require careful indexing and clear decisions about dimensions and boundaries.
Thinking about complexity
The CSES practice files show an interest in comparing approaches, not just producing output. The Missing Number problem, for example, has been explored through an (O(n)) implementation and an (O(1))-time-complexity-oriented approach in the repository’s history. The Weird Algorithm exercise similarly has versions that make the sequence of operations explicit and explore recursive expression.
These exercises are a reminder to state complexity claims carefully: an implementation’s time and auxiliary-space costs depend on the exact operations it performs and the assumptions of the problem. Comparing versions is a useful way to make those trade-offs visible.
A repository that evolves
The commit history records the collection taking shape incrementally: adding solutions, documenting problem statements, revising pointer explanations, fixing jagged-array examples, and clarifying recursive behavior. That edit history is part of the learning record. A solution is not only its final source file; it is also the sequence of questions and revisions that made it clearer.
What this collection is for
I use this repository as a personal reference for CSE 102 topics and as a place to revisit ideas after the original exercise is finished. It may also help other students compare approaches and identify concepts to practice. If you use any solution as a learning reference, read the problem statement, compile and test the code yourself, and make sure you understand why the approach works.
The goal is not to collect code for its own sake. It is to build better instincts for reasoning about memory, structure, correctness, and complexity.
EXPLORE THE CSE 102 REPOSITORY ↗