Computer Science and Programming

Describe how preprocessing, compilation, assembly, linking, and loading turn C source code into a running program.

Compile and run a small C program from the command line with warnings enabled.

Use compiler diagnostics to correct syntax and type errors in a small C program.

Predict the values and types produced by C arithmetic, comparison, and logical expressions.

Implement conditional behavior with if, else, and switch statements.

Implement repetition and simple input processing with while and for loops.

Define and call C functions that use prototypes, local scope, and pass-by-value parameters.

Convert integer values among decimal, binary, and hexadecimal notation.

Determine the range and bit pattern of an unsigned integer type of a given width.

Represent and interpret signed integers using two's-complement notation.

Use bitwise operators and masks to inspect, set, clear, and toggle selected bits.

Encode and decode basic ASCII and UTF-8 text as byte sequences.

Predict common floating-point rounding and comparison behavior in C.

Use sizeof and address-printing techniques to inspect the memory occupied by C objects.

Create pointer variables and trace address-of and dereference operations.

Explain and diagram the contiguous memory layout of a C array.

Traverse an array safely using both indexing and pointer arithmetic.

Trace how arrays and pointers behave when passed to C functions.

Process null-terminated C strings without reading or writing beyond their bounds.

Distinguish automatic, static, and dynamically allocated storage by lifetime and location.

Allocate and release heap memory with malloc, calloc, and free.

Resize a dynamic allocation safely with realloc.

Use compiler sanitizers to locate an out-of-bounds access, use-after-free, or memory leak.

Define struct and enum types and inspect how alignment and padding affect struct layout.

Split a C program into header and source files using declarations, definitions, and include guards.

Diagnose a duplicate-symbol or unresolved-symbol linker error in a multi-file C program.

Estimate an algorithm's time and space growth using Big-O notation.

Implement linear search and state its best- and worst-case running times.

Implement binary search while maintaining explicit search-bound invariants.

Implement insertion sort and trace its effect on a small array.

Trace a recursive function by drawing its sequence of stack frames.

Measure runtime across increasing input sizes and relate the results to a complexity prediction.

Implement a resizable array in C while preserving its size and capacity invariants.

Implement insertion, search, and deletion in a singly linked list.

Implement LIFO stack operations and explain their time complexity.

Implement a FIFO queue using a circular array buffer.

Implement lookup and insertion in a fixed-size hash table using separate chaining.

Trace search, insertion, and traversal operations in a binary search tree.

Trace the fetch-decode-execute cycle for a short sequence of simplified machine instructions.

Relate C variables, arithmetic, and branches to representative assembly instructions and registers.

Explain how a C function call uses registers and a stack frame at machine level.

Predict how spatial and temporal locality affect the cache performance of array and linked-list traversal.

Diagram a process's virtual address space and place code, static data, heap, and stack within it.

Explain how virtual-memory address translation and page faults isolate processes.

Use POSIX file descriptors and the open, read, write, and close system calls in a small C program.

Translate a small command-line program specification into C modules with explicit interfaces and data-ownership rules.

Parse bounded text input into validated struct records while reporting malformed input safely.

Store a changing collection of records in a reusable dynamic container.

Add sorting and searching features whose behavior and complexity match explicit requirements.

Read and write a documented record format while handling partial I/O and error returns.

Profile one performance bottleneck and make a measurement-supported optimization.

Audit the completed program for bounds, lifetime, ownership, and error-handling defects.

Explain the completed program's path from source code through compilation, memory, CPU execution, and operating-system services.