1. Define a Computer System and its Main Components.

Also Draw the

Block Diagram.
A computer system is a combination of hardware and software that works
together to perform a wide variety of tasks. The main components of a
computer system include:
o Input Devices: Devices like keyboard, mouse, and scanner that
allow the user to input data.
o Output Devices: Devices like monitor and printer that allow the
computer to display or output data.
o Central Processing Unit (CPU): The brain of the computer, which
includes the Control Unit (CU), Arithmetic and Logic Unit (ALU),
and Registers.
o Memory (RAM & ROM): Storage for data and instructions that are
used during program execution.
o Storage Devices: Hard drives, SSDs, CDs, etc., used for long-term
data storage.
o Software: Operating systems, applications, and programs that
provide the instructions for the computer to function.
Block Diagram:
lua
Copy code
+-------------------+ +-------------------+ +------------------+
| Input Devices | ---> | CPU | ---> | Output Devices |
| (Keyboard, Mouse)| | (Control Unit, ALU)| | (Monitor, Printer)|
+-------------------+ +-------------------+ +------------------+
^ |
| v
+--------------+ +--------------------+
| Storage | <------> | Memory (RAM/ROM)|
 | (HDD, SSD) | +--------------------+
+--------------+

2. Difference Between Syntax Errors and Logical Errors in C Programming:

o Syntax Errors: These occur when the code does not conform to
the rules of the C language. Examples include missing semicolons,
mismatched parentheses, or incorrect use of keywords. These
errors are usually caught by the compiler.
Example:
c
Copy code
int main() {
printf("Hello, World!) // Missing closing quote and semicolon
}
o Logical Errors: These errors occur when the code does not
perform as expected, even though the syntax is correct. These are
often more difficult to debug as the program runs without
crashing but gives wrong results.
Example:
c
Copy code
int add(int a, int b) {
return a - b; // Logical error: wrong operation, should be a + b
}

3. What is a Pseudo Code and How It is Used in Programming?

Pseudo code is a high-level description of a computer program or algorithm,
written in an informal way that resembles programming language constructs
but without strict syntax. It helps to plan the logic of the program before
writing actual code.
Example:
arduino
Copy code
BEGIN
INPUT number1
INPUT number2
sum = number1 + number2
PRINT sum
END
Pseudo code helps programmers to think about the logic first and then convert
it to actual code in any language.

4. Functions of a Loader and a Linker in the Process of Executing a

Program:
o Loader: The loader is responsible for loading the program into the
memory for execution. It allocates memory space, adjusts the
addresses in the program, and prepares it to run.
o Linker: The linker combines object code generated by the compiler
into an executable program. It resolves addresses and references
to libraries, making the program ready for execution.

5. Structure of a C Program and the Significance of the main() Function:

A typical C program consists of the following sections:
o Preprocessor Directives: Directives such as #include that are
processed before compilation.
o Global Declarations: Variables and functions that are accessible
throughout the program.
 o main() Function: The entry point of the program. Every C program
must have a main() function, which is the first function executed
when the program runs.
o Other Functions: Additional functions are defined after the main()
function.
Example:
c
Copy code
#include <stdio.h> // Preprocessor directive

int main() { // main() function

printf("Hello, World!");
return 0;
}

6. Difference Between Logical AND (&&) and Logical OR (||) Operators in

C:
o Logical AND (&&): Returns true only if both conditions are true.
o Logical OR (||): Returns true if at least one of the conditions is
true.
Example:
c
Copy code
if (x > 0 && y > 0) // True if both x and y are greater than 0
if (x > 0 || y > 0) // True if either x or y is greater than 0

7. Type Conversion in C:
Type conversion refers to converting a value from one data type to another.
 o Implicit Type Conversion: Automatically done by the compiler
when data is converted from a smaller to a larger data type.
Example:
c
Copy code
int x = 5;
double y = x; // Implicit conversion from int to double
o Explicit Type Casting: Done manually by the programmer using a
cast operator. Example:
c
Copy code
double x = 5.7;
int y = (int)x; // Explicit conversion from double to int

8. Difference Between One-Dimensional and Two-Dimensional Arrays:

o One-Dimensional Array: A linear collection of elements, accessed
using a single index. Example:
c
Copy code
int arr[5] = {1, 2, 3, 4, 5};
o Two-Dimensional Array: A matrix-like structure with rows and
columns. Accessed using two indices. Example:
c
Copy code
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
o Memory Representation: Both are stored in contiguous memory
locations, but two-dimensional arrays are stored in a row-major
order (row by row).
 9. Differences Between While and Do-While Loops in C:
o While Loop: The condition is checked before the loop runs. If the
condition is false initially, the loop will not execute.
o Do-While Loop: The condition is checked after the loop executes,
so it always executes at least once.
Example:
c
Copy code
// Using do-while to print 1 through 10
int i = 1;
do {
printf("%d ", i);
i++;
} while (i <= 10);

10.Situation Where a goto Statement Might Be Used in a Loop:

The goto statement can be used for skipping certain parts of code within a loop
or jumping to a label to handle errors or specific cases. However, its use is
discouraged due to the risk of creating difficult-to-maintain code.
Example:
c
Copy code
int i;
for (i = 0; i < 10; i++) {
if (i == 5) {
goto skip; // Skip printing 5
}
printf("%d ", i);
}
skip:

11. Representation of Arrays in Memory

Arrays in C are stored in contiguous memory locations, and elements are
accessed using an index.
 One-Dimensional Arrays: Stored as a continuous block of memory.
Example:
c
Copy code
int arr[3] = {1, 2, 3};
Memory Representation: arr[0], arr[1], arr[2] are stored sequentially in
memory.
 Multi-Dimensional Arrays: These are stored in a row-major order in
memory. For a 2D array, elements in each row are stored contiguously.
Example:
c
Copy code
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
Memory Representation: The elements of the matrix are stored like:
css
Copy code
matrix[0][0], matrix[0][1], matrix[0][2], matrix[1][0], matrix[1][1], matrix[1][2]
Accessing Elements with Pointers:
 You can access array elements using pointers in C.
Example:
c
Copy code
int arr[3] = {1, 2, 3};
int *ptr = arr; // Pointer to the array
printf("%d", *(ptr + 1)); // Accessing arr[1] using pointer arithmetic

12. Types of Functions in C

In C, functions are categorized based on their return type and the parameters
they accept.
1. Functions with No Arguments and No Return Value:
o Example:
c
Copy code
void printMessage() {
printf("Hello, World!");
}
2. Functions with Arguments but No Return Value:
o Example:
c
Copy code
void printSum(int a, int b) {
printf("%d", a + b);
}
3. Functions with Arguments and a Return Value:
o Example:
c
Copy code
int add(int a, int b) {
 return a + b;
}
4. Functions with No Arguments but a Return Value:
o Example:
c
Copy code
int getNumber() {
return 42;
}

13. Array of Pointers in C

An array of pointers is an array where each element is a pointer to another
variable or data. It can be used to store multiple strings (as each string is an
array of characters).
Example:
c
Copy code
#include <stdio.h>

int main() {
char *arr[] = {"Hello", "World", "C"};
for (int i = 0; i < 3; i++) {
printf("%s ", arr[i]);
}
return 0;
}
Output:
mathematica
Copy code
Hello World C

14. Difference Between an Assembler, Compiler, and Interpreter

 Assembler: Converts assembly language code (low-level) into machine
code (object code). Example: NASM, GAS.
 Compiler: Converts high-level language code (like C) into machine code
or intermediate code in one go. Example: gcc, clang.
 Interpreter: Executes high-level code line by line without converting it
into machine code. Example: Python, Ruby.

15. What are Recursive Functions?

A recursive function is a function that calls itself to solve a problem. Recursive
functions typically have two components:
 Base case: A condition where the recursion stops.
 Recursive case: The part where the function calls itself.
Advantages:
 Simplifies problems that have recursive structures, like factorials,
Fibonacci numbers, etc.
 Easier to understand and implement.
Limitations:
 Can lead to stack overflow if the recursion depth is too deep.
 Inefficient in some cases (e.g., computing Fibonacci numbers without
memoization).
Example:
c
Copy code
int factorial(int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}

16. Difference Between Call by Value and Call by Reference in C

 Call by Value: The function gets a copy of the variable’s value. Changes
to the parameter inside the function don’t affect the original variable.
Example:
c
Copy code
void swapByValue(int a, int b) {
int temp = a;
a = b;
b = temp;
}
 Call by Reference: The function gets the address of the variable. Changes
to the parameter affect the original variable.
Example:
c
Copy code
void swapByReference(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
Demonstrating Swap:
c
Copy code
#include <stdio.h>

// Call by value
void swapByValue(int a, int b) {
int temp = a;
a = b;
b = temp;
}

// Call by reference
void swapByReference(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}

int main() {
int x = 5, y = 10;
swapByValue(x, y);
printf("Call by Value: x = %d, y = %d\n", x, y); // x and y remain unchanged

swapByReference(&x, &y);
printf("Call by Reference: x = %d, y = %d\n", x, y); // x and y are swapped
return 0;
}

17. How Pointers Are Declared in C and Pointer Operations

Pointers in C are declared using the * operator. They store the memory address
of variables.
 Declaration:
c
Copy code
int *ptr;
 Dereferencing: To access the value stored at the address the pointer is
pointing to.
c
Copy code
int x = 10;
int *ptr = &x;
printf("%d", *ptr); // Dereferencing to print value 10
 Pointer Arithmetic: You can perform arithmetic on pointers (e.g.,
incrementing the pointer to point to the next memory location).
c
Copy code
int arr[] = {1, 2, 3};
int *ptr = arr;
ptr++; // Now points to arr[1]
printf("%d", *ptr); // Prints 2

18. How Arrays Are Passed to Functions in C

When passing an array to a function, a pointer to the first element is passed.
Arrays are passed by reference, meaning changes to the array inside the
function will affect the original array.
Example:
c
Copy code
#include <stdio.h>

void sumArray(int arr[], int size) {

int sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i];
}
printf("Sum: %d\n", sum);
}

int main() {
int arr[] = {1, 2, 3, 4, 5};
sumArray(arr, 5);
return 0;
}

19. Enumerated Data Types in C

Enumerated types (enum) allow you to define a variable that can hold one of a
set of predefined constants, making code more readable.
Example:
c
Copy code
#include <stdio.h>

enum Weekday { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday,

Saturday };

int main() {
enum Weekday today = Monday;
if (today == Monday) {
printf("It's Monday!\n");
}
return 0;
}

20. Program to Use Switch Statement to Print the Season Based on User Input
c
Copy code
#include <stdio.h>

int main() {
int month;
printf("Enter month number (1-12): ");
scanf("%d", &month);

switch (month) {
case 1:
case 2:
 case 12:
printf("Winter\n");
break;
case 3:
case 4:
case 5:
printf("Spring\n");
break;
case 6:
case 7:
case 8:
printf("Summer\n");
break;
case 9:
case 10:
case 11:
printf("Fall\n");
break;
default:
printf("Invalid month\n");
}
return 0;
}
21. Differences Between Structures and Unions in C
 Structures: A structure is a collection of variables of different data types
grouped together. Each member of a structure has its own memory
location.
Example:
c
Copy code
struct Employee {
int id;
char name[50];
};
 Unions: A union is similar to a structure, but all members share the same
memory location. Only one member can hold a value at a time.
Example:
c
Copy code
union Data {
int i;
float f;
};
Memory Allocation:
 Structures: The total memory size is the sum of the sizes of all members.
 Unions: The total memory size is the size of the largest member because
all members share the same memory.
Program Example (Structure and Union):
c
Copy code
#include <stdio.h>

// Structure definition
struct Employee {
 int id;
char name[50];
};

// Union definition
union Data {
int i;
float f;
};

int main() {
struct Employee emp = {1, "John Doe"};
printf("Employee ID: %d, Name: %s\n", emp.id, emp.name);

union Data data;

data.i = 42;
printf("Union Data (int): %d\n", data.i);

data.f = 3.14;
printf("Union Data (float): %.2f\n", data.f); // Union stores the float now

return 0;
}

22. How Multi-Dimensional Arrays Can Be Used to Solve Problems

Multi-dimensional arrays can be used to represent complex data structures like
matrices or grids. Operations like matrix addition, subtraction, and
multiplication are common use cases.
Program to Perform Matrix Addition, Subtraction, and Multiplication:
c
Copy code
#include <stdio.h>

#define ROWS 2
#define COLS 2

void matrixAdd(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS]

[COLS]) {
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
result[i][j] = A[i][j] + B[i][j];
}
}
}

void matrixSubtract(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS]

[COLS]) {
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
result[i][j] = A[i][j] - B[i][j];
}
}
}

void matrixMultiply(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS]

[COLS]) {
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
result[i][j] = 0;
for (int k = 0; k < COLS; k++) {
result[i][j] += A[i][k] * B[k][j];
}
}
}
}

void printMatrix(int matrix[ROWS][COLS]) {

for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
}

int main() {
int A[ROWS][COLS] = {{1, 2}, {3, 4}};
int B[ROWS][COLS] = {{5, 6}, {7, 8}};
int result[ROWS][COLS];
 printf("Matrix A:\n");
printMatrix(A);
printf("Matrix B:\n");
printMatrix(B);

matrixAdd(A, B, result);
printf("Matrix A + B:\n");
printMatrix(result);

matrixSubtract(A, B, result);
printf("Matrix A - B:\n");
printMatrix(result);

matrixMultiply(A, B, result);
printf("Matrix A * B:\n");
printMatrix(result);

return 0;
}

23. Differences Between Character Arrays and Strings in C

 Character Arrays: A character array is a sequence of characters, where
each character is stored in an individual array element. It is not null-
terminated by default unless explicitly defined.
Example:
c
Copy code
char arr[] = {'H', 'e', 'l', 'l', 'o'};
 Strings: A string is a null-terminated array of characters. In C, a string is
just an array of characters that ends with the special null character '\0'.
Example:
c
Copy code
char str[] = "Hello"; // Implicitly null-terminated
Program to Find Frequency of Vowels in a String:
c
Copy code
#include <stdio.h>
#include <string.h>

int main() {
char str[] = "Hello, World!";
int vowelCount = 0;

for (int i = 0; i < strlen(str); i++) {

if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' || str[i] == 'u' ||
str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' || str[i] == 'U') {
vowelCount++;
}
}

printf("Number of vowels: %d\n", vowelCount);

return 0;
}

24. Purpose of a Linker and a Loader

 Linker: The linker combines object files generated by the compiler into a
single executable. It resolves symbols (such as functions and variables)
and assigns memory addresses.
 Loader: The loader loads the executable file into memory and prepares it
for execution. It also allocates memory and adjusts the addresses.

25. Pseudocode to Find the Largest of Three Numbers

Pseudocode:
vbnet
Copy code
BEGIN
READ num1, num2, num3
IF num1 > num2 AND num1 > num3 THEN
PRINT num1 is the largest
ELSE IF num2 > num3 THEN
PRINT num2 is the largest
ELSE
PRINT num3 is the largest
END

26. Structure of a C Program

A typical C program structure is as follows:
1. Preprocessor Directives: These include instructions like #include to
include libraries or other files.
2. Global Declarations: Variables and functions are declared here.
 3. Main Function: The entry point for the execution.
4. Other Functions: Additional helper functions defined after main().
Example:
c
Copy code
#include <stdio.h> // Preprocessor directive

int add(int a, int b) { // Function definition

return a + b;
}

int main() { // Main function

int x = 5, y = 10;
printf("Sum: %d", add(x, y)); // Calling the function
return 0;
}

27. Storage Classes in C

There are four types of storage classes in C:
1. auto: Default storage class for local variables; variables are automatically
created and destroyed when entering and exiting the scope. Example:
c
Copy code
void func() {
auto int x = 10;
}
 2. register: Suggests that a variable should be stored in a CPU register for
faster access. Example:
c
Copy code
register int x = 10;
3. static: Retains the value of a variable between function calls. Example:
c
Copy code
static int count = 0;
4. extern: Declares a variable that is defined outside of the current file.
Example:
c
Copy code
extern int x; // Variable declared in another file

28. Significance of Return Types in Functions

The return type of a function specifies the type of value the function will
return. It determines how the function's result is treated.
 void: Indicates no value is returned.
c
Copy code
void function() { ... }
 Non-void: The function returns a value of the specified type (e.g., int,
float).
c
Copy code
int add(int a, int b) {
return a + b;
}
29. Operator Precedence and Associativity in C
 Operator Precedence: It determines the order in which operators are
evaluated in an expression. Operators with higher precedence are
evaluated before those with lower precedence.
 Operator Associativity: It defines the order in which operators of the
same precedence level are evaluated. Most operators in C have left-to-
right associativity, but some like assignment (=) and conditional (?:) have
right-to-left associativity.
Example to demonstrate precedence and associativity:
c
Copy code
#include <stdio.h>

int main() {
int a = 5, b = 10, c = 2;
int result = a + b * c; // Multiplication has higher precedence than addition
printf("Result: %d\n", result); // Output will be 25, not 34

int d = 5;
d = 10 + 2 * 3; // Multiplication first, then addition
printf("d = %d\n", d); // Output will be 16
return 0;
}

30. Algorithm, Pseudocode, and C Code for Area of Shapes

Circle:
 Formula: Area = π * r²
Algorithm:
1. Input radius.
2. Calculate area using the formula.
3. Print the result.
Pseudocode:
sql
Copy code
BEGIN
READ radius
area = 3.14 * radius * radius
PRINT area
END
C Code:
c
Copy code
#include <stdio.h>
#define PI 3.14

int main() {
float radius, area;
printf("Enter radius: ");
scanf("%f", &radius);
area = PI * radius * radius;
printf("Area of the circle: %.2f\n", area);
return 0;
}
Triangle:
 Formula: Area = (base * height) / 2
Algorithm:
1. Input base and height.
2. Calculate area using the formula.
3. Print the result.
Pseudocode:
arduino
Copy code
BEGIN
READ base, height
area = (base * height) / 2
PRINT area
END
C Code:
c
Copy code
#include <stdio.h>

int main() {
float base, height, area;
printf("Enter base and height: ");
scanf("%f %f", &base, &height);
area = (base * height) / 2;
printf("Area of the triangle: %.2f\n", area);
return 0;
}
Rectangle:
 Formula: Area = length * width
Algorithm:
1. Input length and width.
2. Calculate area using the formula.
3. Print the result.
Pseudocode:
arduino
Copy code
BEGIN
READ length, width
area = length * width
PRINT area
END
C Code:
c
Copy code
#include <stdio.h>

int main() {
float length, width, area;
printf("Enter length and width: ");
scanf("%f %f", &length, &width);
area = length * width;
printf("Area of the rectangle: %.2f\n", area);
 return 0;
}

31. Variables in C: Declaration and Initialization

A variable in C is used to store data that can change during program execution.
 Declaration: Specifies the variable type and name.
c
Copy code
int a; // Declare an integer variable 'a'
 Initialization: Assigns an initial value to a variable at the time of
declaration.
c
Copy code
int a = 5; // Initialize variable 'a' with value 5
 Memory Storage: The compiler allocates memory based on the type of
variable, e.g., an int typically takes 4 bytes.

32. Role of Memory in a Computer System

 Primary Memory: Also called RAM (Random Access Memory), it stores
data and instructions that are currently being used or processed by the
CPU. It's fast and volatile.
o Example: RAM in a computer.
 Secondary Storage: Non-volatile memory used for storing data
permanently. It's slower than primary memory but can hold much larger
amounts of data.
o Example: Hard drives, SSDs.

33. Purpose of Break and Continue in Loops

  break: Exits the loop immediately, even if the loop condition has not
been satisfied.
 continue: Skips the current iteration of the loop and proceeds with the
next iteration.
Program Using continue to Skip Even Numbers:
c
Copy code
#include <stdio.h>

int main() {
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue; // Skip even numbers
}
printf("%d ", i);
}
return 0;
}
Output: 1 3 5 7 9

34. Object Code and Executable Code

 Object Code: The intermediate machine code produced by the compiler
after compiling the source code. It is not directly executable but contains
instructions for the machine.
 Executable Code: The final machine code produced after linking, which
can be executed by the computer.
Example:
 Object code: .o or .obj files.
  Executable code: .exe or binary files.

35. Recursion in Programming

Recursion is a technique where a function calls itself to solve a problem. It's
typically used when a problem can be broken down into smaller subproblems.
Advantages:
 Simplifies code for problems like tree traversal, factorial, Fibonacci
sequence, etc.
Limitations:
 Can lead to stack overflow if the recursion depth is too large.
 Generally less efficient than iterative solutions.
Recursive Function to Compute nth Fibonacci Number:
c
Copy code
#include <stdio.h>

int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
int n;
printf("Enter a number: ");
scanf("%d", &n);
 printf("Fibonacci number at position %d: %d\n", n, fibonacci(n));
return 0;
}

36. Pointers in Multi-Dimensional Arrays

Pointers can be used to access elements in multi-dimensional arrays by treating

the array as a continuous block of memory.
Program to Access Elements of a 2D Array Using Pointers:
c
Copy code
#include <stdio.h>

int main() {
int arr[2][2] = {{1, 2}, {3, 4}};
int *ptr = &arr[0][0]; // Pointer to the first element

// Accessing elements using pointer arithmetic

printf("Element at [0][0]: %d\n", *(ptr));
printf("Element at [0][1]: %d\n", *(ptr + 1));
printf("Element at [1][0]: %d\n", *(ptr + 2));
printf("Element at [1][1]: %d\n", *(ptr + 3));

return 0;
}
37. Pointer Arithmetic with Multi-Dimensional Arrays

Pointer arithmetic in multi-dimensional arrays works similarly to one-

dimensional arrays, but the memory layout is sequential, row by row.
For a 2D array, you can treat it as a 1D array of pointers. Accessing elements
involves considering the total number of columns in the array for pointer
arithmetic.
Example:
c
Copy code
int arr[2][2] = {{1, 2}, {3, 4}};
int *ptr = (int *)arr; // Treating the 2D array as a 1D array

printf("%d\n", *(ptr + 3)); // Accessing element arr[1][1]

38. Types of User-Defined Functions in C

In C, user-defined functions can be classified based on whether they take

arguments and return values. Below are the types of functions:
1. Functions with No Arguments and No Return Value: These functions do
not take any parameters and do not return any value. They are declared
with void for both the return type and parameters.
Example:
c
Copy code
#include <stdio.h>

void greet() {
 printf("Hello, World!\n");
}

int main() {
greet(); // Calling the function
return 0;
}
2. Functions with Arguments and No Return Value: These functions accept
parameters but do not return any value. The return type is void.
Example:
c
Copy code
#include <stdio.h>

void printSum(int a, int b) {

printf("Sum: %d\n", a + b);
}

int main() {
printSum(5, 3); // Calling the function with arguments
return 0;
}
3. Functions with No Arguments but with Return Value: These functions
do not take any parameters but return a value.
Example:
c
Copy code
#include <stdio.h>

int getFive() {
return 5;
}

int main() {
int result = getFive(); // Calling the function
printf("Returned value: %d\n", result);
return 0;
}
4. Functions with Arguments and Return Value: These functions take
arguments and return a value.
Example:
c
Copy code
#include <stdio.h>

int multiply(int a, int b) {

return a * b;
}

int main() {
int result = multiply(5, 3); // Calling the function with arguments
printf("Product: %d\n", result);
return 0;
}
39. Difference Between an Array and a Structure in C

 Array: A collection of variables of the same type, stored in contiguous

memory locations. Example:
c
Copy code
int arr[5] = {1, 2, 3, 4, 5};
 Structure: A collection of variables of different data types, grouped
together under one name. It allows storing different types of data in one
entity. Example:
c
Copy code
struct Employee {
int id;
char name[50];
};
When to Use:
 Use arrays when you need to store elements of the same type.
 Use structures when you need to group different types of data that
logically belong together.

40. Program to Declare and Initialize an Array of Structures in C

Example of declaring and initializing an array of structures:
c
Copy code
#include <stdio.h>
struct Employee {
int id;
char name[50];
};

int main() {
// Initializing an array of structures
struct Employee emp[2] = {{1, "Alice"}, {2, "Bob"}};

// Accessing elements of the array of structures

printf("Employee 1: ID = %d, Name = %s\n", emp[0].id, emp[0].name);
printf("Employee 2: ID = %d, Name = %s\n", emp[1].id, emp[1].name);

return 0;
}

41. Pointers with an Array of Structures

You can use pointers to access and modify the data in an array of structures.
Example:
c
Copy code
#include <stdio.h>

struct Employee {
int id;
char name[50];
};

int main() {
struct Employee emp[2] = {{1, "Alice"}, {2, "Bob"}};

// Pointer to the array of structures

struct Employee *ptr = emp;

// Accessing elements using the pointer

printf("Employee 1: ID = %d, Name = %s\n", ptr->id, ptr->name);
ptr++; // Moving to the next element
printf("Employee 2: ID = %d, Name = %s\n", ptr->id, ptr->name);

return 0;
}

42. Components of a Computer System: Memory, Processor, I/O Devices, and

Storage
1. Memory:
o Primary Memory (RAM): Volatile storage used by the CPU to store
and quickly access data and instructions that are currently being
executed.
o Secondary Memory: Non-volatile storage used for long-term
storage of data (e.g., hard drives, SSDs).
2. Processor (CPU):
o The CPU is the brain of the computer, responsible for executing
instructions, performing calculations, and managing data flow. It
interacts with memory to fetch instructions and data and performs
operations on them.
 3. I/O Devices:
o These are the peripherals that allow interaction with the
computer, such as keyboards, mice, monitors, printers, and more.
4. Storage:
o Primary Storage (RAM): Temporary storage for active data and
programs.
o Secondary Storage: Used for persistent data storage (e.g., hard
drives, SSDs, USB drives).
Interaction:
 The CPU communicates with memory to fetch and execute instructions.
 I/O devices provide input to the system and receive output from the
system, allowing user interaction.
 Storage devices store data and programs for later use, and the CPU can
load data into primary memory when needed.