UNIT – 2
THESE NOTES ARE FOR EXAM PREPARATION
1. Structured Programming Concepts
Structured programming is a programming paradigm aimed at improving the clarity, quality, and
development time of a computer program by making extensive use of three fundamental control
structures: sequence, selection, and repetition. The sequence structure ensures that instructions are
executed in a specific, linear order, one after another. Selection (or decision) provides a way to
choose between different paths of execution based on a condition, allowing the program to react
differently to different inputs. Repetition (or iteration) allows a block of code to be executed multiple
times, which is essential for processing collections of data or performing tasks until a certain
condition is met. By exclusively using these three structures, programs become easier to read, debug,
and maintain, as they eliminate the chaotic "spaghetti code" that can result from the overuse
of goto statements.
• Important Points:
• Sequence: The default control structure where instructions are executed in the order
they are written (e.g., input, then process, then output).
• Selection: Used for decision-making. Implemented using if, if-else,
and switch statements.
• Repetition: Used for looping. Implemented using for, while, and do-
while statements.
• The goal of structured programming is to create programs with a clear, logical flow.
2. Control Structure Stacking and Nesting
To build programs that solve complex problems, the three basic control structures (sequence,
selection, and repetition) can be combined in two primary ways: stacking and nesting. Stacking refers
to placing control structures one after another in a sequence. For example, a program might have an
input block, followed by a selection block, followed by a repetition block. Nesting, on the other hand,
involves placing one control structure inside another. For instance, an if statement can be placed
inside a for loop (nesting selection within repetition), or a for loop can be placed inside
another for loop (nesting repetition within repetition). This ability to combine structures allows for
the creation of intricate and powerful logic.
• Important Points:
• Stacking: Control structures are executed sequentially (e.g., an if statement followed
by a while loop).
• Nesting: One control structure is placed inside the body of another (e.g., a loop
inside a loop, or a conditional inside a loop).
• Nesting is crucial for tasks like processing two-dimensional arrays or creating
complex patterns.
• Proper indentation is essential for maintaining the readability of nested structures.
3. Different Kinds of Repetitions
While all repetition structures execute a block of code multiple times, they can be categorized based
on how they control the looping process. Entry-controlled loops (like for and while) check the loop
condition before executing the loop body, meaning the body might not execute at all. In
contrast, exit-controlled loops (like do-while) execute the loop body at least once and check the
condition afterwards. Loops can also be classified as counter-controlled (definite repetition), which
run a specific number of times, or sentinel-controlled (indefinite repetition), which continue until a
special value (a sentinel) is encountered in the input.
• Important Points:
• Entry-Controlled Loop: Condition is checked at the beginning (e.g., while, for).
• Exit-Controlled Loop: Condition is checked at the end (e.g., do-while). Guarantees at
least one execution.
• Counter-Controlled (Definite): The number of iterations is known beforehand (e.g.,
a for loop running 10 times).
• Sentinel-Controlled (Indefinite): The loop continues until a specific input value
signals termination (e.g., a loop that reads numbers until the user enters -1).
4. Pseudocode and Flowcharts
Pseudocode and flowcharts are two essential tools used in the algorithm design phase to plan and
visualize a program's logic before writing any actual code. Pseudocode is a simplified, informal way of
describing an algorithm using a mix of natural language and programming-like structures, without
adhering to the strict syntax of a specific programming language. A flowchart, conversely, is a
graphical representation of the algorithm, using standardized symbols to depict the sequence of
operations and the flow of control. Both tools help developers clarify their thinking and
communicate the algorithm's design to others.
• Important Points:
• Pseudocode: A text-based, language-independent description of an algorithm's
steps. Focuses on logic, not syntax.
• Flowchart: A diagram-based representation using symbols for start/end, processes,
decisions, and input/output, connected by arrows showing the flow.
• Both are used to design and document algorithms.
• They serve as a blueprint for the final implementation in a programming language.
5. Definition and Characteristics of Algorithms
An algorithm is a well-defined, finite sequence of unambiguous instructions designed to solve a
specific problem or perform a computation. It is the core logical blueprint that underlies any
computer program. To be considered a valid algorithm, a procedure must possess several key
characteristics: it must be finite, meaning it terminates after a finite number of steps; it must
be definite or unambiguous, with each step precisely defined; it must have zero or more well-
defined inputs and one or more well-defined outputs; and each instruction must be effective,
meaning it is basic enough to be carried out in principle by a person using only a pencil and paper.
• Important Points:
• Finiteness: The algorithm must eventually stop.
• Definiteness: Each instruction is clear and has only one interpretation.
• Input: It takes zero or more values as input.
• Output: It produces at least one value as output.
• Effectiveness: Each step is simple and can be executed.
6. Standard Algorithm Format
While there is no single universally enforced standard, algorithms are typically presented in a
structured format to ensure clarity and consistency. This format usually begins with the
algorithm's name and a brief description of its purpose. It then specifies the input(s) it requires and
the output(s) it will produce. The main part of the algorithm is a series of numbered steps that
describe the procedure. This structured approach makes the algorithm easy to read, understand, and
translate into a programming language.
• Important Points:
• Algorithm Name: A descriptive title.
• Input: A description of the data the algorithm expects.
• Output: A description of the result the algorithm produces.
• Steps: A numbered list of clear, sequential instructions.
• Comments are often included to explain complex steps.
7. Problems Involving Iteration and Nesting
Many computational problems can only be solved through the use of iteration (loops) and, in more
complex cases, nested loops. A classic example is displaying patterns and shapes, where an outer
loop might control the rows and an inner loop controls the columns. Generating sequences like the
Fibonacci series or arithmetic/geometric progressions requires a loop that calculates each new term
based on the previous ones. Furthermore, approximating mathematical values for constants like π or
functions like sin(x) and cos(x) using Taylor series expansions involves iterating through a summation
of terms until the desired level of accuracy is reached.
• Important Points:
• Pattern Display: Nested loops are used to create rows and columns of symbols.
• Sequence Generation: A single loop can be used to generate terms iteratively.
• Series Approximation: Loops are used to sum up the terms of an infinite series until
the result converges.
• These problems are excellent for practicing and understanding the power of
repetition and nesting.
8. Different Kinds of Data and their Representation in Computer Memory
In the real world, data comes in many forms, such as numbers, text, images, and sounds. For a
computer to process this data, it must be converted into a binary format (sequences of 0s and 1s)
and stored in memory. Integers are stored directly as binary numbers, but various schemes exist to
handle negative values. Real numbers (with decimal points) are more complex and are stored using a
floating-point representation that captures both the significant digits and the
exponent. Characters are mapped to numeric codes, which are then stored as binary. The way data is
represented directly impacts the precision, range, and memory usage of a program.
• Important Points:
• All data in a computer is ultimately stored as binary.
• Different data types require different representation schemes.
• The choice of representation involves trade-offs between range, precision, and
memory space.
9. Representation of Integers
To represent integers in binary, especially negative ones, several methods are used. The simplest
is Signed Magnitude, where the first bit (the most significant bit) indicates the sign (0 for positive, 1
for negative) and the remaining bits represent the magnitude. 1's Complement is formed by inverting
all the bits of the positive number to get its negative counterpart. The most widely used method
is 2's Complement, which is formed by taking the 1's complement and adding 1. 2's complement is
preferred because it simplifies arithmetic operations (subtraction can be performed as addition) and
has a single, unambiguous representation for zero.
• Important Points:
• Signed Magnitude: Simple to understand but has two representations for zero (+0
and -0).
• 1's Complement: Also has two representations for zero.
• 2's Complement: The standard method used in most modern computers. It has a
unique zero and makes hardware for arithmetic simpler.
10. Representation of Real Numbers: IEEE 754 Floating Point Representation
Representing real numbers (e.g., 3.14159) in binary requires a method to handle the fractional part.
The IEEE 754 standard is the universal format for floating-point representation used in virtually all
modern computers. It divides a binary number into three parts: a sign bit (indicating positive or
negative), an exponent (representing the number's magnitude or scale, stored in a biased format),
and a mantissa or significand (representing the significant digits of the number in a normalized form).
This standard allows for a wide range of values to be represented with a consistent level of precision.
• Important Points:
• Composed of three parts: Sign (1 bit), Exponent, and Mantissa.
• Defines standard formats like single-precision (32-bit) and double-precision (64-bit).
• Allows for the representation of very large and very small numbers.
• Includes special values for infinity and Not-a-Number (NaN).
11. Representation of Characters: ASCII, UNICODE
To store and process text, characters must be mapped to numerical codes. ASCII (American Standard
Code for Information Interchange) was an early standard that uses 7 or 8 bits to represent 128 or 256
characters, respectively, including English letters, digits, and punctuation. However, ASCII is
insufficient for representing characters from all world languages. Unicode was developed to solve
this problem. It is a universal character encoding standard that provides a unique number for every
character, regardless of the platform, program, or language. UTF-8, a specific implementation of
Unicode, has become the dominant character encoding for the World Wide Web.
• Important Points:
• ASCII: An early, limited standard primarily for English.
• Unicode: A universal standard that aims to represent every character from every
language.
• UTF-8: The most common encoding for Unicode, it is backward-compatible with
ASCII.
12. C Language: Introduction to Programming Languages
A programming language is a formal language comprising a set of instructions used to produce
various kinds of output, primarily to control the behavior of a computer. Programming languages
have evolved through several generations, from low-level machine and assembly languages that are
close to the hardware, to high-level languages like C, Java, and Python that are more abstract and
human-readable. The C language, developed by Dennis Ritchie at Bell Labs in the early 1970s, is a
powerful, general-purpose, and highly influential high-level language known for its efficiency and
control over system resources.
• Important Points:
• Generations: 1st (Machine), 2nd (Assembly), 3rd (High-Level like C, Fortran), 4th
(Domain-Specific like SQL), 5th (AI-focused).
• C Language: A procedural, compiled language that has heavily influenced many other
modern languages.
13. Typed Vs Typeless Programming Languages
Programming languages can be categorized based on how they handle data types. In a typed
language (or statically typed language) like C, C++, or Java, the type of a variable must be explicitly
declared, and type-checking is performed at compile-time. This catches errors early and can lead to
more optimized code. In a typeless language (or dynamically typed language) like Python or
JavaScript, variables do not have fixed types; their type is determined at runtime based on the value
they hold. This offers more flexibility but can lead to runtime errors that are harder to detect.
• Important Points:
• Typed (Statically Typed): Types are checked before the program runs (e.g., int x =
10;).
• Typeless (Dynamically Typed): Types are checked as the program runs (e.g., x = 10,
then x = "hello" is allowed).
• C is a statically typed language.
14. C Language Counterparts and Basic Elements
The C language provides a set of fundamental building blocks for creating programs. An empty C
program (int main() { return 0; }) is the simplest valid program. For input and output, C uses functions
from the standard library, with scanf() for formatted input and printf() for formatted output.
The assignment operator (=) is used to store values in variables. C supports standard arithmetic (+, -
, *, /, %), relational (==, !=, <, >), and logical (&&, ||, !) operators. Control flow is managed with
selection statements like if and if-else, and repetition statements like for, while, and do-while.
• Important Points:
• printf(): Used for displaying output to the console.
• scanf(): Used for reading formatted input from the user.
• C provides a rich set of operators for calculations and comparisons.
• The control structures in C directly implement the concepts of structured
programming.
15. Data Types in C
In C, every variable has a data type, which specifies the size and type of value that can be stored in it.
The primary data types include int for integers, char for single characters, float for single-precision
floating-point numbers, and double for double-precision floating-point numbers. These basic types
can be modified with qualifiers like short, long, signed, and unsigned to adjust their range or memory
size. For instance, unsigned int can only store non-negative integers but has a larger maximum value
than a signed int.
• Important Points:
• int: Typically 4 bytes, for whole numbers.
• char: 1 byte, for characters.
• float: 4 bytes, for real numbers with about 7 decimal digits of precision.
• double: 8 bytes, for real numbers with about 15 decimal digits of precision.
• The sizeof operator can be used to determine the exact size of a data type on a
specific system.
16. Translating Pseudocode/Algorithm to C Program
The process of translating a high-level design, such as pseudocode or a flowchart, into a working C
program involves converting the abstract steps into concrete C syntax. This means declaring variables
with appropriate C data types, mapping logical steps to C statements and functions, and translating
control flow descriptions (like "if-then" or "repeat") into their C equivalents (if-else, for, while). This
translation requires a good understanding of both the algorithm's logic and the specific syntax and
features of the C language.
• Important Points:
• Each variable in the pseudocode needs a corresponding declaration in C.
• Logical constructs (selection, repetition) are replaced with C keywords.
• The main algorithm logic is typically placed within the main() function or broken into
smaller helper functions.
17. Incremental Compilation and Testing of The C Program
Incremental development is a software engineering practice where a program is built, compiled, and
tested in small, manageable pieces rather than all at once. For a C program, this means writing a
small piece of functionality (like a single function), compiling it to check for syntax errors, and then
testing it to ensure it works correctly before moving on to the next piece. This iterative approach
makes it much easier to locate and fix bugs, as any new error is likely to be in the small amount of
code that was just added.
• Important Points:
• Write a little code -> Compile -> Test -> Repeat.
• Helps in isolating bugs and errors more easily.
• Leads to more robust and reliable final programs.
• Contrasts with the "big bang" approach where the entire program is written before
any testing is done.
