added gitignore

.gitignore

@@ -0,0 +1,65 @@
+### MacOS System Files ###
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+.AppleDouble
+.LSOverride
+Icon
+.DocumentRevisions-V100
+.fseventsd
+.TemporaryItems
+.VolumeIcon.icns
+
+### Obsidian ###
+.obsidian/
+
+### IDEs and Editors ###
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+### Node ###
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+### Python ###
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+### Java ###
+*.class
+*.log
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar

DBMS/SQL/Week7/writeup.md

@@ -1 +1,176 @@
-## Week 7 - DBMS Lab - PL SQL & Triggers
+## Week 7 - DBMS Lab - PL SQL & Triggers
+
+### Q1. Generate a trigger displaying driver information, on participating in an accident.
+
+Trigger:
+```sql
+CREATE OR REPLACE TRIGGER trg_display_driver_info
+AFTER INSERT ON participated
+FOR EACH ROW
+DECLARE
+    v_driver_name VARCHAR2(100);
+    v_driver_address VARCHAR2(255);
+BEGIN
+    SELECT NAME, ADDRESS
+    INTO v_driver_name, v_driver_address
+    FROM person
+    WHERE DRIVER_ID# = :NEW.DRIVER_ID#;
+
+    DBMS_OUTPUT.PUT_LINE('Driver ID: ' || :NEW.DRIVER_ID#);
+    DBMS_OUTPUT.PUT_LINE('Driver Name: ' || v_driver_name);
+    DBMS_OUTPUT.PUT_LINE('Driver Address: ' || v_driver_address);
+    DBMS_OUTPUT.PUT_LINE('Car Registration Number: ' || :NEW.REGNO);
+    DBMS_OUTPUT.PUT_LINE('Report Number: ' || :NEW.REPORT_NUMBER);
+    DBMS_OUTPUT.PUT_LINE('Damage Amount: ' || :NEW.DAMAGE_AMOUNT);
+END;
+/
+```
+
+Demo:
+```sql
+SQL> INSERT INTO participated (DRIVER_ID#, REGNO, REPORT_NUMBER, DAMAGE_AMOUNT)
+  2  VALUES (1235, 'EFGH2001', 3, 5000);
+Driver ID: 1235
+Driver Name: Rohit
+Driver Address: Banglalore India
+Car Registration Number: EFGH2001
+Report Number: 3
+Damage Amount: 5000
+Driver_id: 1235 Name: Rohit Address: Banglalore India
+
+1 row created.
+```
+
+### Q2. Create a trigger that updates a `total_damage` column in the `accident` table whenever a new entry is added to or removed from the participated field.`
+Trigger:
+```SQL
+SQL> CREATE OR REPLACE TRIGGER update_total_damage
+  2  AFTER
+  3    INSERT OR DELETE ON PARTICIPATED
+  4  BEGIN
+  5    UPDATE ACCIDENT
+  6    SET
+  7      total_damage = (
+  8        SELECT
+  9          SUM(damage_amount)
+ 10        FROM PARTICIPATED p
+ 11        WHERE
+ 12          p.report_number = ACCIDENT.report_number
+ 13      );
+ 14  END;
+ 15  /
+
+Trigger created.
+```
+Adding an identifier `total_damage`:
+```sql
+SQL> ALTER TABLE ACCIDENT ADD total_damage NUMBER;
+```
+Test case with Insertion:
+```sql
+SQL> INSERT INTO
+        PARTICIPATED (driver_id#, regno, report_number, damage_amount)
+      VALUES
+        ('1235', 'EFGH2001', 1, 5000);
+Driver_id: 1235 Name: Rohit Address: Banglalore India
+
+1 row created.
+
+SQL> SELECT
+        report_number,
+        total_damage
+      FROM ACCIDENT
+      WHERE
+        report_number = 1;
+
+REPORT_NUMBER TOTAL_DAMAGE
+------------- ------------
+            1        15000
+```
+Test case with Deletion:
+```sql
+SQL> DELETE FROM PARTICIPATED
+      WHERE
+        driver_id# = '1235'
+        AND regno = 'EFGH2001'
+        AND report_number = 1;
+
+1 row deleted.
+
+SQL> SELECT
+        report_number,
+        total_damage
+      FROM ACCIDENT
+      WHERE
+        report_number = 1;
+
+REPORT_NUMBER TOTAL_DAMAGE
+------------- ------------
+            1        10000
+```
+
+
+### Q3. List cars involved in accidents with cumulative damage exceeding a specific amount.
+
+Checking for damage amount > 10000, we have
+```SQL
+SQL> SELECT
+          p.driver_id#,
+          o.regno,
+          SUM(pa.damage_amount) AS total_damage
+      FROM
+          PARTICIPATED pa
+      JOIN
+          OWNS o ON pa.driver_id# = o.driver_id#
+      JOIN
+          PERSON p ON o.driver_id# = p.driver_id#
+      GROUP BY
+          p.driver_id#, o.regno
+      HAVING
+          SUM(pa.damage_amount) > 10000;
+
+DRIVER_ID#                     REGNO                TOTAL_DAMAGE
+------------------------------ -------------------- ------------
+1238                           HFSP5601                    26500
+```
+
+### Q4. Identify cars that have been involved in more than one accident and calculate the total damage for each car.
+
+```SQL
+SQL> SELECT 
+    o.regno, 
+    COUNT(DISTINCT pa.report_number) AS accident_count, 
+    SUM(pa.damage_amount) AS total_damage
+FROM 
+    PARTICIPATED pa
+JOIN 
+    OWNS o ON pa.driver_id# = o.driver_id#
+GROUP BY 
+    o.regno
+HAVING 
+    COUNT(DISTINCT pa.report_number) > 1;
+
+REGNO                ACCIDENT_COUNT TOTAL_DAMAGE
+-------------------- -------------- ------------
+HFSP5601                          2        26500
+```
+
+### Q5. Calculate the average damage amount for accidents at each location.
+```sql
+SQL> SELECT
+          a.location,
+          AVG(pa.damage_amount) AS average_damage
+      FROM
+          ACCIDENT a
+      JOIN
+          PARTICIPATED pa ON a.report_number = pa.report_number
+      GROUP BY
+          a.location;
+
+LOCATION                                           AVERAGE_DAMAGE
+-------------------------------------------------- --------------
+ karnataka India                                            25000
+Delhi India                                                 10000
+ India                                                       2575
+ Gujrat India                                                1500
+ ```

OS/C/Week6/menudriven.c

@@ -4,90 +4,87 @@
 
 # define MAX 4
 
- typedef struct {
-  char pid[5]; // Process ID (string)
-  int at; // Arrival Time
-  int bt; // Burst Time
-  int priority; // Priority (lower value = higher priority)
-  int ct; // Completion Time
-  int tat; // Turnaround Time
-  int wt; // Waiting Time
-  int rt; // Response Time
-  int remaining_bt; // Remaining Burst Time (for preemptive sjf)
-  int is_completed; // completion flag
- } Process;
+	typedef struct {
+		char pid[5]; // Process ID (string)
+		int at; // Arrival Time
+		int bt; // Burst Time
+		int priority; // Priority (lower value = higher priority)
+		int ct; // Completion Time
+		int tat; // Turnaround Time
+		int wt; // Waiting Time
+		int rt; // Response Time
+		int remaining_bt; // Remaining Burst Time (for preemptive sjf)
+		int is_completed; // completion flag
+	} Process;
 
- void swap(Process *a, Process *b) {
-  Process temp = *a;
-  *a = *b;
-  *b = temp;
- }
+	void swap(Process *a, Process *b) {
+		Process temp = *a;
+		*a = *b;
+		*b = temp;
+	}
 
- // Function to calculate Completion Time, Turnaround Time, and Waiting Time
- void calculate_times(Process processes[], int n) {
-  for (int i = 0; i < n; i++) {
-  processes[i].tat = processes[i].ct - processes[i].at;
-  processes[i].wt = processes[i].tat - processes[i].bt;
-  }
- }
+	// Function to calculate Completion Time, Turnaround Time, and Waiting Time
+	void calculate_times(Process processes[], int n) {
+		for (int i = 0; i < n; i++) {
+		processes[i].tat = processes[i].ct - processes[i].at;
+		processes[i].wt = processes[i].tat - processes[i].bt;
+		}
+	}
 
- // Function to calculate average times
- void calculate_averages(Process processes[], int n, float *avg_ct,
-  float *avg_tat, float *avg_wt, float *avg_rt) {
-  *avg_ct = 0;
-  *avg_tat = 0;
-  *avg_wt = 0;
-  *avg_rt = 0;
+	// Function to calculate average times
+	void calculate_averages(Process processes[], int n, float *avg_ct,
+		float *avg_tat, float *avg_wt, float *avg_rt) {
+		*avg_ct = 0;
+		*avg_tat = 0;
+		*avg_wt = 0;
+		*avg_rt = 0;
 
-  for (int i = 0; i < n; i++) {
-  *avg_ct += processes[i].ct;
-  *avg_tat += processes[i].tat;
-  *avg_wt += processes[i].wt;
-  *avg_rt += processes[i].rt;
-  }
+		for (int i = 0; i < n; i++) {
+		*avg_ct += processes[i].ct;
+		*avg_tat += processes[i].tat;
+		*avg_wt += processes[i].wt;
+		*avg_rt += processes[i].rt;
+		}
 
-  *avg_ct /= n;
-  *avg_tat /= n;
-  *avg_wt /= n;
-  *avg_rt /= n;
- }
+		*avg_ct /= n;
+		*avg_tat /= n;
+		*avg_wt /= n;
+		*avg_rt /= n;
+	}
 
- // Function to display the Gantt chart
- void display_gantt_chart(Process processes[], int n, int timeline[]) {
-  	printf("\nGantt Chart:\n");
-  	printf("-----------------------------------------------------------\n");
-  	for (int i = 0; i <= timeline[n - 1]; i++) {
-  		printf("%-3d", i);
-  	}
+	// Function to display the Gantt chart
+	void display_gantt_chart(Process processes[], int n, int timeline[], int timeline_index) {
+		printf("\nGantt Chart:\n");
+		printf("-----------------------------------------------------------\n");
+		int last_process = -1;
+		for(int i = 0; i < timeline_index; i++) {
+			if(timeline[i] != last_process) {
+				printf("%s ", processes[timeline[i]].pid);
+				last_process = timeline[i];
+			}
+		}
+		printf("\n-----------------------------------------------------------\n");
+	}
 
-	printf("\n-----------------------------------------------------------\n");
+	// Function to display the process table
+	void display_table(Process processes[], int n) {
+		printf("--------------------------------------------------------------------"
+		"------\n");
+		printf("| PID   | AT  | BT  | CT  | TAT | WT  | RT  |\n");
+		printf("--------------------------------------------------------------------"
+		"------\n");
+		for (int i = 0; i < n; i++) {
+		printf("| %-5s | %-3d | %-3d | %-3d | %-3d | %-3d | %-3d |\n",
+		processes[i].pid, processes[i].at, processes[i].bt,
+		processes[i].ct, processes[i].tat, processes[i].wt,
+		processes[i].rt);
+		}
+		printf("--------------------------------------------------------------------"
+		"------\n");
+	}
 
-	for (int i = 0; i < n; i++) {
-  		printf("%-3s", processes[i].pid);
-  	}
-
-	printf("\n-----------------------------------------------------------\n");
- }
-
- // Function to display the process table
- void display_table(Process processes[], int n) {
-  printf("--------------------------------------------------------------------"
-  "------\n");
-  printf("| PID   | AT  | BT  | CT  | TAT | WT  | RT  |\n");
-  printf("--------------------------------------------------------------------"
-  "------\n");
-  for (int i = 0; i < n; i++) {
-  printf("| %-5s | %-3d | %-3d | %-3d | %-3d | %-3d | %-3d |\n",
-  processes[i].pid, processes[i].at, processes[i].bt,
-  processes[i].ct, processes[i].tat, processes[i].wt,
-  processes[i].rt);
-  }
-  printf("--------------------------------------------------------------------"
-  "------\n");
- }
-
- // Preemptive SJF
- void preemptive_sjf(Process processes[], int n){
+	// Preemptive SJF
+	void preemptive_sjf(Process processes[], int n){
 
 	// process sort by AT
 	for (int i = 0; i < n -1; i++){
@@ -110,13 +107,14 @@
 	int completed = 0;
 	int shortest = -1;
 
-	int *timeline = (int *)malloc((n*2)*sizeof(int));
+	int *timeline = (int *)malloc((n*100)*sizeof(int));
 	if (timeline == NULL) {
 		perror ("MemAlloc Error");
 		return;
 	}
 
 	int timeline_index = 0;
+	int last_process = -1;
 
 	// setting to large values to prevent issues
 	while (completed != n)
@@ -140,248 +138,248 @@
 			processes[shortest].rt = current_time - processes[shortest].at;
 		}
 
+		if(shortest != last_process) {
+			timeline[timeline_index++] = shortest;
+			last_process = shortest;
+		}
+
 		processes[shortest].remaining_bt--;
-  		current_time++;
+		current_time++;
 
-
-  		if (processes[shortest].remaining_bt == 0) {
-  			completed++;
-  			processes[shortest].ct = current_time;
-  			processes[shortest].is_completed = 1;
-  		}
-
-		timeline[timeline_index++] = current_time;
+		if (processes[shortest].remaining_bt == 0) {
+			completed++;
+			processes[shortest].ct = current_time;
+			processes[shortest].is_completed = 1;
+		}
 	}
 
 	calculate_times(processes, n);
 
-  	float avg_ct, avg_tat, avg_wt, avg_rt;
-  	calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
+	float avg_ct, avg_tat, avg_wt, avg_rt;
+	calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
 
 
-  	printf("\nPreemptive SJF Scheduling:\n");
-  	display_table(processes, n);
+	printf("\nPreemptive SJF Scheduling:\n");
+	display_table(processes, n);
 
 
-  	printf("\nAverage Completion Time: %.2f\n", avg_ct);
-  	printf("Average Turnaround Time: %.2f\n", avg_tat);
-  	printf("Average Waiting Time: %.2f\n", avg_wt);
-  	printf("Average Response Time: %.2f\n", avg_rt);
-
-
-  	display_gantt_chart(processes, n, timeline);
-  	free(timeline);
-}
-
- void round_robin(Process processes[], int n, int quantum) {
-
-  	for (int i = 0; i < n; i++) {
-  		processes[i].remaining_bt = processes[i].bt;
-  		processes[i].rt = -1;
-  		processes[i].is_completed = 0;
-  	}
-
-
-	int current_time = 0;
-  	int completed = 0;
-  	int i = 0;
-  	int *timeline = (int *)malloc((n * 2) * sizeof(int)); // memory for timeline
-
-	if (timeline == NULL) {
-  		perror("Failed to allocate memory for timeline");
-  		return;
-  		}
-
-	int timeline_index = 0;
-
-
-  	while (completed != n) {
-  		if (processes[i].remaining_bt > 0 && processes[i].at <= current_time) {
-  			if (processes[i].rt == -1) {
-  				processes[i].rt = current_time - processes[i].at;
-  			}
-
-  			int execute_time = (processes[i].remaining_bt > quantum) ? quantum : processes[i].remaining_bt; processes[i].remaining_bt -= execute_time; current_time += execute_time;
-
-			if (processes[i].remaining_bt == 0) {
-  				completed++;
-  				processes[i].ct = current_time;
-  				processes[i].is_completed = 1;
-  			}
-
-			timeline[timeline_index++] = current_time;
-
-			} else if (processes[i].at > current_time) {
-				current_time++; // if process hasn't arrived, time is incremented (to prevent a stall)
-  		}
-
-
-  	i = (i + 1) % n;
-  	if (current_time > 1000) break;
-  	}
-
-
-  	calculate_times(processes, n);
-
-
-  	float avg_ct, avg_tat, avg_wt, avg_rt;
-  	calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
-
-
-  	printf("\nRound Robin Scheduling (Quantum = %d):\n", quantum);
-  	display_table(processes, n);
-
-
-  	printf("\nAverage Completion Time: %.2f\n", avg_ct);
-  	printf("Average Turnaround Time: %.2f\n", avg_tat);
+	printf("\nAverage Completion Time: %.2f\n", avg_ct);
+	printf("Average Turnaround Time: %.2f\n", avg_tat);
 	printf("Average Waiting Time: %.2f\n", avg_wt);
 	printf("Average Response Time: %.2f\n", avg_rt);
 
 
-	display_gantt_chart(processes, n, timeline);
-	free(timeline); // Free memory
- }
+	display_gantt_chart(processes, n, timeline, timeline_index);
+	free(timeline);
+}
+
+	void round_robin(Process processes[], int n, int quantum) {
+
+			for (int i = 0; i < n; i++) {
+				processes[i].remaining_bt = processes[i].bt;
+				processes[i].rt = -1;
+				processes[i].is_completed = 0;
+			}
 
 
- void non_preemptive_priority(Process processes[], int n) {
-  	for (int i = 0; i < n - 1; i++) {
-  		for (int j = 0; j < n - i - 1; j++) {
-  			if (processes[j].at > processes[j + 1].at) {
-  				swap(&processes[j], &processes[j + 1]);
-  			}
-  		}
-  	}
-
-  	int current_time = 0;
-  	int completed = 0;
-  	int *timeline = (int *)malloc((n * 2) * sizeof(int));
+	int current_time = 0;
+			int completed = 0;
+			int i = 0;
+			int *timeline = (int *)malloc((n * 100) * sizeof(int));
 
 	if (timeline == NULL) {
-  		perror("Failed to allocate memory for timeline");
-  		return;
-  	}
+				perror("Failed to allocate memory for timeline");
+				return;
+				}
 
 	int timeline_index = 0;
+	int last_process = -1;
 
-  	while (completed != n) {
-  		int highest_priority = -1;
-  		int min_priority = 9999; // Large value
+			while (completed != n) {
+				if (processes[i].remaining_bt > 0 && processes[i].at <= current_time) {
+					if (processes[i].rt == -1) {
+						processes[i].rt = current_time - processes[i].at;
+					}
 
+					if(i != last_process) {
+						timeline[timeline_index++] = i;
+						last_process = i;
+					}
 
-  		for (int j = 0; j < n; j++) {
-  			if (processes[j].at <= current_time && processes[j].bt > 0 && processes[j].priority < min_priority) {
-  				min_priority = processes[j].priority;
-  				highest_priority = j;
-  			}
-  		}
+					int execute_time = (processes[i].remaining_bt > quantum) ? quantum : processes[i].remaining_bt;
+					processes[i].remaining_bt -= execute_time;
+					current_time += execute_time;
 
-  		if (highest_priority == -1) {
-  			current_time++;
-  			continue;
-  		}
+					if (processes[i].remaining_bt == 0) {
+						completed++;
+						processes[i].ct = current_time;
+						processes[i].is_completed = 1;
+					}
 
-  		if (processes[highest_priority].rt == -1) {
-  			processes[highest_priority].rt =
-  			current_time - processes[highest_priority].at;
-  		}
+				} else if (processes[i].at > current_time) {
+					current_time++;
+				}
 
-	  	current_time += processes[highest_priority].bt;
+				i = (i + 1) % n;
+				if (current_time > 1000) break;
+			}
 
-		processes[highest_priority].ct = current_time;
-  		processes[highest_priority].bt = 0; // Mark completed
+			calculate_times(processes, n);
 
-		completed++;
-  		timeline[timeline_index++] = current_time;
- 	}
+			float avg_ct, avg_tat, avg_wt, avg_rt;
+			calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
 
-  	calculate_times(processes, n);
+			printf("\nRound Robin Scheduling (Quantum = %d):\n", quantum);
+			display_table(processes, n);
 
-  	float avg_ct, avg_tat, avg_wt, avg_rt;
-  	calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
+			printf("\nAverage Completion Time: %.2f\n", avg_ct);
+			printf("Average Turnaround Time: %.2f\n", avg_tat);
+			printf("Average Waiting Time: %.2f\n", avg_wt);
+			printf("Average Response Time: %.2f\n", avg_rt);
 
-  	printf("\nNon-Preemptive Priority Scheduling:\n");
-  	display_table(processes, n);
+			display_gantt_chart(processes, n, timeline, timeline_index);
+			free(timeline);
+	}
 
-  	printf("\nAverage Completion Time: %.2f\n", avg_ct);
-  	printf("Average Turnaround Time: %.2f\n", avg_tat);
-  	printf("Average Waiting Time: %.2f\n", avg_wt);
-  	printf("Average Response Time: %.2f\n", avg_rt);
+	void non_preemptive_priority(Process processes[], int n) {
+			for (int i = 0; i < n - 1; i++) {
+				for (int j = 0; j < n - i - 1; j++) {
+					if (processes[j].at > processes[j + 1].at) {
+						swap(&processes[j], &processes[j + 1]);
+					}
+				}
+			}
 
-  	display_gantt_chart(processes, n, timeline);
-  	free(timeline); // Free  memory
- }
+			int current_time = 0;
+			int completed = 0;
+			int *timeline = (int *)malloc((n * 100) * sizeof(int));
 
+	if (timeline == NULL) {
+				perror("Failed to allocate memory for timeline");
+				return;
+			}
 
- int main() {
-  	int n, choice, quantum;
+	int timeline_index = 0;
+	int last_process = -1;
 
-  	printf("Enter the number of processes: ");
-  	scanf("%d", &n);
+			while (completed != n) {
+				int highest_priority = -1;
+				int min_priority = 9999;
 
-  	Process processes[n];
+				for (int j = 0; j < n; j++) {
+					if (processes[j].at <= current_time && processes[j].bt > 0 && processes[j].priority < min_priority) {
+						min_priority = processes[j].priority;
+						highest_priority = j;
+					}
+				}
 
-  // Input process details
-  for (int i = 0; i < n; i++) {
+				if (highest_priority == -1) {
+					current_time++;
+					continue;
+				}
+
+				if (processes[highest_priority].rt == -1) {
+					processes[highest_priority].rt = current_time - processes[highest_priority].at;
+				}
+
+				if(highest_priority != last_process) {
+					timeline[timeline_index++] = highest_priority;
+					last_process = highest_priority;
+				}
+
+				current_time += processes[highest_priority].bt;
+				processes[highest_priority].ct = current_time;
+				processes[highest_priority].bt = 0;
+				completed++;
+		}
+
+			calculate_times(processes, n);
+
+			float avg_ct, avg_tat, avg_wt, avg_rt;
+			calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
+
+			printf("\nNon-Preemptive Priority Scheduling:\n");
+			display_table(processes, n);
+
+			printf("\nAverage Completion Time: %.2f\n", avg_ct);
+			printf("Average Turnaround Time: %.2f\n", avg_tat);
+			printf("Average Waiting Time: %.2f\n", avg_wt);
+			printf("Average Response Time: %.2f\n", avg_rt);
+
+			display_gantt_chart(processes, n, timeline, timeline_index);
+			free(timeline);
+	}
+
+	int main() {
+			int n, choice, quantum;
+
+			printf("Enter the number of processes: ");
+			scanf("%d", &n);
+
+			Process processes[n];
+
+		// Input process details
+		for (int i = 0; i < n; i++) {
 	printf("\nEnter details for process %d:\n", i + 1);
 
 	printf("PID: ");
 	scanf("%s", processes[i].pid);
 
 	printf("Arrival Time: ");
-  	scanf("%d", &processes[i].at);
+			scanf("%d", &processes[i].at);
 
 	printf("Burst Time: ");
-  	scanf("%d", &processes[i].bt);
+			scanf("%d", &processes[i].bt);
 
 	printf("Priority (lower value = higher priority): ");
-  	scanf("%d", &processes[i].priority);
+			scanf("%d", &processes[i].priority);
 
 	processes[i].rt = 0; // Initialize response time
-  	processes[i].is_completed = 0; // Initialize completion flag
-  }
+			processes[i].is_completed = 0; // Initialize completion flag
+		}
 
-  // Display initial table
-  	printf("\nInitial Process Table:\n");
-  	printf("-----------------------\n");
-  	printf("| PID   | AT  | BT  |\n");
-  	printf("-----------------------\n");
+		// Display initial table
+			printf("\nInitial Process Table:\n");
+			printf("-----------------------\n");
+			printf("| PID   | AT  | BT  |\n");
+			printf("-----------------------\n");
 
-  	for (int i = 0; i < n; i++) {
-  		printf("| %-5s | %-3d | %-3d |\n", processes[i].pid, processes[i].at, processes[i].bt);
-  	}
+			for (int i = 0; i < n; i++) {
+				printf("| %-5s | %-3d | %-3d |\n", processes[i].pid, processes[i].at, processes[i].bt);
+			}
 
 	printf("-----------------------\n");
 
-  // Algorithm Selection Menu with Loop and Exit
-  	while (1) {
-  		printf("\nChoose a scheduling algorithm:\n");
-  		printf("1. Preemptive SJF\n");
-  		printf("2. Round Robin\n");
-  		printf("3. Non-Preemptive Priority\n");
-  		printf("4. Exit\n");
-  		printf("Enter your choice: ");
+		// Algorithm Selection Menu with Loop and Exit
+			while (1) {
+				printf("\nChoose a scheduling algorithm:\n");
+				printf("1. Preemptive SJF\n");
+				printf("2. Round Robin\n");
+				printf("3. Non-Preemptive Priority\n");
+				printf("4. Exit\n");
+				printf("Enter your choice: ");
 
 		scanf("%d", &choice);
 
 		switch (choice) {
-		  case 1:
-			  preemptive_sjf(processes, n);
-			  break;
-		  case 2:
-  			printf("Enter the time quantum: ");
-  			scanf("%d", &quantum);
-  			round_robin(processes, n, quantum);
-  		  	break;
-  		  case 3:
-  			non_preemptive_priority(processes, n);
-  			break;
-  		  case 4:
-  			printf("Exiting program.\n");
-  			exit(0);
-  		  default:
-  			printf("Invalid choice. Please try again.\n");
-  		}
-  }
+				case 1:
+					preemptive_sjf(processes, n);
+					break;
+				case 2:
+					printf("Enter the time quantum: ");
+					scanf("%d", &quantum);
+					round_robin(processes, n, quantum);
+							break;
+						case 3:
+					non_preemptive_priority(processes, n);
+					break;
+						case 4:
+					printf("Exiting program.\n");
+					exit(0);
+						default:
+					printf("Invalid choice. Please try again.\n");
+				}
+		}
 
-  return 0;
- }
+		return 0;
+	}

OS/C/Week7/aq1.c

@@ -0,0 +1 @@
+// Write a C program to solve the Dining-Philosophers problem.

OS/C/Week8/q1.c

@@ -0,0 +1,134 @@
+// Develop a program to simulate banker’s algorithm. (Consider safety and resource-request algorithms)
+
+#include <stdio.h>
+
+#define MAX_PROCESSES 10
+#define MAX_RESOURCES 10
+
+int processes, resources;
+int available[MAX_RESOURCES];
+int maximum[MAX_PROCESSES][MAX_RESOURCES];
+int allocation[MAX_PROCESSES][MAX_RESOURCES];
+int need[MAX_PROCESSES][MAX_RESOURCES];
+
+int safeSequence[MAX_PROCESSES];
+
+void initialize() {
+    printf("Enter number of processes: ");
+    scanf("%d", &processes);
+
+    printf("Enter number of resources: ");
+    scanf("%d", &resources);
+
+    printf("\nEnter available resources:\n");
+    for(int i=0; i<resources; i++) {
+        scanf("%d", &available[i]);
+    }
+
+    printf("\nEnter maximum matrix:\n");
+    for(int i=0; i<processes; i++) {
+        for(int j=0; j<resources; j++) {
+            scanf("%d", &maximum[i][j]);
+        }
+    }
+
+    printf("\nEnter allocation matrix:\n");
+    for(int i=0; i<processes; i++) {
+        for(int j=0; j<resources; j++) {
+            scanf("%d", &allocation[i][j]);
+            need[i][j] = maximum[i][j] - allocation[i][j];
+        }
+    }
+}
+
+int isSafe() {
+    int work[MAX_RESOURCES];
+    int finish[MAX_PROCESSES] = {0};
+    int count = 0;
+
+    for(int i=0; i<resources; i++)
+        work[i] = available[i];
+
+    while(count < processes) {
+        int found = 0;
+        for(int p=0; p<processes; p++) {
+            if(!finish[p]) {
+                int j;
+                for(j=0; j<resources; j++) {
+                    if(need[p][j] > work[j])
+                        break;
+                }
+                if(j == resources) {
+                    for(int k=0; k<resources; k++)
+                        work[k] += allocation[p][k];
+                    safeSequence[count] = p;
+                    finish[p] = 1;
+                    count++;
+                    found = 1;
+                }
+            }
+        }
+        if(!found) return 0;
+    }
+    return 1;
+}
+
+void resourceRequest(int process) {
+    int request[MAX_RESOURCES];
+
+    printf("\nEnter resource request for process %d:\n", process);
+    for(int i=0; i<resources; i++) {
+        scanf("%d", &request[i]);
+    }
+
+    // Check if request is valid
+    for(int i=0; i<resources; i++) {
+        if(request[i] > need[process][i]) {
+            printf("Error: Request exceeds maximum claim\n");
+            return;
+        }
+        if(request[i] > available[i]) {
+            printf("Error: Resources not available\n");
+            return;
+        }
+    }
+
+    // Try to allocate
+    for(int i=0; i<resources; i++) {
+        available[i] -= request[i];
+        allocation[process][i] += request[i];
+        need[process][i] -= request[i];
+    }
+
+    if(isSafe()) {
+        printf("Request granted\n");
+    } else {
+        printf("Request denied - unsafe state\n");
+        // Rollback
+        for(int i=0; i<resources; i++) {
+            available[i] += request[i];
+            allocation[process][i] -= request[i];
+            need[process][i] += request[i];
+        }
+    }
+}
+
+int main() {
+    initialize();
+
+    if(isSafe()) {
+        printf("\nSystem is in safe state.\nSafe sequence: ");
+        for(int i=0; i<processes; i++)
+            printf("P%d ", safeSequence[i]);
+        printf("\n");
+
+        int process;
+        printf("\nEnter process number (0-%d) to request resources: ", processes-1);
+        scanf("%d", &process);
+        resourceRequest(process);
+    } else {
+        printf("\nSystem is not in safe state!\n");
+    }
+
+    return 0;
+}