IGNOU BCA SOLVED ASSIGNMENTS

C Program: Multiply Two 4×4 Matrices

#include <stdio.h>

int main() {

int A[4][4], B[4][4], C[4][4];

int i, j, k;

// Input for first matrix A

printf("Enter elements of first 4x4 matrix (A):\n");

for(i = 0; i < 4; i++) {

for(j = 0; j < 4; j++) {

scanf("%d", &A[i][j]);

}

// Input for second matrix B

printf("Enter elements of second 4x4 matrix (B):\n");

for(i = 0; i < 4; i++) {

for(j = 0; j < 4; j++) {

scanf("%d", &B[i][j]);

}

// Multiply matrices A and B, store in C

for(i = 0; i < 4; i++) {

for(j = 0; j < 4; j++) {

C[i][j] = 0;

for(k = 0; k < 4; k++) {

C[i][j] += A[i][k] * B[k][j];

}

// Display the result matrix C

printf("Result of multiplication (A x B) is:\n");

for(i = 0; i < 4; i++) {

for(j = 0; j < 4; j++) {

printf("%d\t", C[i][j]);

}

printf("\n");

}

return 0;

}

Two Categories of Constants in C

Primary Constants

These are the basic constants we use directly in a C program.

Types of Primary Constants:

Integer Constant → Example: 5, -10, 100
Float Constant → Example: 3.14, -2.5
Character Constant → Example: 'A', 'z', '9'
String Constant → Example: "Hello", "C programming"

Used for storing direct values in variables like:

c
int a = 10;     // 10 is an integer constant

char ch = 'A'; // 'A' is a character constant

Secondary Constants

These are user-defined or derived constants.

Types of Secondary Constants:

Symbolic Constants → Created using #defineExample: #define PI 3.14
Enumerations (enum) → Set of named integer constants
Example:
```
c
enum day { SUN, MON, TUE };
```

In Simple Words:

Category	What it is	Example
Primary	Basic constant values	`10`, `'A'`, `"C"`
Secondary	Defined by the user/programmer	`#define`, `enum`

C Program to Find Sum of the Series (1 + 4 + 7 + ... up to 20 terms)

#include <stdio.h>

int main() {

int n = 20;
int Sum = 0;
int Term 1;
for(i = 1; i <= 20; i++) {
sum += term;

term += 3; // Next term (add common difference)

}

// Print the result

printf("Sum of the series up to 20 terms is: %d\n", sum);

return 0;

}

C Program to Find the Length of a String Using Pointers

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

int main() {
char str [] = "Hello World";
int length;
length = strlen (str);

printf("Length of the string is: %d\n", length);

return 0;

}

#include <stdio.h>

int main() {

int numbers[10];

int i, search, found = 0;

// Taking 10 numbers from user

printf("Enter 10 numbers:\n");

for(i = 0; i < 10; i++) {

scanf("%d", &numbers[i]);

}

// Number to search

printf("Enter a number to search: ");

scanf("%d", &search);

// Search the number in array

for(i = 0; i < 10; i++) {

if(numbers[i] == search) {

found = 1;

break;

}

// Print result

if(found) {

printf("Square of %d is %d\n", search, search * search);

} else {

printf("The value is missing.\n");

}

return 0;

}

Store and Display Student Details Using Structure

#include <stdio.h>

// Create structure for student

struct Student {

char name[50];

int roll;

char address[100];

char course[10];

};

int main() {

struct Student s[10];

int i;

// Get student details

for(i = 0; i < 10; i++) {

printf("\nEnter details of student %d:\n", i + 1);

printf("Name: ");

scanf(" %[^\n]", s[i].name);

printf("Roll Number: ");

scanf("%d", &s[i].roll);

printf("Address: ");

scanf(" %[^\n]", s[i].address);

printf("Course (BCA/MCA): ");

scanf(" %[^\n]", s[i].course);

}

// Show student details

printf("\n--- Student Details ---\n");

for(i = 0; i < 10; i++) {

printf("\nStudent %d\n", i + 1);

printf("Name : %s\n", s[i].name);

printf("Roll : %d\n", s[i].roll);

printf("Address: %s\n", s[i].address);

printf("Course : %s\n", s[i].course);

}

return 0;

}

Algorithm to Calculate Simple Interest

Algorithm Steps

Start
Read Principal Amount, Time, and Rate
Calculate interest using the formula ((P*T*R)/100)
Print Simple Interest
Stop
Flowchart:

Start
↓
Input P, T, R
↓
Calculate SI = (P × T × R) / 100
↓
Display SI
↓
Stop

Certainly! Here's an example of an 8086 assembly language program that compares the values of AL and BL registers. If AL is greater than BL, it clears the BL register; otherwise, it clears the AL register.

```assembly

section .data

value_al db 0CAh ; '11001010' in binary

value_bl db 0C8h ; '11001000' in binary

section .text

global _start

_start:

mov al, [value_al] ; Load the value into AL register

mov bl, [value_bl] ; Load the value into BL register

cmp al, bl ; Compare AL and BL

jle clear_al ; Jump to clear_al if AL <= BL

mov bl, 0 ; Clear BL register

jmp exit_program ; Jump to exit_program

clear_al:

mov al, 0 ; Clear AL register

exit_program:

; Add any additional code here if needed

; Exit the program

mov eax, 1 ; System call number for sys_exit

xor ebx, ebx ; Exit code 0

int 0x80 ; Call kernel

```

This program loads the values '11001010' and '11001000' into AL and BL registers, respectively. It then compares AL and BL and clears the appropriate register based on the result of the comparison. Replace the values in `value_al` and `value_bl` with your desired values. Compile and run the program using an assembler and linker, as explained in the previous response.

Certainly! Below is an example of an 8086 assembly language program that finds the highest of four byte values stored in memory and leaves the highest value in the AL register:

```assembly

section .data

values db 45h, 32h, 7Eh, 21h ; Replace these values as needed

section .text

global _start

_start:

mov al, [values] ; Load the first byte into AL

mov bl, [values+1] ; Load the second byte into BL

cmp al, bl ; Compare the first and second bytes

jge check_next ; Jump to check_next if AL >= BL

mov al, bl ; Move the value of BL to AL if BL > AL

check_next:

mov bl, [values+2] ; Load the third byte into BL

cmp al, bl ; Compare the current highest value (AL) with the third byte

jge check_last ; Jump to check_last if AL >= BL

mov al, bl ; Move the value of BL to AL if BL > AL

check_last:

mov bl, [values+3] ; Load the fourth byte into BL

cmp al, bl ; Compare the current highest value (AL) with the fourth byte

jge exit_program ; Jump to exit_program if AL >= BL

mov al, bl ; Move the value of BL to AL if BL > AL

exit_program:

; Add any additional code here if needed

; Exit the program

mov eax, 1 ; System call number for sys_exit

xor ebx, ebx ; Exit code 0

int 0x80 ; Call kernel

```

This program uses a series of comparisons to find the highest value among the four bytes in the `values` array. Replace the values in the `values` array with your desired byte values. Compile and run the program using an assembler and linker, as explained in the previous response.

Certainly! Below is a simple 8086 assembly language program that increments a byte value stored in a memory location by 2. The result is stored back in the same memory location:

```assembly

section .data

value db 51h ; Initial byte value, change as needed

section .text

global _start

_start:

mov al, [value] ; Load the byte value into AL register

add al, 2 ; Increment AL by 2

mov [value], al ; Store the result back in the memory location

; Add any additional code here if needed

; Exit the program

mov eax, 1 ; System call number for sys_exit

xor ebx, ebx ; Exit code 0

int 0x80 ; Call kernel

```

This program uses Linux system calls for simplicity (`int 0x80`). If you are running it on a modern 64-bit system, you might need to adjust it accordingly.

Compile and run the program using an assembler and linker. For example, using NASM and LD:

```bash

nasm -f elf32 your_program.asm -o your_program.o

ld -m elf_i386 -s -o your_program your_program.o

./your_program

```

Make sure to replace `your_program.asm` with the actual filename you save the program in. The program increments the initial byte value (`51h`) by 2, and the final value is stored back in the same memory location.

It seems like the details of the tasks you want to perform using 8086 assembly language are missing. Could you please provide more specific information or describe the tasks you'd like assistance with? Once you provide more details, I'll be happy to help you with the assembly language programming.

To design a two-bit counter circuit that counts from 00 to 10 and ignores the state 11 using J-K flip-flops, you can follow these steps:

State Transition Diagram:

```

+-------+ J0 +-------+

| |-------->| |

| 00 | K0 | 01 |

| |<--------| |

+-------+ +-------+

^ | J1 +-------+

| +---------| |

+-----------| 10 |

| K1 | |

+-----------+-------+

```

Karnaugh Maps for J and K Inputs:

For J0 and K0:

```

K0J0

----

00 | 0 0

01 | 1 0

10 | 0 1

11 | - -

```

For J1 and K1:

```

K1J1

----

00 | 1 0

01 | 0 0

10 | 0 1

11 | - -

```

Boolean Expressions:

```

J0 = Q0'

K0 = Q0

J1 = Q0Q1'

K1 = Q0'Q1

```

Circuit Implementation:

You can implement this circuit using J-K flip-flops. Let's denote the flip-flop outputs as Q0 and Q1.

```plaintext

+---+ +---+

--|J0K0|----|J1K1|---

+---+ +---+

| |

| +-----|-----+

| | |

| | +--|-----+ +-----+

| | | | |---| |

| | +--|-----+ | 10 |

| | | | |

| +-----|---------| |

| | +-----+

+--------|-----------+

Q0Q1

```

This circuit uses two J-K flip-flops (J0K0 and J1K1) to implement the state transition diagram. The clock input is assumed to be a common clock signal shared by both flip-flops. The state changes according to the defined J and K inputs based on the current state.

Certainly! Below is a simple example of an interactive C program that provides a menu with the specified options. This program uses a switch-case structure to handle the user's choice.

```c

#include <stdio.h>

void displayGeneralInformation();

void displayProgrammes();

void displayScheduling();

void displayCouncillorDetails();

void displayAssignmentSchedules();

int main() {

int choice;

do {

// Display menu

printf("\nMain Menu\n");

printf("1. General Information of the Learner Support Centre(LSC)\n");

printf("2. Programmes activated in the study centre\n");

printf("3. Scheduling of theory/practical sessions for BCA-MCA programmes\n");

printf("4. Academic Councillor’s Details\n");

printf("5. Schedules for Assignment submissions for various programmes\n");

printf("6. Quit\n");

// User prompt

printf("\nEnter your choice (1-6): ");

scanf("%d", &choice);

// Process user choice

switch (choice) {

case 1:

displayGeneralInformation();

break;

case 2:

displayProgrammes();

break;

case 3:

displayScheduling();

break;

case 4:

displayCouncillorDetails();

break;

case 5:

displayAssignmentSchedules();

break;

case 6:

printf("Quitting the program. Goodbye!\n");

break;

default:

printf("Invalid choice. Please enter a number between 1 and 6.\n");

}

} while (choice != 6);

return 0;

}

void displayGeneralInformation() {

printf("Displaying General Information of the Learner Support Centre(LSC)...\n");