Maharishi University of Information Technology

Name of the faculty: Mr. Abhay Bajpai

Course : BCA
Year/Semester: 1/1
Subject code: BCA 101
Session: 2024-25
Subject Name: Computer Fundamental & C Programming

UNIT I
1. Introduction to Programming & Problem Solving:
1.1 What is Programming?

Programming is the process of designing and creating executable computer software to accomplish
a specific task. It involves writing code in programming languages that a computer can understand
and execute.

Key Concepts in Programming:

• Algorithm: A step-by-step procedure or formula for solving a problem. Algorithms are

fundamental to programming as they define the logic and sequence of operations.

• Programming Language: A formal language comprising a set of instructions that can be used
to produce various kinds of output, including software. Examples include C, C++, Java,
Python, etc.

• Syntax: The set of rules that defines the combinations of symbols that are considered to be
correctly structured programs in that language.

• Semantics: The meaning behind the syntax, i.e., what the code does.

Problem-Solving Steps:

1. Understand the Problem: Clearly define what the problem is and what the desired output
should be.

2. Devise a Plan: Develop an algorithm or a step-by-step approach to solve the problem.

3. Write the Code: Implement the algorithm in a programming language.

4. Test and Debug: Run the program with various test cases to ensure it works correctly and fix
any issues.

5. Refine the Solution: Optimize the code for efficiency and readability if necessary.
 Maharishi University of Information Technology
Example of Problem-Solving:

Problem: Calculate the sum of integers from 1 to 10.

1. Understand: We need the sum of numbers from 1 to 10.

2. Plan: Use a loop to iterate through numbers and accumulate the sum.

3. Code:

#include <stdio.h>
int main() {
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
printf("Sum: %d\n", sum);
return 0;
}
4. Test and Debug: Ensure the output is 55.

5. Refine: The code is already efficient for this problem.

2. Introduction to Components of Computer System:

2.1 Disk:

• Definition: A storage device used to save and retrieve digital information. Common types
include hard disk drives (HDDs) and solid-state drives (SSDs).

• Function: Provides long-term storage for the operating system, applications, and data.

Key Concepts:

• Hard Disk Drive (HDD): Uses spinning disks and read/write heads to access data. Generally
has larger storage capacity but slower access times.

• Solid-State Drive (SSD): Uses flash memory to store data. Faster access times and better
durability compared to HDDs but can be more expensive.

2.2 Memory:

• Definition: The component of a computer that temporarily stores data and instructions that
are being used by the CPU.

• Types:

o RAM (Random Access Memory): Volatile memory used for temporary storage while
programs are running. Data is lost when the computer is turned off.
 Maharishi University of Information Technology
o ROM (Read-Only Memory): Non-volatile memory that is used to store firmware or
software that is rarely changed.

Key Concepts:

• Volatile Memory: Requires power to maintain stored information (e.g., RAM).

• Non-Volatile Memory: Retains information even when the power is turned off (e.g., ROM,
SSD).

2.3 Processor (CPU - Central Processing Unit):

• Definition: The brain of the computer that performs instructions from programs through
basic arithmetic, logic, control, and input/output operations.

• Components:

o ALU (Arithmetic Logic Unit): Performs arithmetic and logical operations.

o Control Unit: Directs operations of the processor.

o Registers: Small, fast storage locations within the CPU for temporary data.

Key Concepts:

• Clock Speed: Measured in GHz, determines how many cycles per second the CPU can
execute.

• Cores: Modern CPUs have multiple cores, allowing them to process multiple instructions
simultaneously.

2.4 Operating System (OS):

• Definition: System software that manages hardware resources and provides common
services for computer programs.

• Functions:

o Process Management: Manages running processes and their scheduling.

o Memory Management: Handles allocation and deallocation of memory space.

o File System Management: Manages files and directories on storage devices.

o Device Management: Controls peripheral devices such as printers, keyboards, and

mice.

Examples: Windows, macOS, Linux, Android.

 Maharishi University of Information Technology
2.5 Compilers:

• Definition: A compiler translates code written in a high-level programming language into

machine language (binary code) that the CPU can execute.

• Process:

1. Lexical Analysis: Breaking down the code into tokens.

2. Syntax Analysis: Parsing tokens to check for grammatical correctness.

3. Semantic Analysis: Ensuring the code follows language rules.

4. Optimization: Improving the code for performance.

5. Code Generation: Producing the final machine code.

Example: GCC (GNU Compiler Collection), Clang.

2.6 Loaders:

• Definition: A loader is responsible for loading executable files into memory and preparing
them for execution.

• Functions:

o Loading: Moves executable code into RAM.

o Relocation: Adjusts addresses in the code and data to reflect their locations in
memory.

o Linking: Combines multiple object files into a single executable.

Types:

• Static Loader: Loads programs at compile time.

• Dynamic Loader: Loads programs or libraries at runtime.

2.7 Linkers:

• Definition: A linker combines several object files generated by a compiler into a single
executable or library.

• Functions:

o Symbol Resolution: Connects function calls to their definitions.

o Address Binding: Assigns memory addresses to various parts of the program.

o Library Linking: Links to libraries and their functions.

 Maharishi University of Information Technology

Types:

• Static Linking: Libraries are included in the executable at compile time.

• Dynamic Linking: Libraries are linked during runtime, allowing for updates without
recompiling.

3. Introduction to Algorithms:
An algorithm is a step-by-step procedure or formula for solving a problem. It is a finite sequence of
well-defined instructions that perform a specific task or solve a particular problem.

Characteristics of an Algorithm:

• Input: Receives zero or more inputs.

• Output: Produces at least one output.

• Definiteness: Each step is precisely defined.

• Finiteness: The algorithm must terminate after a finite number of steps.

• Effectiveness: Each step should be basic enough to be performed exactly and in a finite
amount of time.

Example Algorithm:

To find the largest of three numbers:

1. Input three numbers: a, b, and c.

2. Compare a with b and c:

o If a is greater than both, then a is the largest.

o Otherwise, compare b with c:

▪ If b is greater than c, then b is the largest.

▪ Otherwise, c is the largest.

3. Output the largest number.

4. Steps to Solve Logical & Numerical Problems:

To solve logical and numerical problems, follow these steps:

Step-by-Step Approach:
 Maharishi University of Information Technology
1. Understand the Problem: Read the problem statement carefully and ensure you understand
what is being asked.

2. Analyze the Problem: Break down the problem into smaller parts and determine what
information you need.

3. Design the Algorithm: Create a step-by-step plan (algorithm) to solve the problem.

4. Write Pseudocode or Flowchart: Outline the algorithm in pseudocode or draw a flowchart.

5. Convert to Code: Translate the pseudocode or flowchart into actual source code.

6. Test the Program: Run the program with different inputs to ensure it works correctly.

7. Debug: Identify and fix any errors in the program.

Example:

To solve a problem of calculating the factorial of a number:

1. Understand: Compute n! = n * (n-1) * (n-2) * ... * 1.

2. Analyze: Determine the input (number n) and output (factorial of n).

3. Algorithm:

o Input n.

o Initialize factorial to 1.

o For each number from 1 to n, multiply factorial by that number.

o Output factorial.

4. Pseudocode:

Input n

factorial = 1

For i from 1 to n

factorial = factorial * i

Output factorial

5. Code:

#include <stdio.h>
int main() {
int n, i;
long long factorial = 1;
 Maharishi University of Information Technology
printf("Enter a number: ");
scanf("%d", &n);
for (i = 1; i <= n; i++) {
factorial *= i;
}
printf("Factorial of %d = %lld\n", n, factorial);
return 0;
}

5. Introduction to Flowcharts/Pseudocode:
Flowcharts:

A flowchart is a graphical representation of an algorithm. It uses different shapes to denote different

types of operations, such as processes, decisions, and inputs/outputs.

Common Flowchart Symbols:

• Oval: Start/End

• Rectangle: Process (e.g., calculation or assignment)

• Diamond: Decision (e.g., if-else condition)

• Parallelogram: Input/Output

• Arrow: Flow of control

Example Flowchart for Finding the Largest of Two Numbers:

 Maharishi University of Information Technology
Pseudocode:

Pseudocode is a high-level description of an algorithm using plain language or a mixture of

programming constructs. It is used to design algorithms before coding.

Example Pseudocode:

START

INPUT a, b

IF a > b THEN

OUTPUT a is the largest

ELSE

OUTPUT b is the largest

END

6. From Algorithms/Flowcharts to Programs:

To convert algorithms or flowcharts into source code:

1. Understand the Algorithm/Flowchart: Know the logical steps.

2. Translate Steps to Code: Write the code in the chosen programming language (e.g., C).

3. Use Proper Syntax: Ensure that the code adheres to the syntax rules of the programming
language.

4. Test and Debug: Validate the code against different inputs to ensure correctness.

Example Conversion:

From the pseudocode for finding the largest of three numbers, you would write the following C
program.

#include <stdio.h>
int main() {
int a, b, c;
printf("Enter three numbers: ");
scanf("%d %d %d", &a, &b, &c);

if (a > b) {
if (a > c) {
printf("Largest number is: %d\n", a);
} else {
printf("Largest number is: %d\n", c);
 Maharishi University of Information Technology
}
} else {
if (b > c) {
printf("Largest number is: %d\n", b);
} else {
printf("Largest number is: %d\n", c);
}
}

return 0;
}

7. Source Code, Variables, and Memory Locations:

Source Code:

Source code is the human-readable code written in a programming language. It is the initial form of
the program before compilation.

Variables:

Variables are named storage locations in memory that hold data. They must be declared before use
and can be of different types such as int, float, char, etc.

Example:

int num = 5; // Variable 'num' of type int

float pi = 3.14; // Variable 'pi' of type float

char letter = 'A'; // Variable 'letter' of type char

Memory Locations:

Each variable is stored in a specific location in memory. The memory address of a variable can be
accessed using pointers in C.

Example:

#include <stdio.h>

int main() {

int num = 10;

printf("Value of num: %d\n", num);

printf("Memory address of num: %p\n", (void*)&num);

 Maharishi University of Information Technology
return 0;

8. Syntax & Logical Errors in Compilation:

Syntax Errors:

Syntax errors occur when the code violates the grammatical rules of the programming language.
These errors are detected during compilation.

Example:

#include <stdio.h>
int main() {
int num = 10
printf("Value of num: %d\n", num); // Missing semicolon
return 0;
}
Error: Missing semicolon (;).

Logical Errors:

Logical errors occur when the program runs without syntax errors but produces incorrect results.
These errors are harder to detect because they do not cause compilation issues.

Example:

#include <stdio.h>
int main() {
int a = 5, b = 10;
int sum = a - b; // Incorrect operation for sum
printf("Sum: %d\n", sum); // Will print a difference instead of sum
return 0;
}
Error: Incorrect operation (- instead of +).

9. Object & Executable Code:

Object Code:

Object code is the intermediate machine code generated by the compiler after translating the source
code. It is not executable by itself and is usually in a file with an .obj or .o extension.

Executable Code:

Executable code is the final output of the compilation process. It is a binary file that the operating
system can run directly. It contains machine code instructions and is usually in a file with an .exe
extension (on Windows) or no extension (on Unix/Linux).
 Maharishi University of Information Technology
Example of Compilation Process:

1. Source Code: Written in a high-level language (e.g., C code).

2. Compilation: Translates source code to object code.

3. Linking: Combines object code with libraries to produce executable code.

4. Executable File: Ready to be run by the computer.

Summary:
• Programming involves creating algorithms and coding them in a programming language.

• Problem Solving includes understanding the problem, planning, coding, testing, and
refining.

• Computer System Components include disk storage, memory, processor, operating system,
and tools like compilers, loaders, and linkers, each playing a critical role in the functioning
and management of a computer system.

• Algorithms: Step-by-step procedures for solving problems.

• Flowcharts/Pseudocode: Tools for designing algorithms.