Programming for Problem Solving

Programming for Problem Solving (GR24A1006) Lecture Material

Course Objective: The course aims to introduce B.Tech first-year students to fundamental Computer Programming concepts and language fundamentals methodically.
Course Material: This document is aligned with the GRIET GR-24 (Autonomous) syllabus for Programming for Problem Solving.
Course Contributors/Verification: The lecture material was developed and verified by the CPDS faculty of CSE, ECE, and CSD/CSM.

UNIT-I Introduction to Programming

Algorithms: Representation using flowcharts, pseudocode, examples, program execution, syntax, and logical error identification.
C Programming: Structure, variables, data types, constants, operators, expressions, precedence, type conversion, formatted and unformatted I/O.
Characteristics of Algorithms:
- Input: Zero or more external values.
- Output: At least one output value.
- Definiteness: Clear and unambiguous instructions.
- Finiteness: Algorithm terminates after a finite number of steps.
- Effectiveness: Every instruction must be basic and executable.
Advantages of Algorithms:
- Core solution blueprint.
- Facilitates solution implementation via programming languages.
- Enhances problem comprehension.
- Identifies efficient solutions.
- Easy identification and improvement elimination of logical errors.
Disadvantages of Algorithms:
- Potentially complicated control flow in complex algorithms.
- Limited visual representation of programming constructs.
- Understanding the logical flow can become difficult.
Examples:
- Adding two numbers
- Calculating average of three numbers
- Calculating the average of n natural numbers

Flowcharts

Flowchart Purpose: A pictorial representation of an algorithm, aiding in communication, overview, understanding relationships between elements, verifying program logic, assisting in coding, facilitating program revision and documentation.
Flowchart Symbols:
- Flow Lines: Connect symbols in flowcharts.
- Terminal: Represents the start and ending of a program or subroutine.
- Input/output: Used for data exchange with the outside world.
- Processing: Represents calculations or data manipulation.
- Decision: Represents decisions or conditions.
- Connector: Usedto join different parts of a flowchart.
- Sub function: used to call function

Develop an Algorithm and Flow Chart

Finding the largest of two numbers: Start, input values A and B, compare A>B, if true, output A, else output B, Stop.
Finding the largest of three numbers: Start, input values A, B, and C, Check A > B, if true, check A > C, if true output A, else output C, else check B > C, if true output B, else Output C, Stop.

Developing an Algorithm and Flowchart to find the factorial of a number.

Algorithm steps: Start, input n, initialize a counter variable i =1, factors = 1, if i <= n go to step 5, otherwise go to step 7, calculate factors = factors * i, increment counter variable i, go to step 4, output factors, Stop.

Programming Concepts (Pages 7-10)

Creating, Compiling, and Executing a Program: The process of creating, writing, compiling, linking, and then executing program using text editor, then a compiler and a linker to translate into executable code that the cpu understands, then runner program executes the code.
Object and Executable Codes: Key aspects of transferring source code to executable code through compilation and linking.
C Program Structure: Sections describing comments( for documentation, name, author other details), link section ( instructions compiler to link functions for executing a program or to include pre predefined headers), Global section (Declaring global variables), Main function section, Local variable declaration section,Executable statements, sub programs (or) user defined function sections.
Variables and data types: Definition of variables, different datatypes supported by C programming language, scope of variables

Data Types

Fundamental Data Types: int, char, float, double are integer, character, floating-point,and double-precision floating point respectively.
Integer datatypes: signed short int, short int, unsigned short int, unsigned int, long int, signed long int, unsigned long int, the range for each are provided, and the format specifiers.
Character Type: signed char and unsigned char.
Floating-point Datatypes:float, double,long double.

Constants in C

Integer Constants: Decimal, octal, and hexadecimal values, and expressions.
Real Constants: Numbers containing fractional parts, or in exponential form.
Character Constants: Single characters enclosed in single quotes, and examples are provided.
String Constants: Sequences of characters enclosed in double quotes.

Operators in C

Arithmetic Operators: +, -, *, /, %, ++, -- (+, -, *,/, %, ++, --).
Relational Operators: <, <=, >, >=, ==, !=
Logical Operators: &&, || , !
Assignment Operators: =, +=, -=, *=, /=, %=, &=, |=, ^=, >>=, <<=

Loops

while loop: A conditional loop that runs repeatedly as long as a given condition is true.
do-while loop: A post-test loop that executes the loop body at least once, and then repeatedly checks a condition until the condition becomes false.
for loop: A pre-test loop that utilizes a loop counter, and a terminating condition.

Conditional Branching

if statement: used for simple conditional checks.
if-else statement: used to execute different blocks of code based on two conditions (true or false).
Nested if-else: A sequence of nested (one within another) if-else statements.
else-if ladder: a series of if...else statements for multiple scenarios; if the first condition is false, the compiler moves on to the next condition up until the program finds a condition that is true.
switch-case statement: used for multiple cases/conditions, each represented by a case label.
goto statement: A transfer of control in a program.

Function

User-defined functions: functions created by the programmer for specific tasks
Function prototype: a declaration specifying the return type, function name and parameter types for a function.
Function Definition: complete definition of the function that includes parameters, variable, logical structure, and return statement
Calling a function: the reference to a function and the arguments.
Function arguments and parameters: arguments represent values passed to the function while parameters are the named variables in the function definition used to store the values of the arguments passed.
Return values: Function output; a function can return a single value using the return keyword.
Call by value and call by reference: ways of passing values to functions, call by value copies the value to the parameter, whereas call by reference passes a memory address.

Arrays

One-dimensional Arrays: An ordered sequence of elements of the same data type.
Two-dimensional Arrays: Represents a table-like structure consisting of rows and columns with elements of the same data type.
Arrays within Structures: An array is used as a member of a structure. This approach is useful for storing collections of similar data representing multiple records of a file..
Array of Structures: An array of structures is a useful data structure for storing multiple records of a particular type.
Initializing Arrays: Compile-time and run-time initialization.

Pointers

Pointer Declaration: Declaring a variable of type int *ptr creates a pointer variable named ptr that can store the memory address of a variable of type integer
Pointer Initialization: Initializing a pointer variable with the address of another variable using the & operator.
Dereferencing: Accessing the value stored at the memory location pointed to by a pointer using the * operator.
Pointer Arithmetic: Performing mathematical operations (+, -, etc.) on pointers.
Pointer to arrays and structures: Pointers that point to an array of elements or structure members, or arrays-within-structures.
Advantages of using pointers: More efficiency and reduced memory usage compared to traditional methods when dealing with large amounts of data.

Strings

Declaration and Initialization: Strings are treated as arrays of characters.
String Handling Functions: functions for string manipulation in C, operations on characters and strings, like strcat, strcmp, strcpy,strlen, strrev, gets, puts.

Files

File Operations: Read/write operations, operations to write a block to a file, reading and writing blocks of data
Opening, Closing, and Reading Files: Using fopen, fclose, getc,putc,fgets, fputs functions to handle text files.
Random Access to Files: Using functions like fseek, ftell, and rewind to access specific parts of files
Error Handling in Files: Using functions like feof and ferror for error management during file operations.
Standard Streams: stdin, stdout, stderr pointers that handle standard input, output, and error streams.

Preprocessor Directives

Macros: A macro is a piece of code that is given a name. Whenever this name appears in the code, the preprocessor replaces it with the actual piece of code.
File Inclusion: Preprocessor directives that instruct the compiler to include another file in the source code.
Conditional Compilation: Allows conditional inclusion or exclusion of code during compilation based on preprocessor macros or defined conditions.

Enumeration Data Types

Enum Declaration: Creating user-defined types to represent a fixed set of values where each value in a list is a symbolic constant with a unique integer value
Enum Usage: Using enumerations to represent symbolic constants and control flow in a variety of conditional contexts.