8. Synopsis
1st week.

Introduction: Concepts of Programming.
Expressions and variables, the type concept. C Language Reference. Simple
expressions in the program.

Practice: Everyday algorithms. Create a
flowchart-like diagram of well known algorithms (e.g., written addition,
subtraction, prime factorization using pen and paper).

Laboratory: Introduction to the computer
lab, to the system, and to the structure of the university network. Operating
System basics: command line program can be started from the command line, its
parameters.

2nd week.

Lecture: Elements of the Source Code.
Algorithm: definition and description. Cycle (loop), branching, sequence.
Combination of these. Complex control structures, complex expressions. Computer
hardware overview.

Practice: Exercise algorithms with a deck
of cards as an example. Find a given card. Which is the lowest/highest? How can
I sort?

Laboratory: Introduction of an Integrated
Development Environment. Compilation of simple programs. Basics of debugging,
monitoring the assignment to variables. Editing the program source and
compilation. The compiler error messages.

3rd week.

Lecture: Pseudo code / C versions of simple
algorithms. Theorems of Summation and Search of extremum. Simple types.
Character and logical types. Arrays.

Practice: Algorithms in C language
description. Examples from Number theory. Quadratic equation. Numerical
methods, e.g. calculation of pi using loops. Several versions of 'is this a
prime number'. Palindrome numbers.

Laboratory: Coding simple algorithms from a
Pseudo code / structogram representation. Programs with simple I/O. printf,
scanf, format strings.

4th week.

Lecture: Built-in types in details. Finite
numerical representation. Integer and floating-point representation of numbers,
limits. Concept of functions and their use. Abstraction, function arguments,
local variables.

Practice: Exercise tasks that can be solved
using arrays. Calendar, leap years. The sieve of Eratosthenes.

Laboratory: Exercise simple algorithms.
Nested loops. Multiplication table, 'draw' a rectangle. Programming of known
algorithms (eg, prime, gcd). Find my Number (guess, smaller, bigger).

5th week.

Lecture: Operators: precedence, evaluation,
side effects. Compound data, structures, defining user types.

Practice: Complex problems, decomposition.
Functions, parameters and return values. Writing simple math-like functions. My
toupper, Caesar encryption.

Laboratory: The basics of array handling.
Creating arrays. Search, count the number of pairs in it, etc.. Demonstration
of out-of-range indexing of an array.

6th week.

Lecture: Enumerated type. State machine.
Pointers and indirection, passing variables by address. Strings.

Practice: Structures. 3D vector structure.
Operations and functions. More complex data types: array of structure, array in
structure.

Laboratory: Bit functions. Dump number in
binary form. Bit-pattern generation, c = set(c, 5). Effect of overflow.
Determination of the bits of an integer. Demonstration of floating point
inaccuracy.

7th week.

Lecture: Communication between the program
and the outside world. Pre-processing. Program Segmentation. Writing maintainable
programs.

Practice: Using Arrays and functions,
arrays as function parameters. String algorithms. Text reverser, palindrome.
String as function parameter. Array size and the length of a string. Risk of
indexing out of range.

Laboratory: Built-in string processing
functions. Handling arrays - more exercise. Multi-dimensional arrays.

8th week:

Lecture: Array algorithms. Searches. Sorts.
Recursion and quick sort.

Practice: State machine design examples,
details of implementation. TH counter, comment filter.

State machine coding. Redirect input from
file and/or to file. TH counter, comment filter. Pattern Recognition.

9th week.

Lecture: Dynamic memory management. Dynamic
arrays. Dynamic encoding of a string. Systematic discussion of memory handling.

Practice: Sorting an array. Median search.
N smallest items. Interval of identical elements. Sorting keys. Cards: array of
structures, sorting by suit or by rank.

Laboratory: Coding of recursive functions.
Fibonacci series, iteratively and recursively. False recursion, printing of a
number. True recursion, coloring shapes.

10th week.

Lecture: Dynamic data structures: linked
lists. List algorithms. Traversal, deletion, insertion.

Practice: Coding a complete user type: Set.
Work with Dynamic arrays. Storing the size, search, resize. Work with pointers
to structures.

Laboratory: Array algorithms, pointers.
Search and Sort implementations. Using multiple module source, decomposition.

11th week.

Lecture: Trees, using binary trees. Search
trees, decoding trees. Traversing trees. Search trees, decoding trees. Multiple
indirection. Introduction to hash tables.

Practice: Choosing a data structure. Lists;
re-linking the elements, memory management.

Laboratory: Implementation of list
handling. Building a list. Writing to a file, reading from a file. Application
of a sentry. Insert, delete.

12th week.

Lecture: Function pointers. Designing a
function plotting program. Union, bit-field.

Practice: Recursive functions. Tree
algorithms. Nodes, levels of a tree (depth), leaves. Analysis of symmetrical
trees.

Laboratory: File management, for example:
writing an array into file and reading back. Programs split to multiple
modules. Processing of command line arguments. File copy.

13th week.

Lecture: More data structures. Design of
large programs. Functional decomposition of a complex project.

Practice: Function pointers. Numerical
integration.

Laboratory: Binary tree handling.

14th week.

Spare lecture.

Practice and Laboratory: practice and
overview.