Programming Fundamentals — Flowcharts, Algorithms & C Basics

Problem solving with computers

1. Understand the problem (inputs, required outputs, constraints).
2. Design a solution — algorithm, flowchart or pseudocode.
3. Code the solution in a programming language.
4. Test and debug.
5. Document and maintain.

Algorithms

An algorithm is a finite, step-by-step set of well-defined instructions to solve a problem.

Characteristics of a good algorithm

Example algorithm — area of a rectangle

1. Start
2. Read length L and breadth B
3. Area ← L × B
4. Print Area
5. Stop

Pseudocode

Informal, language-independent description using programming-like keywords:

BEGIN
  READ L, B
  AREA = L * B
  PRINT AREA
END

Algorithm efficiency — time and space complexity (Big-O notation, e.g. linear search O(n), binary search O(log n)).

Flowcharts

A flowchart is a graphical representation of an algorithm using standard symbols.

Rules

• Flow generally top to bottom, left to right; one start and one stop.
• Decision symbols have one entry and two (or more) exits, labelled.
• Flow lines should not cross unnecessarily; use connectors.

Advantages and limitations

• Advantages: easy to understand and communicate logic; helps debugging and documentation.
• Limitations: difficult to draw/modify for complex programs; not directly executable.

Example — check whether a beam passes deflection

Start → Input actual deflection δ and span L → Process: allowable = L/250 → Decision: δ ≤ allowable? → Yes: print "Safe" / No: print "Revise section" → Stop

Decision tables

Tabular representation of conditions and corresponding actions — useful when many combinations exist (e.g. concrete exposure condition and minimum grade).

Programming paradigms

Structured programming constructs: sequence, selection (if/switch), iteration (loops) — sufficient for any algorithm.

Program development life cycle

Problem definition → analysis → design (algorithm/flowchart) → coding → testing and debugging → documentation → deployment → maintenance.

Errors and debugging

Debugging — finding and fixing bugs (breakpoints, tracing, test cases, print statements).

C programming basics

• C was developed by Dennis Ritchie at Bell Laboratories in 1972 (used to rewrite Unix).
• Middle-level, procedural, compiled language; portable, efficient; basis of C++, Java, etc.
• Case-sensitive; statements end with semicolon (;).

Structure of a C program

#include <stdio.h>      /* preprocessor directive: header file */
#define PI 3.14159      /* symbolic constant */

int main(void)          /* execution starts at main() */
{
    float d, area;                   /* variable declarations */
    printf("Enter pipe diameter (m): ");
    scanf("%f", &d);                 /* input */
    area = PI * d * d / 4;           /* processing */
    printf("Area = %.4f m2\n", area); /* output */
    return 0;
}

Compilation process

Source code (.c) → preprocessor (handles #include, #define) → compiler (object code) → linker (links libraries) → executable → loader runs it.

Tokens

Data types (typical sizes on modern 32/64-bit systems)

(Sizes are implementation-dependent; use sizeof to check.)

Operators

• Integer division truncates: 7/2 = 3; 7.0/2 = 3.5.
• Precedence (high to low, simplified): () → unary (! ++ --) → * / % → + - → relational → equality → && → || → ternary → assignment.

Control structures

/* if–else */
if (fck >= 25)
    printf("Grade OK\n");
else
    printf("Grade not OK\n");

/* switch */
switch (zone) {
    case 2: Z = 0.10; break;
    case 3: Z = 0.16; break;
    case 4: Z = 0.24; break;
    case 5: Z = 0.36; break;
    default: printf("Invalid zone\n");
}

/* for loop */
for (i = 1; i <= 10; i++)
    sum = sum + i;

/* while loop — condition checked first (entry-controlled) */
while (error > 0.001) { /* iterate */ }

/* do–while — executes at least once (exit-controlled) */
do { /* read value */ } while (value < 0);

• break exits a loop/switch; continue skips to the next iteration.

Arrays and strings

• Array — collection of same-type elements with a common name: float load[5]; indices 0 to 4.
• 2D array: int m[3][3];
• String — character array ending with null character '\0': char name[20] = "Bridge"; — functions in <string.h>: strlen, strcpy, strcat, strcmp.

Functions

• Reusable blocks: declaration (prototype), definition, call.
• Library functions (printf, sqrt in <math.h>) and user-defined functions.
• Call by value (copy passed) vs call by reference (address passed using pointers).
• Recursion — function calling itself (e.g. factorial).

Pointers (introduction)

• A pointer stores the memory address of a variable: int *p; p = &x; → *p gives the value of x.
• Used for arrays, dynamic memory (malloc, free), call by reference, data structures.

Other features

Structures (struct grouping different types — e.g. a beam record with span, width, depth), unions, file handling (fopen, fprintf, fscanf, fclose), preprocessor macros.