Instruction

An instruction is a basic command given to a computer to perform a specific operation such as arithmetic, data transfer, or logical comparison. It is the smallest unit of a program that the processor can execute.

Program

A program is a set of instructions written in a programming language that directs a computer to perform a specific task or solve a problem. It is executed sequentially (or conditionally) by the CPU.

Generations of Programming Languages

Importance of Problem Analysis

Problem analysis is the first and most critical step in software development. Its importance includes:

• Clearly defines the input, output, and constraints of the problem.
• Helps identify the correct approach before coding begins, saving time and effort.
• Reduces errors and rework during later stages.
• Forms the basis for writing algorithms, flowcharts, and test cases.
• Ensures the final software actually solves the intended problem.

Algorithm – Check Even or Odd

Step 1: Start
Step 2: Read a number N from the user
Step 3: If N MOD 2 = 0, go to Step 4, else go to Step 5
Step 4: Print "N is Even", go to Step 6
Step 5: Print "N is Odd"
Step 6: Stop

Flowchart – Check Even or Odd

Expression

An expression is a combination of operands (variables, constants) and operators that evaluates to a single value. Every expression has a type determined by its operands and operators.

a + b        // evaluates to sum
x > y        // evaluates to true or false
a = 5        // assignment expression

Types of Expression

Formatted Input/Output

printf() – Displays formatted output to the screen.

Syntax:  printf("format string", variable_list);
Example: printf("Sum = %d", a + b);

scanf() – Reads formatted input from the keyboard.

Syntax:  scanf("format string", &variable_list);
Example: scanf("%d %f", &n, &x);

Unformatted Input/Output

getchar() / putchar() – Reads/writes a single character.

char c;
c = getchar();   // reads one character
putchar(c);      // prints one character

gets() / puts() – Reads/writes a string.

char name[50];
gets(name);      // reads a string (until newline)
puts(name);      // prints string followed by newline

Format Specifiers

Nested if

An if statement inside another if statement. Used when a condition depends on another condition being true first.

if (condition1) {
    if (condition2) {
        // executes when both condition1 and condition2 are true
    } else {
        // executes when condition1 true, condition2 false
    }
} else {
    // executes when condition1 is false
}

else if Ladder

A series of if-else if conditions checked one by one. Used for multi-way branching where conditions are mutually exclusive.

if (condition1) {
    // block 1
} else if (condition2) {
    // block 2
} else if (condition3) {
    // block 3
} else {
    // default block
}

Comparison

C Program – Prime or Composite

#include <stdio.h>
int main() {
    int n, i, flag = 0;
    printf("Enter a number: ");
    scanf("%d", &n);

    if (n <= 1) {
        printf("%d is neither prime nor composite.\n", n);
        return 0;
    }

    for (i = 2; i <= n / 2; i++) {
        if (n % i == 0) {
            flag = 1;
            break;
        }
    }

    if (flag == 1)
        printf("%d is a Prime number.\n", n);
    else
        printf("%d is a Composite number.\n", n);

    return 0;
}

Output

Enter a number: 13
13 is a Prime number.

Enter a number: 12
12 is a Composite number.

Call by Value

In call by value, a copy of the actual argument is passed to the function. Changes made inside the function do NOT affect the original variable.

#include <stdio.h>
void square(int x) {
    x = x * x;   // only local copy is changed
    printf("Inside: %d\n", x);
}
int main() {
    int a = 5;
    square(a);
    printf("Outside: %d\n", a);  // a remains 5
    return 0;
}
// Output:
// Inside: 25
// Outside: 5

Call by Reference

In call by reference, the address of the actual argument is passed. Changes made inside the function DO affect the original variable.

#include <stdio.h>
void square(int *x) {
    *x = (*x) * (*x);  // original variable is changed
    printf("Inside: %d\n", *x);
}
int main() {
    int a = 5;
    square(&a);
    printf("Outside: %d\n", a);  // a is now 25
    return 0;
}
// Output:
// Inside: 25
// Outside: 25

Comparison

C Program – Factorial Using Recursion

#include <stdio.h>

int factorial(int n) {
    if (n == 0 || n == 1)
        return 1;             // base case
    return n * factorial(n - 1); // recursive call
}

int main() {
    int n;
    printf("Enter a positive integer: ");
    scanf("%d", &n);
    printf("Factorial of %d = %d\n", n, factorial(n));
    return 0;
}

Output

Enter a positive integer: 5
Factorial of 5 = 120

Recursive Trace (n=5)

factorial(5)
= 5 * factorial(4)
= 5 * 4 * factorial(3)
= 5 * 4 * 3 * factorial(2)
= 5 * 4 * 3 * 2 * factorial(1)
= 5 * 4 * 3 * 2 * 1
= 120

C Program – Reverse a String

#include <stdio.h>
int main() {
    char str[100], rev[100];
    int i, len = 0;

    printf("Enter a string: ");
    scanf("%s", str);

    // Find length manually
    while (str[len] != '\0')
        len++;

    // Copy in reverse
    for (i = 0; i < len; i++)
        rev[i] = str[len - 1 - i];
    rev[len] = '\0';

    printf("Reversed string: %s\n", rev);
    return 0;
}

Output

Enter a string: HELLO
Reversed string: OLLEH

C Program – Largest and Smallest among 10 Numbers

#include <stdio.h>
int main() {
    int a[10], i, max, min;

    printf("Enter 10 numbers:\n");
    for (i = 0; i < 10; i++) {
        printf("Number %d: ", i + 1);
        scanf("%d", &a[i]);
    }

    max = a[0];
    min = a[0];

    for (i = 1; i < 10; i++) {
        if (a[i] > max)
            max = a[i];
        if (a[i] < min)
            min = a[i];
    }

    printf("Largest number  = %d\n", max);
    printf("Smallest number = %d\n", min);

    return 0;
}

Output

Enter 10 numbers:
Number 1: 4
Number 2: 7
... (10 inputs)
Largest number  = 98
Smallest number = 2

Structure

A structure is a user-defined data type in C that groups variables of different data types under a single name. Each variable inside a structure is called a member.

struct Student {
    int roll;
    char name[50];
    float marks;
};

Why is it Necessary?

Structures are necessary because they allow related data of different types to be stored and managed together as a single unit. Without structures, each piece of related information would need to be stored in separate variables, making programs harder to manage, read, and maintain. They are especially useful for representing real-world entities like students, employees, or distances.

C Program – Add Two Distances (feet and inches)

#include <stdio.h>

struct Distance {
    int feet;
    float inch;
};

int main() {
    struct Distance d1, d2, sum;

    printf("Enter first distance:\n");
    printf("Feet: ");  scanf("%d", &d1.feet);
    printf("Inch: ");  scanf("%f", &d1.inch);

    printf("Enter second distance:\n");
    printf("Feet: ");  scanf("%d", &d2.feet);
    printf("Inch: ");  scanf("%f", &d2.inch);

    sum.feet = d1.feet + d2.feet;
    sum.inch = d1.inch + d2.inch;

    // Convert excess inches to feet
    if (sum.inch >= 12.0) {
        sum.feet += (int)(sum.inch / 12);
        sum.inch  = sum.inch - (int)(sum.inch / 12) * 12;
    }

    printf("\nSum = %d feet %.2f inches\n", sum.feet, sum.inch);
    return 0;
}

Output

Enter first distance:
Feet: 5
Inch: 9.5
Enter second distance:
Feet: 3
Inch: 4.8

Sum = 9 feet 2.30 inches

Pointer Arithmetic

Pointer arithmetic refers to arithmetic operations performed on pointer variables. Since pointers hold memory addresses, arithmetic on them moves the pointer by multiples of the size of the data type they point to.

Valid Pointer Operations

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;   // ptr points to arr[0]

    printf("ptr   = %d (address: %u)\n", *ptr, ptr);
    ptr++;
    printf("ptr++ = %d (address: %u)\n", *ptr, ptr);
    ptr += 2;
    printf("ptr+2 = %d (address: %u)\n", *ptr, ptr);

    return 0;
}
// Output (assuming int = 4 bytes):
// ptr   = 10 (address: 1000)
// ptr++ = 20 (address: 1004)
// ptr+2 = 40 (address: 1012)

Each increment moves the pointer by 4 bytes (size of int), not just 1 byte.

C Program – Sum, Difference, Product Using Pointers

#include <stdio.h>
int main() {
    int a, b;
    int *p1, *p2;

    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);

    p1 = &a;
    p2 = &b;

    printf("Sum        = %d\n", *p1 + *p2);
    printf("Difference = %d\n", *p1 - *p2);
    printf("Product    = %d\n", *p1 * *p2);

    return 0;
}

Output

Enter two numbers: 8 3
Sum        = 11
Difference = 5
Product    = 24

Console I/O vs File I/O

C Program – Display Employees with Salary > 50000

#include <stdio.h>
int main() {
    FILE *fp;
    char name[50];
    int id;
    float salary;
    int found = 0;

    fp = fopen("employee.txt", "r");
    if (fp == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    printf("Employees with salary > 50000:\n");
    printf("%-20s %-10s %-10s\n", "Name", "ID", "Salary");
    printf("--------------------------------------\n");

    while (fscanf(fp, "%s %d %f", name, &id, &salary) != EOF) {
        if (salary > 50000) {
            printf("%-20s %-10d %-10.2f\n", name, id, salary);
            found = 1;
        }
    }

    if (!found)
        printf("No employees found with salary > 50000.\n");

    fclose(fp);
    return 0;
}

Sample employee.txt

Ram       101  45000
Sita      102  60000
Hari      103  75000
Gita      104  30000

Output

Employees with salary > 50000:
Name                 ID         Salary
--------------------------------------
Sita                 102        60000.00
Hari                 103        75000.00

C vs FORTRAN Key Differences

Array Declaration in FORTRAN

C --- 1D Array ---
      INTEGER A(10)        ! Array of 10 integers (index 1 to 10)
      REAL    X(5)         ! Array of 5 real numbers

C --- 2D Array ---
      INTEGER MAT(3,4)     ! 3 rows, 4 columns
      REAL    B(10,10)     ! 10x10 matrix

FORTRAN Program – Matrix Transpose

      PROGRAM TRANSPOSE
      INTEGER A(10,10), T(10,10), M, N, I, J

C     Read dimensions
      WRITE(*,*) 'Enter number of rows and columns:'
      READ(*,*) M, N

C     Read matrix elements
      WRITE(*,*) 'Enter matrix elements row by row:'
      DO 10 I = 1, M
        DO 10 J = 1, N
          READ(*,*) A(I,J)
   10 CONTINUE

C     Compute transpose: T(I,J) = A(J,I)
      DO 20 I = 1, N
        DO 30 J = 1, M
          T(I,J) = A(J,I)
   30   CONTINUE
   20 CONTINUE

C     Display transpose
      WRITE(*,*) 'Transpose of the matrix:'
      DO 40 I = 1, N
        DO 50 J = 1, M
          WRITE(*,100) T(I,J)
   50   CONTINUE
        WRITE(*,*)
   40 CONTINUE

  100 FORMAT(I5,$)
      STOP
      END

System Software vs Application Software

Why C is Commonly Used in Simulation

C is widely used in simulation for the following reasons:

• High Performance: C is a compiled language that produces fast, efficient machine code, critical for real-time simulations.
• Low-level Memory Control: C allows direct memory management using pointers, enabling fine-tuned control over data structures needed in complex simulations.
• Portability: C programs can run on virtually any hardware platform, making simulations portable across systems.
• Rich Library Support: C provides extensive mathematical and I/O libraries suitable for scientific simulations.
• Close to Hardware: C can directly interact with hardware resources, making it suitable for embedded and hardware-level simulations.
• Deterministic Behavior: C gives predictable execution timing, which is important for time-critical simulations.

Testing

Testing is the process of executing a program with various inputs to verify that it produces the correct and expected output. The goal is to detect errors, verify functionality, and ensure the program meets its requirements. Testing does not fix errors — it only identifies them.

Types: Unit testing, Integration testing, System testing, Black-box testing, White-box testing.

Debugging

Debugging is the process of finding, analyzing, and fixing the errors (bugs) discovered during testing. It involves locating the exact source of the error in the code and correcting it so the program runs as expected.

Difference

Algorithm – Sum of First N Natural Numbers

Step 1: Start
Step 2: Read N from the user
Step 3: Set sum = 0, i = 1
Step 4: If i > N, go to Step 7
Step 5: sum = sum + i, i = i + 1
Step 6: Go to Step 4
Step 7: Print sum
Step 8: Stop

Flowchart

Operator Precedence

Precedence determines the order in which operators are evaluated when an expression has more than one operator. Operators with higher precedence are evaluated first.

int x = 2 + 3 * 4;
// * has higher precedence than +
// Evaluated as: 2 + (3 * 4) = 2 + 12 = 14

Operator Associativity

Associativity determines the direction of evaluation when two operators have the same precedence. It can be left-to-right or right-to-left.

// Left-to-right (most operators):
int x = 10 - 3 - 2;   // = (10 - 3) - 2 = 5

// Right-to-left (assignment, unary):
int a, b, c;
a = b = c = 5;         // = c=5, then b=5, then a=5

Keywords

Keywords are reserved words in C that have predefined meanings and cannot be used as identifiers (variable names, function names, etc.). C has 32 keywords.

int, float, char, double, void, if, else, for, while, do,
switch, case, break, continue, return, struct, union,
typedef, enum, sizeof, static, extern, auto, register,
const, volatile, signed, unsigned, short, long, goto, default

Rules for Writing Identifiers in C

• An identifier can contain letters (A-Z, a-z), digits (0-9), and underscore (_) only.
• An identifier must begin with a letter or underscore, not a digit.
• Identifiers are case-sensitive (e.g., sum and Sum are different).
• Keywords cannot be used as identifiers.
• There is no limit on the length, but only the first 31 characters are significant (ANSI C).
• No spaces or special characters (@, #, $, etc.) are allowed.

Valid:   sum, _count, total1, MAX_SIZE
Invalid: 1total (starts with digit), int (keyword), my-var (hyphen)

Formatted vs Unformatted I/O

Examples

// Formatted I/O
int n;
float x;
scanf("%d %f", &n, &x);
printf("n=%d, x=%.2f", n, x);

// Unformatted I/O
char c, str[50];
c = getchar();       // reads one character
putchar(c);          // prints one character
gets(str);           // reads a string
puts(str);           // prints a string

C Program – Prime or Composite

#include <stdio.h>
int main() {
    int n, i, flag = 0;
    printf("Enter a number: ");
    scanf("%d", &n);

    if (n <= 1) {
        printf("%d is neither prime nor composite.\n", n);
        return 0;
    }

    for (i = 2; i <= n / 2; i++) {
        if (n % i == 0) {
            flag = 1;
            break;
        }
    }

    if (flag == 0)
        printf("%d is a Prime number.\n", n);
    else
        printf("%d is a Composite number.\n", n);

    return 0;
}

Output

Enter a number: 17
17 is a Prime number.

Enter a number: 9
9 is a Composite number.

C Program – Star Pattern (Triangle)

#include <stdio.h>
int main() {
    int i, j, n = 5;

    for (i = 1; i <= n; i++) {
        // Print leading spaces
        for (j = i; j < n; j++) {
            printf("  ");
        }
        // Print stars
        for (j = 1; j <= (2 * i - 1); j++) {
            printf("* ");
        }
        printf("\n");
    }
    return 0;
}

Output

        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *

Function

A function is a self-contained block of code that performs a specific task. It can be called multiple times from anywhere in the program. Every C program has at least one function: main().

Classification of Functions

User-defined functions are further classified by return type and arguments:

• No argument, no return value
• With argument, no return value
• No argument, with return value
• With argument, with return value

Advantages of Using Functions

• Modularity: Program is divided into smaller, manageable modules.
• Reusability: A function can be called multiple times, avoiding code repetition.
• Readability: Makes the program easier to read and understand.
• Easy Debugging: Errors can be isolated and fixed in individual functions.
• Reduced Complexity: Breaks a complex problem into simpler sub-problems.

C Program – n^th Fibonacci Term Using Recursion

#include <stdio.h>

int fibonacci(int n) {
    if (n == 0) return 0;       // base case
    if (n == 1) return 1;       // base case
    return fibonacci(n - 1) + fibonacci(n - 2); // recursive call
}

int main() {
    int n;
    printf("Enter the value of n: ");
    scanf("%d", &n);
    printf("The %dth Fibonacci term = %d\n", n, fibonacci(n));
    return 0;
}

Output

Enter the value of n: 7
The 7th Fibonacci term = 13

Recursive Trace (n=5)

fibonacci(5)
= fibonacci(4) + fibonacci(3)
= (fibonacci(3) + fibonacci(2)) + (fibonacci(2) + fibonacci(1))
= ... = 3 + 2 = 5

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21 … (index starts at 0)

1D Array

A 1D (one-dimensional) array is a linear collection of elements of the same data type stored in contiguous memory locations, accessed using a single index.

int a[5] = {10, 20, 30, 40, 50};
// accessed as a[0], a[1], ..., a[4]

2D Array

A 2D (two-dimensional) array is an array of arrays that represents data in rows and columns (like a matrix), accessed using two indices: row and column.

int mat[3][4];   // 3 rows, 4 columns
// accessed as mat[i][j]

C Program – Transpose of m×n Matrix

#include <stdio.h>
int main() {
    int a[10][10], t[10][10], m, n, i, j;

    printf("Enter rows and columns: ");
    scanf("%d %d", &m, &n);

    printf("Enter matrix elements:\n");
    for (i = 0; i < m; i++)
        for (j = 0; j < n; j++)
            scanf("%d", &a[i][j]);

    // Compute transpose
    for (i = 0; i < m; i++)
        for (j = 0; j < n; j++)
            t[j][i] = a[i][j];

    printf("Transpose matrix:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++)
            printf("%4d", t[i][j]);
        printf("\n");
    }
    return 0;
}

Output

Enter rows and columns: 2 3
Enter matrix elements:
1 2 3
4 5 6
Transpose matrix:
   1   4
   2   5
   3   6

C Program – String Length Without Library Function

#include <stdio.h>
int main() {
    char str[100];
    int len = 0;

    printf("Enter a string: ");
    scanf("%s", str);

    while (str[len] != '\0')
        len++;

    printf("Length of string = %d\n", len);
    return 0;
}

Output

Enter a string: HELLO
Length of string = 5

The loop counts characters until the null terminator '\0' is reached, which marks the end of the string.

Nested Structure

A nested structure is a structure that contains another structure as one of its members. This allows grouping of related sub-data within a larger structure.

struct Address {
    char city[50];
    char district[50];
};

struct Student {
    char name[50];
    int roll;
    float marks;
    struct Address addr;   // nested structure
};

C Program – Student Details Sorted by Marks

#include <stdio.h>
#include <string.h>

struct Address {
    char city[50];
    char district[50];
};

struct Student {
    char name[50];
    int roll;
    float marks;
    struct Address addr;
};

int main() {
    int n, i, j;
    struct Student s[50], temp;

    printf("Enter number of students: ");
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("\nStudent %d:\n", i + 1);
        printf("Name: ");    scanf("%s", s[i].name);
        printf("Roll: ");    scanf("%d", &s[i].roll);
        printf("Marks: ");   scanf("%f", &s[i].marks);
        printf("City: ");    scanf("%s", s[i].addr.city);
        printf("District: ");scanf("%s", s[i].addr.district);
    }

    // Sort by marks (descending) using bubble sort
    for (i = 0; i < n - 1; i++)
        for (j = 0; j < n - i - 1; j++)
            if (s[j].marks < s[j + 1].marks) {
                temp = s[j];
                s[j] = s[j + 1];
                s[j + 1] = temp;
            }

    printf("\n%-15s %-6s %-8s %-15s %-15s\n",
           "Name", "Roll", "Marks", "City", "District");
    printf("--------------------------------------------------------------\n");
    for (i = 0; i < n; i++)
        printf("%-15s %-6d %-8.2f %-15s %-15s\n",
               s[i].name, s[i].roll, s[i].marks,
               s[i].addr.city, s[i].addr.district);

    return 0;
}

Pointer

A pointer is a variable that stores the memory address of another variable. It is declared using the * operator and the address-of operator & is used to get the address of a variable.

int a = 10;
int *p = &a;   // p stores address of a
printf("%d", *p);  // *p dereferences to get value: 10

Importance of Pointers in C

• Dynamic Memory Allocation: Pointers enable runtime memory allocation using malloc(), calloc(), realloc(), and free().
• Call by Reference: Allows functions to modify the actual variables of the caller.
• Array Handling: Arrays are internally represented as pointers; pointer arithmetic enables efficient array traversal.
• String Handling: Strings in C are character pointers; pointer operations simplify string processing.
• Data Structures: Pointers are essential for building linked lists, trees, stacks, and queues.
• Efficiency: Passing pointers to functions is more memory-efficient than passing large structures by value.

C Program – Sort N Numbers Using Pointer (Bubble Sort)

#include <stdio.h>

void bubbleSort(int *arr, int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++)
        for (j = 0; j < n - i - 1; j++)
            if (*(arr + j) > *(arr + j + 1)) {
                temp = *(arr + j);
                *(arr + j) = *(arr + j + 1);
                *(arr + j + 1) = temp;
            }
}

int main() {
    int n, i;
    printf("Enter number of elements: ");
    scanf("%d", &n);

    int arr[n];
    printf("Enter %d numbers:\n", n);
    for (i = 0; i < n; i++)
        scanf("%d", arr + i);   // using pointer notation

    bubbleSort(arr, n);

    printf("Sorted in ascending order:\n");
    for (i = 0; i < n; i++)
        printf("%d ", *(arr + i));
    printf("\n");

    return 0;
}

Output

Enter number of elements: 5
Enter 5 numbers:
40 10 30 50 20
Sorted in ascending order:
10 20 30 40 50

Text File vs Binary File

C Program – Copy source.txt to destination.txt

#include <stdio.h>
int main() {
    FILE *src, *dest;
    char ch;

    src = fopen("source.txt", "r");
    if (src == NULL) {
        printf("Error: Cannot open source.txt\n");
        return 1;
    }

    dest = fopen("destination.txt", "w");
    if (dest == NULL) {
        printf("Error: Cannot create destination.txt\n");
        fclose(src);
        return 1;
    }

    while ((ch = fgetc(src)) != EOF)
        fputc(ch, dest);

    printf("File copied successfully.\n");

    fclose(src);
    fclose(dest);
    return 0;
}

Output

File copied successfully.

Structure of a FORTRAN Program

      PROGRAM program_name       ! Program header (optional in F77)
C     Declaration section
      [data type declarations]

C     Executable section
      [statements]

C     Subprogram section (optional)
      [SUBROUTINE / FUNCTION definitions]

      STOP
      END

• PROGRAM statement: Optional header naming the program.
• Declaration section: All variables and arrays declared before use.
• Executable section: Contains READ, WRITE, arithmetic, and control statements.
• STOP: Terminates execution.
• END: Marks the physical end of the program unit.
• Column 1 is for C (comment); columns 2–5 for statement labels; column 6 for continuation; columns 7–72 for statements.

Data Types in FORTRAN

FORTRAN Program – Negative, Zero, or Positive Using Arithmetic IF

      PROGRAM ARITH_IF
      REAL N

      WRITE(*,*) 'Enter a number:'
      READ(*,*) N

C     Arithmetic IF: IF (expression) label1, label2, label3
C     Jumps to label1 if expression < 0
C     Jumps to label2 if expression = 0
C     Jumps to label3 if expression > 0

      IF (N) 10, 20, 30

   10 WRITE(*,*) 'The number is Negative.'
      GO TO 40

   20 WRITE(*,*) 'The number is Zero.'
      GO TO 40

   30 WRITE(*,*) 'The number is Positive.'

   40 STOP
      END

Output

Enter a number:
-5
The number is Negative.

Enter a number:
0
The number is Zero.

Enter a number:
8
The number is Positive.

Note: Arithmetic IF syntax — IF (expr) L1, L2, L3 — branches to L1 if expr < 0, L2 if expr = 0, L3 if expr > 0. It is unique to FORTRAN.

System Software vs Application Software [2]

Basic Steps for Software Development [4]

Software development follows the Software Development Life Cycle (SDLC):

1. Problem Analysis / Requirement Gathering: Identify and define what the software must do. Gather requirements from stakeholders. Produce a Requirements Specification Document (SRS).
2. System Design: Plan the overall architecture, data structures, algorithms, and interfaces. Includes high-level (HLD) and low-level design (LLD).
3. Coding / Implementation: Translate the design into actual source code using a suitable programming language (C, Java, Python, etc.).
4. Testing & Debugging: Execute the program with various inputs to detect errors (testing), then locate and fix them (debugging). Includes unit, integration, and system testing.
5. Documentation: Prepare user manuals, technical documentation, and inline code comments to help future developers and users.
6. Maintenance: After deployment, fix bugs reported by users, update features, and adapt the software to new environments.

Operator [1]

An operator is a symbol that instructs the compiler to perform a specific mathematical, relational, logical, or bitwise operation on operands.

int x = 5 + 3;   // + is the arithmetic operator
int y = (x > 3); // > is the relational operator

Types: Arithmetic (+, -, *, /, %), Relational (<, >, ==, !=), Logical (&&, ||, !), Assignment (=, +=), Bitwise (&, |, ^), Increment/Decrement (++, --), Conditional (?:), sizeof.

Keyword [1]

A keyword is a reserved word in C with a predefined meaning that cannot be used as an identifier. C has 32 keywords.

int, float, char, double, void, if, else, for, while, do,
switch, case, break, continue, return, struct, union,
typedef, enum, sizeof, static, extern, auto, register,
const, volatile, signed, unsigned, short, long, goto, default

Algorithm – Factorial of a Positive Integer [3]

Step 1: Start
Step 2: Read N from user
Step 3: If N < 0, print "Invalid" and goto Step 8
Step 4: Set fact = 1, i = 1
Step 5: If i > N, goto Step 7
Step 6: fact = fact * i,  i = i + 1,  goto Step 5
Step 7: Print fact
Step 8: Stop

Flowchart [3]

i) getch()

Syntax: int getch(void);  — Header: <conio.h>

Reads a single character from the keyboard without echoing it on screen and without waiting for Enter.

#include <stdio.h>
#include <conio.h>
int main() {
    char ch;
    printf("Press any key: ");
    ch = getch();          // reads char without displaying
    printf("\nYou pressed: %c", ch);
    return 0;
}

ii) gets()

Syntax: char *gets(char *str);  — Header: <stdio.h>

Reads a full line (including spaces) from stdin into str until a newline or EOF is encountered. The newline is replaced with '\0'.

#include <stdio.h>
int main() {
    char name[50];
    printf("Enter full name: ");
    gets(name);            // reads string with spaces
    printf("Hello, %s!\n", name);
    return 0;
}

iii) printf()

Syntax: int printf(const char *format, ...);  — Header: <stdio.h>

Formatted output function. Prints data to stdout using format specifiers (%d, %f, %c, %s, etc.).

#include <stdio.h>
int main() {
    int age = 20;
    float gpa = 3.85;
    char name[] = "Alice";
    printf("Name: %s, Age: %d, GPA: %.2f\n", name, age, gpa);
    // Output: Name: Alice, Age: 20, GPA: 3.85
    return 0;
}

iv) scanf()

Syntax: int scanf(const char *format, ...);  — Header: <stdio.h>

Formatted input function. Reads data from stdin and stores them at the given addresses. Returns the number of items successfully read.

#include <stdio.h>
int main() {
    int n;
    float x;
    char name[30];
    printf("Enter name, number, float: ");
    scanf("%s %d %f", name, &n, &x);
    printf("%s %d %.2f\n", name, n, x);
    return 0;
}

do-while vs while Loop [3]

// while loop
int i = 5;
while (i < 5) { printf("%d", i); i++; }  // prints nothing

// do-while loop
int j = 5;
do { printf("%d", j); j++; } while (j < 5); // prints 5 once

C Program – Armstrong Number Check (N-digit) [5]

An Armstrong (Narcissistic) number of N digits satisfies: sum of each digit raised to the power N equals the original number.

#include <stdio.h>
#include <math.h>

int main() {
    long long num, temp, orig;
    int digit, n = 0;
    double sum = 0;

    printf("Enter a positive number: ");
    scanf("%lld", &num);
    orig = num;
    temp = num;

    // Count digits
    while (temp != 0) {
        n++;
        temp /= 10;
    }

    temp = num;
    // Calculate sum of digits^n
    while (temp != 0) {
        digit = temp % 10;
        sum += pow(digit, n);
        temp /= 10;
    }

    if ((long long)sum == orig)
        printf("%lld is an Armstrong number.\n", orig);
    else
        printf("%lld is NOT an Armstrong number.\n", orig);

    return 0;
}

Output

Enter a positive number: 1634
1634 is an Armstrong number.

Enter a positive number: 153
153 is an Armstrong number.    [1³+5³+3³ = 1+125+27 = 153]

Enter a positive number: 100
100 is NOT an Armstrong number.

Passing Array to a Function [2]

In C, an array is always passed to a function by reference (by address) — the function receives a pointer to the first element. This means changes inside the function affect the original array.

// Syntax
return_type function_name(data_type arr[], int size);
// OR equivalently:
return_type function_name(data_type *arr, int size);

• The array name itself is a pointer to its first element.
• The size must be passed separately since it is not automatically known.
• There is no & operator needed — the array name already holds the address.
• Multi-dimensional arrays require all dimensions except the first: void f(int a[][4], int r).

C Program – Read and Sort 1-D Array (Bubble Sort) [5]

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp    = arr[j];
                arr[j]  = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void display(int arr[], int n) {
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int n, arr[100];
    printf("Enter number of elements: ");
    scanf("%d", &n);

    printf("Enter %d elements:\n", n);
    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    bubbleSort(arr, n);   // array passed by reference

    printf("Sorted array (ascending): ");
    display(arr, n);

    return 0;
}

Output

Enter number of elements: 6
Enter 6 elements:
45 12 78 3 56 23
Sorted array (ascending): 3 12 23 45 56 78

C Program – String Length Without Library Function

#include <stdio.h>

int main() {
    char str[200];
    int len = 0;

    printf("Enter a string: ");
    gets(str);                    // reads full line with spaces

    while (str[len] != '\0')     // count until null terminator
        len++;

    printf("Length of \"%s\" = %d\n", str, len);
    return 0;
}

Output

Enter a string: Hello World
Length of "Hello World" = 11

Enter a string: COMPUTER
Length of "COMPUTER" = 8

The loop increments len for every character until '\0' (null terminator) is found, which marks the end of the string in C. This replicates the behaviour of strlen() from <string.h>.

Function Prototyping [2]

A function prototype is a declaration of a function that specifies its name, return type, and parameter types before its actual definition. It tells the compiler about the function so it can perform type checking during compilation.

// Prototype (declaration) — usually before main()
int add(int a, int b);      // return type + name + parameter types

int main() {
    int result = add(3, 5); // compiler checks types using prototype
    return 0;
}

// Definition (actual body)
int add(int a, int b) {
    return a + b;
}

Why needed?

• Allows functions to be defined after main() without error.
• Enables the compiler to validate argument types and count at the call site.
• Required when functions are defined in separate files.
• Improves code readability by listing all functions at the top.

C Program – Fibonacci Series Using Recursion [5]

#include <stdio.h>

// Function prototype
int fibonacci(int n);

int main() {
    int n, i;
    printf("Enter number of terms: ");
    scanf("%d", &n);

    printf("Fibonacci series: ");
    for (i = 0; i < n; i++)
        printf("%d ", fibonacci(i));
    printf("\n");

    return 0;
}

// Recursive function definition
int fibonacci(int n) {
    if (n == 0) return 0;          // base case
    if (n == 1) return 1;          // base case
    return fibonacci(n-1) + fibonacci(n-2); // recursive case
}

Output

Enter number of terms: 8
Fibonacci series: 0 1 1 2 3 5 8 13

Recursive Trace (n=5)

fibonacci(5) = fibonacci(4) + fibonacci(3)
             = (fibonacci(3) + fibonacci(2)) + (fibonacci(2) + fibonacci(1))
             = ((fibonacci(2)+fibonacci(1)) + (fibonacci(1)+fibonacci(0)))
               + ((fibonacci(1)+fibonacci(0)) + 1)
             = ((1+1)+1+0) + (1+0+1) = 3 + 2 = 5  ✓

Nested Structure [3]

A nested structure is a structure that contains another structure as one of its members. This allows logically related sub-data to be grouped within a larger structure.

struct Date {
    int day, month, year;
};

struct Student {
    char name[50];
    int roll;
    struct Date dob;    // nested structure — Date inside Student
};

Accessing nested members:

struct Student s;
s.dob.day   = 15;       // dot operator chained
s.dob.month = 8;
s.dob.year  = 2003;
printf("%s born on %d/%d/%d", s.name, s.dob.day, s.dob.month, s.dob.year);

Dot (.) vs Arrow (->) Operator [2]

C Program Demonstrating Both Operators [3]

#include <stdio.h>
#include <string.h>

struct Address {
    char city[50];
    char zip[10];
};

struct Employee {
    int  id;
    char name[50];
    float salary;
    struct Address addr;   // nested structure
};

int main() {
    // Using dot operator with a structure variable
    struct Employee e1;
    e1.id = 101;
    strcpy(e1.name, "Ramesh Sharma");
    e1.salary = 45000.00;
    strcpy(e1.addr.city, "Kathmandu");
    strcpy(e1.addr.zip, "44600");

    printf("=== Using dot (.) operator ===\n");
    printf("ID     : %d\n",   e1.id);
    printf("Name   : %s\n",   e1.name);
    printf("Salary : %.2f\n", e1.salary);
    printf("City   : %s\n",   e1.addr.city);
    printf("ZIP    : %s\n",   e1.addr.zip);

    // Using arrow operator with a structure pointer
    struct Employee e2;
    struct Employee *ptr = &e2;

    ptr->id = 202;
    strcpy(ptr->name, "Sunita Thapa");
    ptr->salary = 52000.00;
    strcpy(ptr->addr.city, "Pokhara");
    strcpy(ptr->addr.zip, "33700");

    printf("\n=== Using arrow (->) operator ===\n");
    printf("ID     : %d\n",   ptr->id);
    printf("Name   : %s\n",   ptr->name);
    printf("Salary : %.2f\n", ptr->salary);
    printf("City   : %s\n",   ptr->addr.city);
    printf("ZIP    : %s\n",   ptr->addr.zip);

    return 0;
}

Output

=== Using dot (.) operator ===
ID     : 101
Name   : Ramesh Sharma
Salary : 45000.00
City   : Kathmandu
ZIP    : 44600

=== Using arrow (->) operator ===
ID     : 202
Name   : Sunita Thapa
Salary : 52000.00
City   : Pokhara
ZIP    : 33700

Pointer Arithmetic – Concept

Pointer arithmetic involves performing arithmetic operations on pointer variables. The operations are scaled automatically by the size of the data type the pointer points to.

• Increment (++): Moves pointer to the next element (adds sizeof(type) bytes).
• Decrement (--): Moves pointer to the previous element.
• Addition (ptr + n): Moves pointer forward by n elements.
• Subtraction (ptr - n): Moves pointer backward by n elements.
• Difference (ptr1 - ptr2): Gives number of elements between two pointers.

C Program – Pointer Arithmetic

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;         // ptr points to first element
    int i, n = 5;

    printf("Array traversal using pointer arithmetic:\n");

    // Using ptr++ to traverse
    for (i = 0; i < n; i++) {
        printf("arr[%d] = %d  (address: %u)\n", i, *ptr, ptr);
        ptr++;              // moves to next int (adds 4 bytes)
    }

    // Reset pointer
    ptr = arr;

    // Pointer + integer
    printf("\nptr + 2 points to: %d\n", *(ptr + 2));  // arr[2] = 30
    printf("ptr + 4 points to: %d\n", *(ptr + 4));  // arr[4] = 50

    // Difference between two pointers
    int *p1 = &arr[1];
    int *p2 = &arr[4];
    printf("\nElements between p1(arr[1]) and p2(arr[4]): %ld\n", p2 - p1);

    // Pointer comparison
    if (p2 > p1)
        printf("p2 is ahead of p1 in memory.\n");

    return 0;
}

Output (addresses may vary)

Array traversal using pointer arithmetic:
arr[0] = 10  (address: 6422280)
arr[1] = 20  (address: 6422284)
arr[2] = 30  (address: 6422288)
arr[3] = 40  (address: 6422292)
arr[4] = 50  (address: 6422296)

ptr + 2 points to: 30
ptr + 4 points to: 50

Elements between p1(arr[1]) and p2(arr[4]): 3
p2 is ahead of p1 in memory.

Each increment adds 4 bytes (size of int), demonstrating that pointer arithmetic is type-aware.

Text File vs Binary File [3]

C Program – Separate Odd and Even to Files [3]

#include <stdio.h>

int main() {
    FILE *odd_fp, *even_fp;
    int n, num;

    odd_fp  = fopen("ODD.txt",  "w");
    even_fp = fopen("EVEN.txt", "w");

    if (odd_fp == NULL || even_fp == NULL) {
        printf("Error opening files!\n");
        return 1;
    }

    printf("How many integers to enter? ");
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        printf("Enter positive integer %d: ", i + 1);
        scanf("%d", &num);

        if (num <= 0) {
            printf("Skipping non-positive number.\n");
            continue;
        }

        if (num % 2 != 0)
            fprintf(odd_fp,  "%d\n", num);  // write odd to ODD.txt
        else
            fprintf(even_fp, "%d\n", num);  // write even to EVEN.txt
    }

    fclose(odd_fp);
    fclose(even_fp);

    printf("\nOdd numbers written to ODD.txt\n");
    printf("Even numbers written to EVEN.txt\n");
    return 0;
}

Sample Run

How many integers to enter? 6
Enter positive integer 1: 7
Enter positive integer 2: 12
Enter positive integer 3: 3
Enter positive integer 4: 8
Enter positive integer 5: 15
Enter positive integer 6: 4

Odd numbers written to ODD.txt
Even numbers written to EVEN.txt

ODD.txt contents:   7   EVEN.txt contents: 12
                    3                      8
                    15                     4

Arithmetic IF Statement in FORTRAN [3]

The Arithmetic IF is a three-way branching statement unique to FORTRAN. It evaluates an arithmetic expression and transfers control to one of three labeled statements depending on whether the result is negative, zero, or positive.

      IF (arithmetic_expression) label1, label2, label3

C     Example: classify X
      IF (X) 10, 20, 30
   10 WRITE(*,*) 'Negative'
      GOTO 40
   20 WRITE(*,*) 'Zero'
      GOTO 40
   30 WRITE(*,*) 'Positive'
   40 CONTINUE

The arithmetic IF is a FORTRAN 77 feature; modern FORTRAN (90+) prefers IF-THEN-ELSE constructs.

FORTRAN Program – Palindrome Number Check [6]

A number is a palindrome if it reads the same forwards and backwards (e.g., 121, 1221, 12321).

      PROGRAM PALINDROME
      INTEGER N, ORIG, REV, DIGIT, TEMP

      WRITE(*,*) 'Enter a positive integer:'
      READ(*,*)  N

C     Store original number
      ORIG = N
      REV  = 0
      TEMP = N

C     Reverse the number
   10 IF (TEMP) 30, 30, 20
   20 DIGIT = MOD(TEMP, 10)
      REV   = REV * 10 + DIGIT
      TEMP  = TEMP / 10
      GOTO 10

C     Check palindrome
   30 IF (ORIG - REV) 40, 50, 40

   40 WRITE(*,*) ORIG, ' is NOT a Palindrome.'
      GOTO 60

   50 WRITE(*,*) ORIG, ' is a Palindrome.'

   60 STOP
      END

Output

Enter a positive integer:
12321
       12321 is a Palindrome.

Enter a positive integer:
1234
       1234 is NOT a Palindrome.

Enter a positive integer:
1221
       1221 is a Palindrome.

Explanation

• Statement 10: IF (TEMP) 30, 30, 20 — if TEMP ≤ 0 go to 30 (loop ends), else go to 20 (continue reversing).
• Statement 30: IF (ORIG - REV) 40, 50, 40 — if difference is non-zero → not palindrome (40), if zero → palindrome (50).
• Each iteration extracts the last digit and builds the reversed number.

Compilation Process in C

The compilation process converts human-readable C source code into an executable machine code through the following stages:

Source (.c)
   → Preprocessor → .i
   → Compiler     → .s (assembly)
   → Assembler    → .o (object)
   → Linker       → .exe / a.out (executable)

Flowchart – Sum of Digits

Variables and Constants in C

A variable is a named memory location whose value can change during program execution. A constant is a fixed value that cannot be changed once defined.

/* Variable Declaration in C */
int age;              // declare
int age = 20;         // declare and initialize
float price = 9.99;
char grade = 'A';
int a, b, c;          // multiple variables

/* Constants in C */
// Method 1: #define (macro constant)
#define PI 3.14159
#define MAX 100

// Method 2: const keyword
const float PI = 3.14159;
const int MAX = 100;

Variables and Constants in FORTRAN

In FORTRAN, variables are declared by specifying the data type before the variable name. Constants are defined using the PARAMETER statement.

C     Variable Declaration in FORTRAN
      INTEGER COUNT, N
      REAL    PRICE, TOTAL
      CHARACTER*20 NAME
      LOGICAL FLAG
      DOUBLE PRECISION X

C     Constants in FORTRAN using PARAMETER
      REAL PI
      PARAMETER (PI = 3.14159)

      INTEGER MAX
      PARAMETER (MAX = 100)

C     Implicit typing (FORTRAN default):
C     Variables starting with I-N are INTEGER
C     All others are REAL (unless declared otherwise)

else-if Ladder Syntax

if (condition1) {
    // block 1
} else if (condition2) {
    // block 2
} else if (condition3) {
    // block 3
} else {
    // default block
}

do-while Syntax

do {
    // loop body (executes at least once)
} while (condition);

C Program – Number Pattern

#include <stdio.h>
int main() {
    int rows; // Total number of rows
    int i, j, s;
    printf ("Enter the number of rows: ");
    scanf ("%d",&rows);
    for (i = 1; i <= rows; i++) {
        
        // 1. Print leading spaces for right alignment
        // Each number + space takes roughly 3-4 characters
        for (s = 1; s <= (rows - i); s++) {
            printf("    "); 
        }

        // 2. Print the multiples of i
        for (j = 1; j <= i; j++) {
            // %3d ensures each number takes up 3 spaces for alignment
            printf("%4d", i * j);
        }

        // 3. Move to the next line
        printf("\n");
    }

    return 0;
}

C Program – x^y Using Recursion

#include <stdio.h>

int power(int x, int y) {
    if (y == 0)
        return 1;              // base case: x^0 = 1
    return x * power(x, y - 1); // recursive case
}

int main() {
    int x, y;
    printf("Enter base (x): ");
    scanf("%d", &x);
    printf("Enter exponent (y): ");
    scanf("%d", &y);
    printf("%d ^ %d = %d\n", x, y, power(x, y));
    return 0;
}

Output

Enter base (x): 2
Enter exponent (y): 5
2 ^ 5 = 32

How the Program Works

The recursive function uses two rules:

• Base case: When y == 0, return 1 (any number to the power 0 is 1). This stops the recursion.
• Recursive case: power(x, y) = x * power(x, y-1). The function calls itself with a reduced exponent each time.

power(2, 5)
= 2 * power(2, 4)
= 2 * 2 * power(2, 3)
= 2 * 2 * 2 * power(2, 2)
= 2 * 2 * 2 * 2 * power(2, 1)
= 2 * 2 * 2 * 2 * 2 * power(2, 0)
= 2 * 2 * 2 * 2 * 2 * 1
= 32

Each call is pushed onto the call stack until the base case is reached, after which values are returned and multiplied as the stack unwinds.

toupper() and tolower()

Both functions are defined in <ctype.h> and operate on individual characters.

#include <ctype.h>
char c = 'a';
printf("%c", toupper(c));  // Output: A

char d = 'Z';
printf("%c", tolower(d));  // Output: z

C Program – Sort N Country Names Alphabetically

#include <stdio.h>
#include <string.h>

int main() {
    int n, i, j;
    char countries[50][50], temp[50];

    printf("Enter number of countries: ");
    scanf("%d", &n);

    printf("Enter country names:\n");
    for (i = 0; i < n; i++) {
        printf("Country %d: ", i + 1);
        scanf("%s", countries[i]);
    }

    // Bubble sort alphabetically
    for (i = 0; i < n - 1; i++)
        for (j = 0; j < n - i - 1; j++)
            if (strcmp(countries[j], countries[j + 1]) > 0) {
                strcpy(temp, countries[j]);
                strcpy(countries[j], countries[j + 1]);
                strcpy(countries[j + 1], temp);
            }

    printf("\nCountries in alphabetical order:\n");
    for (i = 0; i < n; i++)
        printf("%s\n", countries[i]);

    return 0;
}

Output

Enter number of countries: 4
Country 1: Nepal
Country 2: India
Country 3: China
Country 4: Bhutan

Countries in alphabetical order:
Bhutan
China
India
Nepal

Declaration of Pointers

A pointer is declared by placing an asterisk (*) before the variable name. The data type specifies what type of variable the pointer will point to.

data_type *pointer_name;

int    *p;     // pointer to integer
float  *fp;    // pointer to float
char   *cp;    // pointer to character
double *dp;    // pointer to double

Initialization of Pointers

A pointer is initialized by assigning it the address of a variable using the address-of operator (&). A pointer should never be used without initialization (it would be a dangling/wild pointer).

int a = 10;
int *p = &a;      // p now holds address of a

printf("%d", a);   // prints value: 10
printf("%u", p);   // prints address: e.g. 1000
printf("%d", *p);  // dereference: prints value 10

*p = 25;           // changes a to 25 via pointer
printf("%d", a);   // prints: 25

// NULL pointer (safe initialization when no target yet)
int *ptr = NULL;

Pointer Arithmetic

Arithmetic on pointers moves the pointer by multiples of the size of the data type it points to.

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    printf("%d\n", *ptr);      // 10  (address 1000)
    ptr++;
    printf("%d\n", *ptr);      // 20  (address 1004)
    ptr += 2;
    printf("%d\n", *ptr);      // 40  (address 1012)
    return 0;
}

Note: Multiplication, division, and addition of two pointers are not valid pointer operations.

C Program – Karmachari Structure with Search by Salary

#include <stdio.h>
#include <string.h>

#define MAX 10   /* Use 40000 in real case; reduced for demo */

struct karmachari {
    long  ID_Number;
    char  Name[50];
    float salary;
};

struct karmachari emp[MAX];

void search(int n, float target) {
    int i, found = 0;
    printf("\nRecords with salary = %.2f:\n", target);
    printf("%-12s %-20s %-10s\n", "ID Number", "Name", "Salary");
    printf("------------------------------------------\n");
    for (i = 0; i < n; i++) {
        if (emp[i].salary == target) {
            printf("%-12ld %-20s %-10.2f\n",
                   emp[i].ID_Number,
                   emp[i].Name,
                   emp[i].salary);
            found = 1;
        }
    }
    if (!found)
        printf("No records found with that salary.\n");
}

int main() {
    int n, i;
    float searchSal;

    printf("Enter number of employees (max %d): ", MAX);
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("\nEmployee %d:\n", i + 1);
        printf("ID Number (6-digit): ");
        scanf("%ld", &emp[i].ID_Number);
        printf("Name: ");
        scanf("%s", emp[i].Name);
        printf("Salary: ");
        scanf("%f", &emp[i].salary);
    }

    printf("\nEnter salary to search: ");
    scanf("%f", &searchSal);

    search(n, searchSal);

    return 0;
}

Sample Output

Enter number of employees (max 10): 3

Employee 1:
ID Number (6-digit): 100001
Name: RamBahadur
Salary: 45000

Employee 2:
ID Number (6-digit): 100002
Name: SitaDevi
Salary: 62000

Employee 3:
ID Number (6-digit): 100003
Name: HariPrasad
Salary: 45000

Enter salary to search: 45000

Records with salary = 45000.00:
ID Number    Name                 Salary
------------------------------------------
100001       RamBahadur           45000.00
100003       HariPrasad           45000.00

Note: In a 16-bit compiler (Turbo C), int is 2 bytes so long is used for 6-digit IDs. For 40,000 records, set #define MAX 40000.

C Program – Primes to File, Copy, and Display

#include <stdio.h>

int isPrime(int n) {
    int i;
    if (n < 2) return 0;
    for (i = 2; i <= n / 2; i++)
        if (n % i == 0) return 0;
    return 1;
}

int main() {
    int n1, n2, i;
    char ch;
    FILE *src, *dest;

    printf("Enter range n1 and n2: ");
    scanf("%d %d", &n1, &n2);

    /* Step 1: Write primes to Source file */
    src = fopen("Source.txt", "w");
    if (src == NULL) {
        printf("Error creating Source file.\n");
        return 1;
    }
    for (i = n1; i <= n2; i++)
        if (isPrime(i))
            fprintf(src, "%d\n", i);
    fclose(src);
    printf("Prime numbers written to Source.txt\n");

    /* Step 2: Copy Source to Destination */
    src  = fopen("Source.txt",      "r");
    dest = fopen("Destination.txt", "w");
    if (src == NULL || dest == NULL) {
        printf("Error opening files.\n");
        return 1;
    }
    while ((ch = fgetc(src)) != EOF)
        fputc(ch, dest);
    fclose(src);
    fclose(dest);
    printf("Content copied to Destination.txt\n");

    /* Step 3: Display Destination file */
    dest = fopen("Destination.txt", "r");
    if (dest == NULL) {
        printf("Error opening Destination file.\n");
        return 1;
    }
    printf("\nContents of Destination.txt:\n");
    while ((ch = fgetc(dest)) != EOF)
        putchar(ch);
    fclose(dest);

    return 0;
}

Sample Output (n1=10, n2=30)

Enter range n1 and n2: 10 30
Prime numbers written to Source.txt
Content copied to Destination.txt

Contents of Destination.txt:
11
13
17
19
23
29

FORTRAN Program – Fibonacci Sequence

      PROGRAM FIBONACCI
      INTEGER N, I, A, B, TEMP
      WRITE(*,*) 'Enter the number of terms:'
      READ(*,*) N

      A = 0
      B = 1

      WRITE(*,*) 'Fibonacci sequence:'
      DO 10 I = 1, N
        WRITE(*,100) A
        TEMP = A + B
        A = B
        B = TEMP
   10 CONTINUE

  100 FORMAT(I5)
      STOP
      END

Output (for n = 8)

Fibonacci sequence:
    0
    1
    1
    2
    3
    5
    8
   13

switch Statement vs User Defined Function

// switch example
switch (day) {
    case 1: printf("Monday"); break;
    case 2: printf("Tuesday"); break;
    default: printf("Other");
}

// User defined function example
int add(int a, int b) { return a + b; }
result = add(3, 5);

C Program – Transpose of N×N Matrix

#include <stdio.h>
#define MAX 10

void transpose(int a[][MAX], int t[][MAX], int n) {
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            t[j][i] = a[i][j];
}

void printMatrix(int m[][MAX], int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++)
            printf("%4d", m[i][j]);
        printf("\n");
    }
}

int main() {
    int a[MAX][MAX], t[MAX][MAX], n, i, j;

    printf("Enter size of matrix (N): ");
    scanf("%d", &n);

    printf("Enter %dx%d matrix elements:\n", n, n);
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            scanf("%d", &a[i][j]);

    transpose(a, t, n);

    printf("\nOriginal Matrix:\n");
    printMatrix(a, n);

    printf("\nTranspose Matrix:\n");
    printMatrix(t, n);

    return 0;
}

Output

Enter size of matrix (N): 3
Enter 3x3 matrix elements:
1 2 3
4 5 6
7 8 9

Original Matrix:
   1   2   3
   4   5   6
   7   8   9

Transpose Matrix:
   1   4   7
   2   5   8
   3   6   9