Assignment 1: To implement scheduling algorithms like FCFS, RR,

SJF
#include <stdio.h>
#include <stdlib.h>
struct Process {
int id; // Process ID
int arrivalTime; // Arrival time
int burstTime; // Burst time
};
void FCFS(struct Process processes[], int n) {
int waitingTime = 0, turnaroundTime = 0;
printf("\nFCFS Scheduling\n");

printf("---------------------------------------------
------\n");
printf("Process\t| Arrival Time\t| Burst Time\t|
Waiting Time\t| Turnaround Time\n");

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

for (int i = 0; i < n; i++) {

// Calculate waiting time and turnaround time
for each process
turnaroundTime = turnaroundTime +
processes[i].burstTime;
printf("P%d\t|\t%d\t|\t%d\t|\t%d\t|\t%d\n",
processes[i].id, processes[i].arrivalTime,
processes[i].burstTime, waitingTime,
turnaroundTime);
waitingTime = turnaroundTime;

[1]
 }
}
void RR(struct Process processes[], int n, int
timeQuantum) {
int remainingTime[n];
int waitingTime = 0, turnaroundTime = 0;
for (int i = 0; i < n; i++) {
remainingTime[i] = processes[i].burstTime;
}

printf("\nRound Robin Scheduling (Time Quantum:

%d)\n", timeQuantum);

printf("---------------------------------------------
------\n");
printf("Process\t| Arrival Time\t| Burst Time\t|
Waiting Time\t| Turnaround Time\n");

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

int time = 0; // Current time

int flag; // Flag to check if any process is
remaining
do {
flag = 0;
for (int i = 0; i < n; i++) {
if (remainingTime[i] > 0) {
flag = 1;
int executeTime = (remainingTime[i] <
timeQuantum) ? remainingTime[i] : timeQuantum;

[2]
 remainingTime[i] -= executeTime;
waitingTime += time -
processes[i].arrivalTime;
turnaroundTime += time -
processes[i].arrivalTime + executeTime;

printf("P%d\t|\t%d\t|\t%d\t|\t%d\t|\t
%d\n", processes[i].id, processes[i].arrivalTime,
executeTime, waitingTime,
turnaroundTime);
time += executeTime;
}
}
} while (flag);
}
void SJF(struct Process processes[], int n) {
int remainingTime[n];
int waitingTime = 0, turnaroundTime = 0;
for (int i = 0; i < n; i++) {
remainingTime[i] = processes[i].burstTime;
}

printf("\nShortest Job First (SJF) Scheduling\

n");

printf("---------------------------------------------
------\n");
printf("Process\t| Arrival Time\t| Burst Time\t|
Waiting Time\t| Turnaround Time\n");

[3]
printf("---------------------------------------------
------\n");

int time = 0; // Current time

for (int i = 0; i < n; i++) {
int shortest = i; // Assume the current
process has the shortest burst time
for (int j = i + 1; j < n; j++) {
if (processes[j].burstTime <
processes[shortest].burstTime &&
processes[j].arrivalTime <= time) {
shortest = j;
}
}
// Swap processes[i] and processes[shortest]
struct Process temp = processes[i];
processes[i] = processes[shortest];
processes[shortest] = temp;
int executeTime = processes[i].burstTime;
waitingTime += time -
processes[i].arrivalTime;
turnaroundTime += time -
processes[i].arrivalTime + executeTime;
printf("P%d\t|\t%d\t|\t%d\t|\t%d\t|\t%d\n",
processes[i].id, processes[i].arrivalTime,
executeTime, waitingTime,
turnaroundTime);
time += executeTime;
}
}
[4]
int main() {
int n, timeQuantum;
printf("Enter the number of processes: ");
scanf("%d", &n);
struct Process processes[n];
for (int i = 0; i < n; i++) {
processes[i].id = i + 1;
printf("Enter arrival time for process P%d:
", i + 1);
scanf("%d", &processes[i].arrivalTime);
printf("Enter burst time for process P%d: ",
i + 1);
scanf("%d", &processes[i].burstTime);
}
printf("Enter time quantum for Round Robin
scheduling: ");
scanf("%d", &timeQuantum);
FCFS(processes, n);
RR(processes, n, timeQuantum);
SJF(processes, n);

return 0;
}

Output:
Enter the number of processes: Enter time quantum for Round Robin
scheduling:
FCFS Scheduling

[5]
---------------------------------------------------
Process | Arrival Time | Burst Time | Waiting Time |
Turnaround Time
---------------------------------------------------

Round Robin Scheduling (Time Quantum: 0)

---------------------------------------------------
Process | Arrival Time | Burst Time | Waiting Time |
Turnaround Time
---------------------------------------------------

Shortest Job First (SJF) Scheduling

---------------------------------------------------
Process | Arrival Time | Burst Time | Waiting Time |
Turnaround Time
---------------------------------------------------

2: To implement the banker's algorithm

#include <stdio.h>

#define MAX_PROCESSES 5
#define MAX_RESOURCES 3

int available[MAX_RESOURCES];
int maximum[MAX_PROCESSES][MAX_RESOURCES];
int allocation[MAX_PROCESSES][MAX_RESOURCES];
int need[MAX_PROCESSES][MAX_RESOURCES];

[6]
int isSafe(int process, int request[]) {
for (int i = 0; i < MAX_RESOURCES; i++) {
if (request[i] > need[process][i] ||
request[i] > available[i]) {
return 0;
}
}
for (int i = 0; i < MAX_RESOURCES; i++) {
available[i] -= request[i];
allocation[process][i] += request[i];
need[process][i] -= request[i];
}

int work[MAX_RESOURCES];
for (int i = 0; i < MAX_RESOURCES; i++) {
work[i] = available[i];
}

int finish[MAX_PROCESSES] = {0}; // Array to

track finished processes
int safeSequence[MAX_PROCESSES];
int count = 0;

while (count < MAX_PROCESSES) {

int found = 0;
for (int i = 0; i < MAX_PROCESSES; i++) {
if (finish[i] == 0) {

[7]
 int j;
for (j = 0; j < MAX_RESOURCES; j++) {
if (need[i][j] > work[j]) {
break;
}
}
if (j == MAX_RESOURCES) {
for (int k = 0; k <
MAX_RESOURCES; k++) {
work[k] += allocation[i][k];
}
safeSequence[count++] = i;
finish[i] = 1;
found = 1;
}
}
}
if (found == 0) {
// No safe sequence found
return 0;
}
}
for (int i = 0; i < MAX_RESOURCES; i++) {
available[i] += request[i];
allocation[process][i] -= request[i];
need[process][i] += request[i];
}
return 1; // Request can be granted

[8]
}
void displayState() {
printf("Available resources: ");
for (int i = 0; i < MAX_RESOURCES; i++) {
printf("%d ", available[i]);
}
printf("\n");
printf("Maximum resources:\n");
for (int i = 0; i < MAX_PROCESSES; i++) {
for (int j = 0; j < MAX_RESOURCES; j++) {
printf("%d ", maximum[i][j]);
}
printf("\n");
}
printf("Allocated resources:\n");
for (int i = 0; i < MAX_PROCESSES; i++) {
for (int j = 0; j < MAX_RESOURCES; j++) {
printf("%d ", allocation[i][j]);
}
printf("\n");
}
printf("Remaining needs:\n");
for (int i = 0; i < MAX_PROCESSES; i++) {
for (int j = 0; j < MAX_RESOURCES; j++) {
printf("%d ", need[i][j]);
}
printf("\n");
}
[9]
}
int main() {
// Initialize available resources
printf("Enter the available resources for each
resource type:\n");
for (int i = 0; i < MAX_RESOURCES; i++) {
scanf("%d", &available[i]);
}
printf("Enter the maximum resources required for
each process and resource type:\n");
for (int i = 0; i < MAX_PROCESSES; i++) {
for (int j = 0; j < MAX_RESOURCES; j++) {
scanf("%d", &maximum[i][j]);
need[i][j] = maximum[i][j];
}
}
printf("Enter the allocated resources for each
process and resource type:\n");
for (int i = 0; i < MAX_PROCESSES; i++) {
for (int j = 0; j < MAX_RESOURCES; j++) {
scanf("%d", &allocation[i][j]);
need[i][j] -= allocation[i][j];
}
}
int process;
printf("Enter the process number (0 to %d)
requesting resources: ", MAX_PROCESSES - 1);
scanf("%d", &process);

[10]
 int request[MAX_RESOURCES];
printf("Enter the requested resources for each
resource type:\n");
for (int i = 0; i < MAX_RESOURCES; i++) {
scanf("%d", &request[i]);
}
if (isSafe(process, request)) {
printf("Request can be granted. System is in
a safe state.\n");
printf("Safe sequence: ");
for (int i = 0; i < MAX_PROCESSES; i++) {
printf("%d ", i);
}
printf("\n");
displayState();
} else {
printf("Request cannot be granted. System is
not in a safe state.\n");
}
return 0;
}

Output:

[11]
Assignment 3: To drop a table, alter the schema of a table, and
insert/update/delete records using tables created in previous
Assignments. (Use simple forms of insert/update/delete
statements)

1. Drop a Table:
-- Drop the EmployeeTable if it exists
IF OBJECT_ID('EmployeeTable', 'U') IS NOT NULL
DROP TABLE EmployeeTable;

2. Alter the Schema of a Table:

-- Add a new column to the EmployeeTable
ALTER TABLE EmployeeTable
ADD Email NVARCHAR(255);

3. Insert Records:
-- Insert a new record into the EmployeeTable
INSERT INTO EmployeeTable (EmployeeID, EmployeeName,
Salary, Department)
VALUES (4, 'Alice Johnson', 70000, 'Marketing');

[12]
4. Update Records:
-- Update the salary for a specific employee in the
EmployeeTable
UPDATE EmployeeTable
SET Salary = 75000
WHERE EmployeeID = 1;

5. Delete Records:
-- Delete a record from the EmployeeTable
DELETE FROM EmployeeTable
WHERE EmployeeID = 2;

Output:

[13]
Assignment 4: To create simple tables with only the primary key
constraint (as a table-level constraint & and as a field level
constraint) (include all data types),
CREATE TABLE TableWithTableLevelPK (
ID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
Age INT
);
CREATE TABLE TableWithFieldLevelPK (
ID INT,
FirstName VARCHAR(50),
LastName VARCHAR(50),
Age INT,
PRIMARY KEY (ID)
);
INSERT INTO TableWithTableLevelPK (ID, FirstName,
LastName, Age) VALUES
(1, 'John', 'Doe', 25),
(2, 'Jane', 'Smith', 30);

[14]
INSERT INTO TableWithFieldLevelPK (ID, FirstName,
LastName, Age) VALUES
(101, 'Alice', 'Johnson', 28),
(102, 'Bob', 'Williams', 35);

Output:

[15]
Assignment 5: To create more than one table, with referential
integrity constraint, PK constrain, Check constraint, Unique
constraint, not null constraint

CREATE TABLE Authors (

AuthorID INT PRIMARY KEY,
AuthorName VARCHAR(50) NOT NULL,
BirthDate DATE,
UNIQUE (AuthorName), -- Unique constraint on
AuthorName
CONSTRAINT CHK_Authors_BirthDate CHECK (BirthDate
<= CURRENT_DATE())
);
CREATE TABLE Books (
BookID INT PRIMARY KEY,
Title VARCHAR(100) NOT NULL,
ISBN VARCHAR(13) UNIQUE,
PublishedYear INT CHECK (PublishedYear >= 0),
AuthorID INT,
CONSTRAINT FK_Books_Authors FOREIGN KEY
(AuthorID) REFERENCES Authors(AuthorID),
CONSTRAINT CHK_Books_PublishedYear CHECK
(PublishedYear <= YEAR(CURRENT_DATE())),

[16]
 CONSTRAINT CHK_Books_Title_Length CHECK
(LENGTH(Title) <= 100)
);
INSERT INTO Authors (AuthorID, AuthorName, BirthDate)
VALUES
(1, 'John Doe', '1980-01-01'),
(2, 'Jane Smith', '1990-05-15');

INSERT INTO Books (BookID, Title, ISBN,

PublishedYear, AuthorID) VALUES
(101, 'Introduction to SQL', '1234567890123',
2020, 1),
(102, 'Database Design Basics', '9876543210987',
2018, 2);

Output:

[17]