Upload batch 35/306

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 3.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6577ba75d3d676f6a3f2fce14714e122d5ab94c6a8bbb602449da0e38b583e7
+size 715252

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 4.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6168fbbae680dc23a7902e064f9a368565afa237868a578e62691057bfc3c712
+size 749893

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 5.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d52ad6c70765615dfc6e9af8fa3b7685834e9b84cf200591fce53162706e4fe
+size 660153

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 6.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be34f9c68513b7e2663f493002f4c94de5cf81615e66a339b45be65a7a705939
+size 993223

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 7.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05ad08625d9b8d217d6cbf2eb5562602ecbd25358186a25d03ab26e0698ac8ed
+size 755238

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 8.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c36e1b766b1518e35b54fe02a4d2f1e71cfc6cb7ef6d4a1335a2663695ca2fee
+size 717892

שנה א/מבוא למדעי המחשב/עבודות בית/מטלת בית מספר 9.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e10b56ff6876578136a28d7847ebc321ee953ef503625f5391c8bf36187e0af5
+size 609178

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-1.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+
+// Function to calculate and print the birth year
+void printDate() {
+    int currentYear = 2024;
+    int age = 26;
+    printf("Birth Year is: %d\n", currentYear - age);
+}
+
+// Function to print a nicely aligned pattern resembling 'X' in one printf statement
+void printX() {
+    printf("*     *\n"
+        " *   * \n"
+        "  * *  \n"
+        "   *   \n"
+        "  * *  \n"
+        " *   * \n"
+        "*     *\n");
+}
+
+// Function to calculate and print earnings compensation for a worker
+void printBobEranings() {
+    long id = 306543365;
+    double hourlyRate = 50.3;
+    int hoursWorkedDay = 8;
+    int daysWorkedInWeek = 5;
+    int yearFired = 2024;
+    int yearHired = 1990;
+
+    int yearsWorked = yearFired - yearHired; // Calculate total years worked
+    double monthWorth = hourlyRate * hoursWorkedDay * daysWorkedInWeek * 4; // Approximate monthly earnings
+    double compensation = yearsWorked * monthWorth; // Total compensation based on years worked
+
+    printf("Congratulations Worker ID: %ld\n", id);
+    printf("Thank you for the %d years you've worked\n", yearsWorked);
+    printf("You are entitled to a sum of: %.2f\n", compensation);
+    printf("Thank you and Goodbye!\n");
+}
+
+// Function to calculate and print average amount paid per item by Alice
+void printAliceBill() {
+    double productA = 2.0;
+    double productB = 2.5;
+    int boughtA = 10;
+    int boughtB = 2;
+
+    double totalPaid = (productA * boughtA) + (productB * boughtB); // Total amount spent
+    double totalItems = boughtA + boughtB; // Total items bought
+    double average = totalPaid / totalItems; // Average amount per item
+
+    printf("Alice paid in average %f NIS per item\n", average);
+}
+
+// Function to calculate and print the estimated arrival time based on distance and speed
+void printArrivelTime() {
+    double distance = 300; // Distance to travel in KM
+    double speed = 120; // Speed in KMH
+
+    double timeInHours = distance / speed; // Calculate total time in hours
+    int hours = timeInHours; // Extract whole hours
+    int minutes = (timeInHours - hours) * 60; // Calculate remaining minutes
+
+    printf("Arriving in %d hours and %d minutes.\n", hours, minutes);
+}
+
+int main() {
+    printDate();
+    printf("--------------\n");
+    printX();
+    printf("--------------\n");
+    printBobEranings();
+    printf("--------------\n");
+    printAliceBill();
+    printf("--------------\n");
+    printArrivelTime();
+    return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-10.c

@@ -0,0 +1,207 @@
+#include <stdio.h>
+
+int findIndex(int* arr, int n) {
+	for (int i = 0; i < n; i++)
+		if (arr[i] == i)
+			return i;
+	return -1;
+}
+
+int findIndexLog(int* arr, int n) {
+	int mid, low = 0, high = n - 1; // Initialize low and high for binary search
+
+	// Step 1: Check boundary cases
+	if (arr[low] == low) return low;   // If the first element matches its index
+	if (arr[high] == high) return high; // If the last element matches its index
+
+	// Step 2: Perform binary search
+	while (low <= high) { // Continue while the search range is valid
+		mid = (low + high) / 2; // Calculate the middle index
+
+		if (arr[mid] == mid) {  // If the middle element matches its index
+			return mid;         // Return the matching index
+		}
+
+		if (arr[mid] > mid) {   // If the middle value is greater than its index
+			high = mid - 1;     // Search the left half
+		}
+
+		if (arr[mid] < mid) {   // If the middle value is less than its index
+			low = mid + 1;      // Search the right half
+		}
+	}
+
+	// Step 3: If no match is found, return -1
+	return -1;
+}
+
+// Iterative binary search for reverse-sorted array
+int findKey(int* arr, int n, int key) {
+	int low = n - 1, high = 0, mid; // Initialize low and high for reverse-sorted array
+
+	// Step 1: Check boundary cases
+	if (arr[low] == key) return low;   // Check if the key matches the last element
+	if (arr[high] == key) return high; // Check if the key matches the first element
+
+	// Step 2: Perform binary search
+	while (high <= low) { // Continue while the search range is valid
+		mid = (low + high) / 2; // Calculate the middle index
+
+		if (arr[mid] == key) return mid; // If the middle element matches the key, return its index
+
+		if (arr[mid] > key) {   // If the middle value is greater than the key
+			high = mid + 1;     // Search the right side
+		}
+		else if (arr[mid] < key) { // If the middle value is less than the key
+			low = mid - 1;      // Search the left side
+		}
+	}
+
+	return -1; // If the key is not found, return -1
+}
+
+// Recursive binary search for reverse-sorted array
+int findKeyRe(int* arr, int n, int key, int low, int high) {
+	// Base Case: If the search range becomes invalid
+	if (low < high) return -1;
+
+	int mid = (low + high) / 2; // Calculate the middle index
+
+	if (arr[mid] == key) return mid; // If the middle element matches the key, return its index
+
+	if (arr[mid] > key) { // If the middle value is greater than the key
+		// Recursively search the right half (adjust high)
+		return findKeyRe(arr, n, key, low, mid + 1);
+	}
+	else if (arr[mid] < key) { // If the middle value is less than the key
+		// Recursively search the left half (adjust low)
+		return findKeyRe(arr, n, key, mid - 1, high);
+	}
+
+	return -1; // This point should never be reached if all cases are handled
+}
+
+// Wrapper function to initialize the recursion
+int findKeyR(int* arr, int n, int key) {
+	// Call the recursive helper function with initial range for reverse-sorted array
+	return findKeyRe(arr, n, key, n - 1, 0);
+}
+
+int findKeyAsc(int* arr, int n, int key) {
+	int low = 0, high = n - 1, mid; // Initialize low and high for a sorted array
+	int result = -1; // To store the minimum index of the key
+
+	// Perform binary search
+	while (low <= high) {
+		mid = (low + high) / 2; // Calculate the middle index
+
+		if (arr[mid] == key) {
+			result = mid; // Save the current index as a potential result
+			high = mid - 1; // Continue searching in the left half for a smaller index
+		}
+		else if (arr[mid] > key) {
+			high = mid - 1; // Search the left side
+		}
+		else {
+			low = mid + 1; // Search the right side
+		}
+	}
+
+	return result; // Return the minimum index of the key, or -1 if not found
+}
+
+int sumArr(int* arr, int n, int x) {
+	// Define two pointers: low starting at the beginning of the array,
+	// and high starting at the end of the array.
+	int low = 0, high = n - 1;
+
+	// Loop until the two pointers meet.
+	while (low < high) {
+		// Calculate the sum of the elements at the low and high pointers.
+		int sum = arr[low] + arr[high];
+
+		// If the sum equals the target value x:
+		if (sum == x) {
+			// Print the indices of the two elements that sum to x.
+			printf("%d %d\n", low, high);
+			// Return 1 to indicate a successful match.
+			return 1;
+		}
+
+		// If the sum is greater than x, decrement the high pointer
+		// to reduce the sum (move to a smaller element).
+		if (sum > x)
+			high--;
+
+		// If the sum is less than x, increment the low pointer
+		// to increase the sum (move to a larger element).
+		if (sum < x)
+			low++;
+	}
+
+	// If no such pair is found, return 0.
+	return 0;
+}
+
+int sumMonotonic(int x, int* arr, int n) {
+	int low = 0, high = n - 2;
+	int mid, sum = 0;
+
+	while (low <= high) {
+		mid = (low + high) / 2;
+		sum = arr[mid] + arr[mid + 1];
+
+		if (sum == x) return mid;
+
+		if (sum > x) {
+			high = mid - 1;
+		}
+		else {
+			low = mid + 1;
+		}
+	}
+	return -1;
+
+}
+
+int main()
+{
+	// 1
+	//int arr[] = {-1,1,6,9,11};
+	//int arr1[] = {-1,0,6,9,11};
+
+	//printf("%d\n", findIndex(arr,5));
+	//printf("%d\n", findIndex(arr1,5));
+	//printf("--------\n");
+	//printf("%d\n", findIndexLog(arr,5));
+	//printf("%d\n", findIndexLog(arr1,5));
+
+	// 2
+	//int arr[] = { 9,7,7,5,3,3,3,1 };
+	//int n = 8;
+	//printf("%d\n",findKey(arr,n,3));
+	//printf("%d\n",findKey(arr,n,4));
+	//printf("%d\n", findKeyR(arr, n, 3));
+	//printf("%d\n", findKeyR(arr, n, 4));
+
+	// 3
+	//int arr[] = { 1,1,3,3,3,6,8,9,9 };
+	//int n = 9;
+	//printf("%d\n",findKeyAsc(arr,n,3));
+	//printf("%d\n",findKeyAsc(arr,n,4));
+
+	// 4
+	//int arr[] = { 1,3,5,5,6,9,10,13 };
+	//int n = 8;
+	//int x = 13;
+	//printf("%d", sumArr(arr, n, x));
+
+	// 5
+	//int arr[] = {-3,8,1,9,15,10,18};
+	//int n = 7;
+	//printf("%d\n", sumMonotonic(28, arr, n)); // --> 5
+	//printf("%d\n", sumMonotonic(10, arr, n)); // --> 2
+	//printf("%d\n", sumMonotonic(5, arr, n)); // --> 0
+
+	return 0;
+}

שנה א/מבוא למדעי המחשב/עבודות בית/פתרונות לעבודות/מטלה-11.c

@@ -0,0 +1,385 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void printArr(int* arr, int n) {
+	printf("{");
+	for (int i = 0; i < n; i++)
+	{
+		if (i + 1 == n)
+			printf("%d", arr[i]);
+		else
+			printf("%d ,", arr[i]);
+	}
+	printf("}\n");
+}
+
+void sort(int* arr, int n) {
+	int freq[] = { 0,0,0,0,0,0,0,0,0,0 }; // Frequency array to count occurrences of digits 0�9
+
+	// Step 1: Count the frequency of each number in the array (O(n))
+	for (int i = 0; i < n; i++) {
+		freq[arr[i]]++; // Increment the count of the number at index `arr[i]`
+	}
+
+	// Step 2: Reconstruct the sorted array using the frequency array (O(n))
+	for (int i = 0, j = 0; i < 10; i++) { // Loop through digits 0�9
+		while (freq[i] > 0) { // If the current digit `i` appears in the array
+			arr[j++] = i; // Place it in the sorted array
+			freq[i]--; // Decrement the frequency count
+		}
+	}
+}
+
+void sortEvenOdd(int* arr, int n) {
+	int low = 0, high = n - 1; // Two pointers: `low` starts at the beginning, `high` starts at the end
+	int temp; // Temporary variable for swapping
+
+	// Step 1: Traverse the array using the two pointers
+	while (low <= high) {
+		// Case 1: `low` points to an odd number, `high` points to an even number
+		if (arr[low] % 2 != 0 && arr[high] % 2 == 0) {
+			// Swap the odd number at `low` with the even number at `high`
+			temp = arr[low];
+			arr[low] = arr[high];
+			arr[high] = temp;
+
+			// Move both pointers inward after the swap
+			low++;
+			high--;
+		}
+
+		// Case 2: `low` points to an even number
+		if (arr[low] % 2 == 0) low++; // Move `low` to the next position
+
+		// Case 3: `high` points to an odd number
+		if (arr[high] % 2 != 0) high--; // Move `high` to the previous position
+	}
+}
+
+void merge(int* arr, int start1, int end1, int start2, int end2) {
+	// Calculate the total size of the merged array
+	int size = (end1 - start1 + 1) + (end2 - start2 + 1);
+
+	// Pointers for the two sub-arrays
+	int i = start1, j = start2;
+
+	// Allocate memory for a temporary array to hold the merged result
+	int* temp = (int*)calloc(size, sizeof(int));
+	if (temp == NULL) { // Check for memory allocation failure
+		printf("Memory allocation failed.\n");
+		return;
+	}
+
+	int count = 0; // Counter for the temporary array
+
+	// Step 1: Merge elements from both sub-arrays into `temp` while both have elements
+	while (i <= end1 && j <= end2) {
+		if (arr[i] < arr[j]) { // Take the smaller element from the first sub-array
+			temp[count] = arr[i];
+			i++; // Move the pointer for the first sub-array
+		}
+		else { // Take the smaller element from the second sub-array
+			temp[count] = arr[j];
+			j++; // Move the pointer for the second sub-array
+		}
+		count++; // Move the pointer for the temporary array
+	}
+
+	// Step 2: Add remaining elements from the first sub-array, if any
+	while (i <= end1) {
+		temp[count] = arr[i];
+		i++;
+		count++;
+	}
+
+	// Step 3: Add remaining elements from the second sub-array, if any
+	while (j <= end2) {
+		temp[count] = arr[j];
+		j++;
+		count++;
+	}
+
+	// Step 4: Copy the merged result from `temp` back to the original array `arr`
+	for (int k = 0; k < size; k++) {
+		arr[start1 + k] = temp[k];
+	}
+
+	// Step 5: Free the memory allocated for `temp`
+	free(temp);
+}
+
+void sortK(int* arr, int n, int k) {
+	int start = 0, end = n - 1; // `start` is the beginning of the first sub-array, `end` is the last index of the array
+	int end1;                  // Stores the end index of the first sub-array in each merge
+	int start2, end2;          // Stores the start and end indices of the second sub-array in each merge
+
+	// Loop through the array, processing chunks of size `k`
+	for (int i = 1; i * k < n; i++) {
+		// Calculate the end of the first sub-array
+		end1 = (i * k) - 1;
+
+		// Calculate the start of the second sub-array
+		start2 = end1 + 1;
+
+		// Calculate the end of the second sub-array
+		// Ensure that the end of the second sub-array doesn't go beyond the array bounds
+		end2 = (start2 + k - 1 > end) ? end : start2 + k - 1;
+
+		// Merge the two sub-arrays: `arr[start...end1]` and `arr[start2...end2]`
+		merge(arr, start, end1, start2, end2);
+	}
+}
+
+// Helper function to partition the array and find the sum of k smallest elements
+int partitionHelper(int* arr, int n, int k) {
+	// Handle invalid input (k cannot be greater than n)
+	if (k > n) {
+		printf("Invalid input: k cannot be greater than n\n");
+		return 0;
+	}
+
+	// Base case: If the array has only one element and k == 1, return that element
+	if (n == 1 && k == 1) {
+		return arr[0];
+	}
+
+	// Step 1: Select a pivot randomly to avoid biased splits
+	int pivot = arr[rand() % n];
+
+	// Allocate memory for two groups
+	int* group1 = (int*)malloc(n * sizeof(int)); // Group for elements smaller than pivot
+	int* group2 = (int*)malloc(n * sizeof(int)); // Group for elements greater than or equal to pivot
+
+	if (group1 == NULL || group2 == NULL) { // Check for memory allocation failure
+		printf("Memory allocation failed.\n");
+		exit(1);
+	}
+
+	int count1 = 0, count2 = 0;
+
+	// Step 2: Partition the array into group1 and group2
+	for (int i = 0; i < n; i++) {
+		if (arr[i] < pivot) {
+			group1[count1++] = arr[i];
+		}
+		else {
+			group2[count2++] = arr[i];
+		}
+	}
+
+	// Step 3: Handle edge case: If group1 is empty, move one instance of pivot to group1
+	if (count1 == 0) {
+		group1[count1++] = pivot;
+		count2--;
+	}
+
+	// Step 4: Compare the size of group1 with k
+	if (count1 == k) {
+		// Exactly k smallest elements are in group1
+		int sum = 0;
+		for (int i = 0; i < count1; i++) {
+			sum += group1[i];
+		}
+		free(group1);
+		free(group2);
+		return sum;
+	}
+	else if (count1 > k) {
+		// The k smallest elements are all in group1, recurse into group1
+		free(group2);
+		int result = partitionHelper(group1, count1, k);
+		free(group1);
+		return result;
+	}
+	else {
+		// Take all elements of group1 and find the remaining (k - count1) smallest elements in group2
+		int sum = 0;
+		for (int i = 0; i < count1; i++) {
+			sum += group1[i];
+		}
+		free(group1); // Free group1 memory
+		int remainingSum = partitionHelper(group2, count2, k - count1);
+		free(group2); // Free group2 memory
+		return sum + remainingSum; // Return combined sum
+	}
+}
+
+int findKSmallestSum(int* arr, int n, int k) {
+	return partitionHelper(arr, n, k);
+}
+
+// Function to merge two sorted sub-arrays in descending order
+void mergeDescending(int* arr, int start, int mid, int end) {
+	// Step 1: Calculate the size of the temporary array
+	int size = end - start + 1; // Total elements in the range [start, end]
+	int* temp = (int*)malloc(size * sizeof(int)); // Allocate temporary array
+	if (temp == NULL) {
+		printf("Memory allocation failed.\n");
+		return;
+	}
+
+	// Step 2: Initialize pointers for the left, right sub-arrays, and temp array
+	int i = start;      // Pointer for the left sub-array [start, mid]
+	int j = mid + 1;    // Pointer for the right sub-array [mid + 1, end]
+	int k = 0;          // Pointer for the temporary array
+
+	// Step 3: Merge the two sub-arrays into temp in descending order
+	while (i <= mid && j <= end) {
+		if (arr[i] > arr[j]) {  // Compare elements
+			temp[k++] = arr[i++]; // Take the larger element
+		}
+		else {
+			temp[k++] = arr[j++]; // Take the larger element
+		}
+	}
+
+	// Step 4: Copy any remaining elements from the left sub-array
+	while (i <= mid) {
+		temp[k++] = arr[i++]; // Add remaining elements from the left
+	}
+
+	// Step 5: Copy any remaining elements from the right sub-array
+	while (j <= end) {
+		temp[k++] = arr[j++]; // Add remaining elements from the right
+	}
+
+	// Step 6: Copy the sorted elements from temp back into the original array
+	for (int l = 0; l < size; l++) {
+		arr[start + l] = temp[l]; // Copy temp array to the original array
+	}
+
+	// Free the temporary array
+	free(temp); // Prevent memory leak
+}
+
+// Recursive function to sort an array in descending order
+void sortDescendingRecursive(int* arr, int start, int end) {
+	if (start >= end) return; // Base case: Sub-array with 1 or 0 elements is already sorted
+
+	int mid = (start + end) / 2; // Calculate the middle index
+
+	// Recursively sort the left half
+	sortDescendingRecursive(arr, start, mid);
+
+	// Recursively sort the right half
+	sortDescendingRecursive(arr, mid + 1, end);
+
+	// Merge the two halves in descending order
+	mergeDescending(arr, start, mid, end);
+}
+
+// Wrapper function to sort the entire array in descending order
+void sortDecending(int* arr, int n) {
+	int start = 0, end = n - 1; // Set the range for the entire array
+	sortDescendingRecursive(arr, start, end); // Start the recursive sorting process
+}
+
+int main()
+{
+	// 1
+	//int arr[] = { 1,5,9,2,3 };
+	//sort(arr, 5);
+	//printArr(arr, 5);
+	//int arr1[] = { 8,6,5,2,1,3,4,7,8,9,6,5,2,3,5,4,7,0};
+	//sort(arr1, 18);
+	//printArr(arr1, 18);
+
+	// 2
+	//int arr[] = { 1,6,3,8,2 };
+	//sortEvenOdd(arr, 5);
+	//printArr(arr, 5);
+
+	// 3
+	//int arr[] = { -1,2,5,3,7,9,4,6 };
+	//int n = 8, k = 3;
+	//sortK(arr, n, k);
+	//printArr(arr, n);
+
+	//// Test Case 1: Basic Case
+	//int arr1[] = { 3, 4, 5, 1, 2, 6 };
+	//int n1 = 6, k1 = 3;
+	//sortK(arr1, n1, k1);
+	//printf("Test 1: ");
+	//printArr(arr1, n1); // Expected: {1, 2, 3, 4, 5, 6}
+
+	//// Test Case 2: Single Element Sub-Arrays
+	//int arr2[] = { 10, 20, 30, 40 };
+	//int n2 = 4, k2 = 1;
+	//sortK(arr2, n2, k2);
+	//printf("Test 2: ");
+	//printArr(arr2, n2); // Expected: {10, 20, 30, 40}
+
+	//// Test Case 3: Sub-Arrays Already Sorted
+	//int arr3[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+	//int n3 = 8, k3 = 3;
+	//sortK(arr3, n3, k3);
+	//printf("Test 3: ");
+	//printArr(arr3, n3); // Expected: {1, 2, 3, 4, 5, 6, 7, 8}
+
+	//// Test Case 4: Array with Last Sub-Array Smaller than k
+	//int arr4[] = { 9, 12, 14, 1, 3, 8, 7 };
+	//int n4 = 7, k4 = 3;
+	//sortK(arr4, n4, k4);
+	//printf("Test 4: ");
+	//printArr(arr4, n4); // Expected: {1, 3, 7, 8, 9, 12, 14}
+
+	//// Test Case 5: Array of Size 1
+	//int arr5[] = { 5 };
+	//int n5 = 1, k5 = 3;
+	//sortK(arr5, n5, k5);
+	//printf("Test 5: ");
+	//printArr(arr5, n5); // Expected: {5}
+
+	//// Test Case 6: Reverse Sorted Array
+	//int arr6[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+	//int n6 = 9, k6 = 3;
+	//sortK(arr6, n6, k6);
+	//printf("Test 6: ");
+	//printArr(arr6, n6); // Expected: {1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	//// Test Case 7: Array of Repeated Elements
+	//int arr7[] = { 5, 5, 5, 5, 5, 5 };
+	//int n7 = 6, k7 = 2;
+	//sortK(arr7, n7, k7);
+	//printf("Test 7: ");
+	//printArr(arr7, n7); // Expected: {5, 5, 5, 5, 5, 5}
+
+	//// Test Case 8: Array with Negative Numbers
+	//int arr8[] = { -9, -7, -5, -1, -3, -4, -2 };
+	//int n8 = 7, k8 = 3;
+	//sortK(arr8, n8, k8);
+	//printf("Test 8: ");
+	//printArr(arr8, n8); // Expected: {-9, -7, -5, -4, -3, -2, -1}
+
+	//// Test Case 9: Array Size Smaller than k
+	//int arr9[] = { 5, 1, 3, 2 };
+	//int n9 = 4, k9 = 5;
+	//sortK(arr9, n9, k9);
+	//printf("Test 9: ");
+	//printArr(arr9, n9); // Expected: {1, 2, 3, 5}
+
+	//// Test Case 10: Array with k = 1
+	//int arr10[] = { 7, 3, 9, 1, 5, 4 };
+	//int n10 = 6, k10 = 1;
+	//sortK(arr10, n10, k10);
+	//printf("Test 10: ");
+	//printArr(arr10, n10); // Expected: {1, 3, 4, 5, 7, 9}
+
+	// 4
+	//int arr1[] = { 1, 6, 3, 9, 6, 7 };
+	//int n1 = 6, k1 = 3;
+	//printf("Sum of %d smallest elements: %d\n", k1, findKSmallestSum(arr1, n1, k1));
+	//// Expected Output: 10 (1 + 3 + 6)
+
+	//int arr2[] = { 5, 4, 3, 2, 1 };
+	//int n2 = 5, k2 = 2;
+	//printf("Sum of %d smallest elements: %d\n", k2, findKSmallestSum(arr2, n2, k2));
+	//// Expected Output: 3 (1 + 2)
+
+	// 5
+	//int arr[] = { 1,6,3,8,2 };
+	//int n = 5;
+	//sortDecending(arr, n);
+	//printArr(arr, n);
+	return 0;
+}