diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 41641c8..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,65 +0,0 @@
-### 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
diff --git a/DBMS/SQL/Week7/writeup.md b/DBMS/SQL/Week7/writeup.md
index 1b4f589..235f665 100644
--- a/DBMS/SQL/Week7/writeup.md
+++ b/DBMS/SQL/Week7/writeup.md
@@ -1,176 +1 @@
-## 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
- ```
\ No newline at end of file
+## Week 7 - DBMS Lab - PL SQL & Triggers
\ No newline at end of file
diff --git a/OS/C/Week6/menu b/OS/C/Week6/menu
deleted file mode 100755
index a8eb922..0000000
Binary files a/OS/C/Week6/menu and /dev/null differ
diff --git a/OS/C/Week6/menudriven.c b/OS/C/Week6/menudriven.c
index 6001315..f36895f 100644
--- a/OS/C/Week6/menudriven.c
+++ b/OS/C/Week6/menudriven.c
@@ -4,87 +4,90 @@
 
 # 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[], 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");
-	}
+ // 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 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");
-	}
+	printf("\n-----------------------------------------------------------\n");
 
-	// Preemptive SJF
-	void preemptive_sjf(Process processes[], int 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){
 
 	// process sort by AT
 	for (int i = 0; i < n -1; i++){
@@ -107,14 +110,13 @@
 	int completed = 0;
 	int shortest = -1;
 
-	int *timeline = (int *)malloc((n*100)*sizeof(int));
+	int *timeline = (int *)malloc((n*2)*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)
@@ -138,248 +140,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;
-		}
+
+  		if (processes[shortest].remaining_bt == 0) {
+  			completed++;
+  			processes[shortest].ct = current_time;
+  			processes[shortest].is_completed = 1;
+  		}
+
+		timeline[timeline_index++] = current_time;
 	}
 
 	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("\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("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);
-}
-
-	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;
-			}
+	display_gantt_chart(processes, n, timeline);
+	free(timeline); // Free memory
+ }
 
 
-	int current_time = 0;
-			int completed = 0;
-			int i = 0;
-			int *timeline = (int *)malloc((n * 100) * sizeof(int));
+ 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));
 
 	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) {
-				if (processes[i].remaining_bt > 0 && processes[i].at <= current_time) {
-					if (processes[i].rt == -1) {
-						processes[i].rt = current_time - processes[i].at;
-					}
+  	while (completed != n) {
+  		int highest_priority = -1;
+  		int min_priority = 9999; // Large value
 
-					if(i != last_process) {
-						timeline[timeline_index++] = i;
-						last_process = i;
-					}
 
-					int execute_time = (processes[i].remaining_bt > quantum) ? quantum : processes[i].remaining_bt;
-					processes[i].remaining_bt -= execute_time;
-					current_time += execute_time;
+  		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;
+  			}
+  		}
 
-					if (processes[i].remaining_bt == 0) {
-						completed++;
-						processes[i].ct = current_time;
-						processes[i].is_completed = 1;
-					}
+  		if (highest_priority == -1) {
+  			current_time++;
+  			continue;
+  		}
 
-				} else if (processes[i].at > current_time) {
-					current_time++;
-				}
+  		if (processes[highest_priority].rt == -1) {
+  			processes[highest_priority].rt =
+  			current_time - processes[highest_priority].at;
+  		}
 
-				i = (i + 1) % n;
-				if (current_time > 1000) break;
-			}
+	  	current_time += processes[highest_priority].bt;
 
-			calculate_times(processes, n);
+		processes[highest_priority].ct = current_time;
+  		processes[highest_priority].bt = 0; // Mark completed
 
-			float avg_ct, avg_tat, avg_wt, avg_rt;
-			calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
+		completed++;
+  		timeline[timeline_index++] = current_time;
+ 	}
 
-			printf("\nRound Robin Scheduling (Quantum = %d):\n", quantum);
-			display_table(processes, n);
+  	calculate_times(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);
+  	float avg_ct, avg_tat, avg_wt, avg_rt;
+  	calculate_averages(processes, n, &avg_ct, &avg_tat, &avg_wt, &avg_rt);
 
-			display_gantt_chart(processes, n, timeline, timeline_index);
-			free(timeline);
-	}
+  	printf("\nNon-Preemptive Priority Scheduling:\n");
+  	display_table(processes, n);
 
-	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]);
-					}
-				}
-			}
+  	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);
 
-			int current_time = 0;
-			int completed = 0;
-			int *timeline = (int *)malloc((n * 100) * sizeof(int));
+  	display_gantt_chart(processes, n, timeline);
+  	free(timeline); // Free  memory
+ }
 
-	if (timeline == NULL) {
-				perror("Failed to allocate memory for timeline");
-				return;
-			}
 
-	int timeline_index = 0;
-	int last_process = -1;
+ int main() {
+  	int n, choice, quantum;
 
-			while (completed != n) {
-				int highest_priority = -1;
-				int min_priority = 9999;
+  	printf("Enter the number of processes: ");
+  	scanf("%d", &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;
-					}
-				}
+  	Process processes[n];
 
-				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++) {
+  // 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;
+ }
diff --git a/OS/C/Week7/aq1.c b/OS/C/Week7/aq1.c
index 4cce698..e69de29 100644
--- a/OS/C/Week7/aq1.c
+++ b/OS/C/Week7/aq1.c
@@ -1 +0,0 @@
-// Write a C program to solve the Dining-Philosophers problem.
diff --git a/OS/C/Week8/aq1.c b/OS/C/Week8/aq1.c
deleted file mode 100644
index e69de29..0000000
diff --git a/OS/C/Week8/q1.c b/OS/C/Week8/q1.c
deleted file mode 100644
index 783cfe8..0000000
--- a/OS/C/Week8/q1.c
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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;
-}