Write a program to find the index of an integer in an array. Assume that the array size is 50. The program will read the array elements first and then input an integer to search in the array. If the integer appears more than one time in the array, give the index for the first appearance of this integer. If the integer does not appear in the array, print “Not found”. The input has -1 as the end, but -1 is not saved in the array.

Here is a sample implementation of binary search in C: ``` #include <stdio.h> int binarySearch(int arr[], int left, int right, int key) { while (left <= right) { int mid = (left + right) / 2; if (arr[mid] == key) { return mid; } else if (arr[mid] < key) { left = mid + 1; } else { right = mid - 1; } } return -1; } int main() { int arr[] = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int n = sizeof(arr) / sizeof(arr[0]); int key = 12; int index = binarySearch(arr, 0, n - 1, key); if (index == -1) { printf("Element not found\n"); } else { printf("Element found at index %d\n", index); } return 0; } ``` In this implementation, `binarySearch()` takes four arguments: the array to search `arr`, the left and right indices of the subarray to search `left` and `right`, and the key to search for `key`. It returns the index of the key in the array if it is found, or `-1` if it is not found. The function works by repeatedly dividing the subarray in half using the middle index `mid`, comparing the key to the element at `arr[mid]`, and adjusting the left and right indices accordingly until the key is found or the subarray is exhausted. In the `main()` function, we test the `binarySearch()` function by searching for the key `12` in the array `arr`. If the key is found, we print its index; otherwise, we print a message indicating that the element was not found.

``` #include <stdio.h> #include <stdlib.h> #define BACKING_STORE_SIZE 128 #define PAGE_SIZE 32 #define NUM_PAGES 4 #define NUM_FRAMES 8 #define FRAME_SIZE 32 #define PHYSICAL_MEMORY_SIZE NUM_FRAMES * FRAME_SIZE int page_table[NUM_PAGES]; unsigned char backing_store[BACKING_STORE_SIZE]; unsigned char physical_memory[PHYSICAL_MEMORY_SIZE]; void load_page(int page_num, int frame_num) { int byte_offset = page_num * PAGE_SIZE; int frame_offset = frame_num * FRAME_SIZE; for (int i = 0; i < PAGE_SIZE; i++) { physical_memory[frame_offset + i] = backing_store[byte_offset + i]; } } int main() { FILE *la_file = fopen("la.txt", "r"); FILE *pdata_file = fopen("pdata.bin", "rb"); if (la_file == NULL || pdata_file == NULL) { printf("Error opening file\n"); return 1; } // populate backing store with process data fread(backing_store, sizeof(unsigned char), BACKING_STORE_SIZE, pdata_file); // initialize page table for (int i = 0; i < NUM_PAGES; i++) { page_table[i] = -1; } // read logical addresses from file int logical_address; while (fscanf(la_file, "%d", &logical_address) != EOF) { // calculate page number and offset int page_num = logical_address / PAGE_SIZE; int page_offset = logical_address % PAGE_SIZE; // check if page is in memory if (page_table[page_num] != -1) { int frame_num = page_table[page_num]; int physical_address = (frame_num * FRAME_SIZE) + page_offset; printf("Logical address: %d, Physical address: %d, Data: %c\n", logical_address, physical_address, physical_memory[physical_address]); } else { // find a free frame in physical memory int free_frame = -1; for (int i = 0; i < NUM_FRAMES; i++) { if (page_table[i] == -1) { free_frame = i; break; } } // if no free frame is found, use a random one (for simplicity) if (free_frame == -1) { free_frame = rand() % NUM_FRAMES; page_table[free_frame] = -1; } // load page into free frame load_page(page_num, free_frame); page_table[page_num] = free_frame; // print physical address int physical_address = (free_frame * FRAME_SIZE) + page_offset; printf("Logical address: %d, Physical address: %d, Data: %c\n", logical_address, physical_address, physical_memory[physical_address]); } } fclose(la_file); fclose(pdata_file); return 0; } ```