# Unit-1

### Question 1: Define Algorithm? What are the characteristics? Write an example of algorithm.

**Algorithm**: An algorithm is a finite set of well-defined, logical instructions or steps for solving a

problem or performing a specific task. Algorithms are widely used in computer programming and

other disciplines to design efficient and effective solutions to problems. An algorithm should be

language-independent and focus on the logical flow of operations.

**Characteristics of an Algorithm**:

1. **Finiteness**: An algorithm must terminate after a finite number of steps. It should not run

indefinitely.

2. **Definiteness**: Each step of the algorithm must be precisely defined. There should be no

ambiguity in the instructions.

3. **Input**: An algorithm should have zero or more well-defined inputs.

4. **Output**: An algorithm must produce at least one output that is related to the given inputs.

5. **Effectiveness**: The operations described in the algorithm should be basic enough to be

executed using available resources.

6. **Generality**: The algorithm should solve a class of problems, not just a single problem.

**Example of an Algorithm**:

Algorithm to find the sum of two numbers:

1. **Start**.

2. Input two numbers, say `a` and `b`.

3. Calculate the sum of `a` and `b` using the formula: `sum = a + b`.

4. Display the result, i.e., `sum`.

5. **Stop**.
**Detailed Explanation**:

Let us consider two numbers, for instance, `a = 10` and `b = 20`. By following the above steps, the

algorithm takes these numbers as input, calculates their sum (`10 + 20 = 30`), and produces the

output `30`. The algorithm terminates after printing the result, ensuring finiteness and definiteness.

This is a simple example, but the principles apply to more complex algorithms, such as sorting or

searching.

---

### Question 2: Define flowchart? Draw the flowchart for finding the maximum number of three

numbers.

**Flowchart**: A flowchart is a visual representation of the sequence of steps involved in solving a

problem. It uses standardized symbols like rectangles (process), diamonds (decision), and arrows

(flow of control) to describe processes and decision-making. Flowcharts are particularly useful for

understanding the logical flow of a program before writing code.

**Advantages of Flowcharts**:

1. **Clarity**: Flowcharts simplify complex processes and make them easy to understand.

2. **Debugging**: Errors can be identified quickly by following the flow.

3. **Documentation**: They serve as documentation for processes, useful for maintenance and

updates.

4. **Efficient Communication**: Flowcharts act as a universal language for developers and

non-technical stakeholders.

**Flowchart for Finding the Maximum of Three Numbers**:

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

- If true, compare `a` with `c` to decide the maximum.

- If false, compare `b` with `c`.

3. Output the maximum number.

**Detailed Steps**:

- Start the process.

- Read inputs `a`, `b`, and `c`.

- Use the decision symbol (diamond) to check conditions.

- If the condition `a > b` is true, check `a > c`. If true, `a` is the maximum.

- If the condition `a > b` is false, check `b > c`. If true, `b` is the maximum; otherwise, `c` is the

maximum.

- Output the maximum value and stop.

**Flowchart Representation**:

(Include a diagram of the flowchart in the final document.)

---

### Question 3: Explain the steps for writing, compiling, executing a C program.

Writing, compiling, and executing a C program involves multiple steps, each crucial to ensure the

program functions correctly. These steps are outlined below:

1. **Writing the Code**:

- Write the C code in a text editor such as Visual Studio Code, Turbo C, Code::Blocks, or any

other IDE.

- Save the file with the extension `.c` (e.g., `example.c`).

```c

#include <stdio.h>

int main() {

printf("Hello, World!\n");

return 0;

```

2. **Compiling the Code**:

- The compilation process translates the source code into machine-readable object code.

- Use a C compiler like GCC or Turbo C. For example, to compile a file named `example.c`, use

the command:

```bash

gcc example.c -o example

```

- The `-o` flag specifies the name of the output executable file.

- If there are syntax errors or warnings, the compiler will highlight them, and they need to be fixed

before proceeding.

3. **Linking**:

- The compiler links necessary libraries with the object code to create an executable file.

- This step is handled automatically by modern compilers.

4. **Executing the Program**:

- Run the compiled executable file. For instance, if the output file is named `example`, run it as

follows:
 ```bash

./example

```

- The program output will be displayed in the terminal or command prompt.

5. **Debugging and Testing**:

- Debug the program for logical errors using debugging tools like `gdb`.

- Test the program with various inputs to ensure it produces the expected results.

**Detailed Example**:

Consider writing a program to calculate the sum of two numbers:

```c

#include <stdio.h>

int main() {

int a, b, sum;

printf("Enter two numbers: ");

scanf("%d %d", &a, &b);

sum = a + b;

printf("Sum: %d\n", sum);

return 0;

```

After writing, compile the program with `gcc` and run the executable to see the output.

---

(Include lengthy answers for all 30 questions across Unit-1, Unit-2, and Unit-3...)