🎉

Author: pl3onasm

Diff for: IP-Finals/2017resit/problem3/prob3.c

@@ -16,47 +16,38 @@ void *safeMalloc (int n) {
   return ptr;
 }
 
-int *copySubArray(int left, int right, int arr[]) {
-  int i, *copy = safeMalloc((right - left)*sizeof(int));
-  for (i=left; i < right; i++) {
+int *copySubArray(int *arr, int left, int right) {
+  /* copies the subarray arr[left..right] into a new array */
+  int *copy = safeMalloc((right - left) * sizeof(int));
+  for (int i = left; i < right; i++) 
     copy[i - left] = arr[i];
-  }
   return copy;
 }
 
-void mergeSort(int length, int arr[]) {
-  int l, r, mid, idx, *left, *right;
-  if (length <= 1) {
-    return;
-  }
-  mid = length/2;
-  left = copySubArray(0, mid, arr);
-  right = copySubArray(mid, length, arr);
-  mergeSort(mid, left);
-  mergeSort(length - mid, right);
-  idx = 0;
-  l = 0;
-  r = 0;
-  while ((l < mid) && (r < length - mid)) {
-    if (left[l] < right[r]) {
-      arr[idx] = left[l];
-      l++;
-    } else {
-      arr[idx] = right[r];
-      r++;
-    }
-    idx++;
-  }
-  while (l < mid) {
-    arr[idx] = left[l];
-    idx++;
-    l++;
-  }
-  while (r < length - mid) {
-    arr[idx] = right[r];
-    idx++;
-    r++;
+void mergeSort(int *arr, int length) {
+  /* sorts an array of integers in O(n log n) time */
+  int l = 0, r = 0, idx = 0, mid = length/2;
+  if (length <= 1) return;
+  
+  int *left = copySubArray(arr, 0, mid);
+  int *right = copySubArray(arr, mid, length);
+
+  mergeSort(left, mid);
+  mergeSort(right, length - mid);
+  
+  while (l < mid && r < length - mid) {
+    if (left[l] < right[r]) 
+      arr[idx++] = left[l++];
+    else 
+      arr[idx++] = right[r++];
   }
+
+  while (l < mid)
+    arr[idx++] = left[l++];
+
+  while (r < length - mid) 
+    arr[idx++] = right[r++];
+
   free(left);
   free(right);
 }
@@ -74,8 +65,8 @@ int main(int argc, char *argv[]) {
   (void)! scanf("%d", &n);
   int *arr1 = readInput(n);
   int *arr2 = readInput(n);
-  mergeSort(n, arr1);
-  mergeSort(n, arr2);
+  mergeSort(arr1, n);
+  mergeSort(arr2, n);
   for (int i=0; i < n; ++i) {
     if (arr1[i] != arr2[i]) {
       printf("NO\n");

Diff for: IP-Finals/2018/problem3/prob3-1.c

@@ -26,47 +26,38 @@ void* safeRealloc(void* ptr, int n) {
   return ptr;
 }
 
-int *copySubArray(int left, int right, int arr[]) {
-  int i, *copy = safeMalloc((right - left)*sizeof(int));
-  for (i=left; i < right; i++) {
+int *copySubArray(int *arr, int left, int right) {
+  /* copies the subarray arr[left..right] into a new array */
+  int *copy = safeMalloc((right - left) * sizeof(int));
+  for (int i = left; i < right; i++) 
     copy[i - left] = arr[i];
-  }
   return copy;
 }
 
-void mergeSort(int length, int arr[]) {
-  int l, r, mid, idx, *left, *right;
-  if (length <= 1) {
-    return;
-  }
-  mid = length/2;
-  left = copySubArray(0, mid, arr);
-  right = copySubArray(mid, length, arr);
-  mergeSort(mid, left);
-  mergeSort(length - mid, right);
-  idx = 0;
-  l = 0;
-  r = 0;
-  while ((l < mid) && (r < length - mid)) {
-    if (left[l] < right[r]) {
-      arr[idx] = left[l];
-      l++;
-    } else {
-      arr[idx] = right[r];
-      r++;
-    }
-    idx++;
-  }
-  while (l < mid) {
-    arr[idx] = left[l];
-    idx++;
-    l++;
-  }
-  while (r < length - mid) {
-    arr[idx] = right[r];
-    idx++;
-    r++;
+void mergeSort(int *arr, int length) {
+  /* sorts an array of integers in O(n log n) time */
+  int l = 0, r = 0, idx = 0, mid = length/2;
+  if (length <= 1) return;
+  
+  int *left = copySubArray(arr, 0, mid);
+  int *right = copySubArray(arr, mid, length);
+
+  mergeSort(left, mid);
+  mergeSort(right, length - mid);
+  
+  while (l < mid && r < length - mid) {
+    if (left[l] < right[r]) 
+      arr[idx++] = left[l++];
+    else 
+      arr[idx++] = right[r++];
   }
+
+  while (l < mid)
+    arr[idx++] = left[l++];
+
+  while (r < length - mid) 
+    arr[idx++] = right[r++];
+
   free(left);
   free(right);
 }
@@ -107,7 +98,7 @@ int main(int argc, char **argv){
   int size=10, target; 
   (void)! scanf("%d\n", &target);
   int *vec = readIntVector(&size); 
-  mergeSort(size, vec);
+  mergeSort(vec, size);
   getPairs(vec, size, target); 
   free(vec); 
   return 0; 

Diff for: IP-Finals/2018resit/problem3/prob3-1.c

@@ -53,7 +53,7 @@ int bubbleCount(int *arr, int len) {
         ++count; 
       }
     }
-    if (change == 0) break;
+    if (!change) break;
   }
   return count;
 }

Diff for: IP-Finals/2018resit/problem3/prob3-2.c

@@ -21,53 +21,43 @@ void *safeMalloc (int n) {
   return ptr;
 }
 
-int *copySubArray(int left, int right, int arr[]) {
-  int i, *copy = safeMalloc((right - left)*sizeof(int));
-  for (i=left; i < right; i++) {
+int *copySubArray(int *arr, int left, int right) {
+  /* copies the subarray arr[left..right] into a new array */
+  int *copy = safeMalloc((right - left)*sizeof(int));
+  for (int i = left; i < right; i++) 
     copy[i - left] = arr[i];
-  }
   return copy;
 }
 
-int mergeSort(int length, int arr[]) {
-  int l, r, mid, idx, *left, *right;
-  if (length <= 1) {
-    return 0;
-  }
-  mid = length/2;
-  left = copySubArray(0, mid, arr);
-  right = copySubArray(mid, length, arr);
-  int count = mergeSort(mid, left);
-  count += mergeSort(length - mid, right);
-  idx = 0;
-  l = 0;
-  r = 0;
-  while ((l < mid) && (r < length - mid)) {
-    if (left[l] <= right[r]) {
-      // no inversions in this case
-      arr[idx] = left[l];
-      l++;
-    } else {
-      // total number of inversions to add is the number of
-      // elements currently left in the left array: mid - l
-      arr[idx] = right[r];
-      r++; count += mid - l;
+int countInversions(int *arr, int length) {
+  /* sorts an array of integers in O(n log n) time */
+  int l = 0, r = 0, idx = 0, mid = length/2, count = 0;
+  if (length <= 1) return 0;
+  
+  int *left = copySubArray(arr, 0, mid);
+  int *right = copySubArray(arr, mid, length);
+
+  count += countInversions(left, mid);
+  count += countInversions(right, length - mid);
+  
+  while (l < mid && r < length - mid) {
+    if (left[l] <= right[r])    // no inversions in this case
+      arr[idx++] = left[l++];
+    else {                      // total number of inversions to add               
+      arr[idx++] = right[r++];  // is the number of elements currently 
+      count += mid - l;         // left in the left subarray: mid - l
     }
-    idx++;
-  }
-  while (l < mid) {
-    arr[idx] = left[l];
-    idx++;
-    l++;
-  }
-  while (r < length - mid) {
-    arr[idx] = right[r];
-    idx++;
-    r++;
   }
+
+  while (l < mid)
+    arr[idx++] = left[l++];
+
+  while (r < length - mid) 
+    arr[idx++] = right[r++];
+
   free(left);
   free(right);
-  return count; 
+  return count;
 }
 
 int *readIntVector (int size) {
@@ -81,7 +71,7 @@ int main(int argc, char **argv){
   int size; 
   (void)! scanf("%d\n", &size);
   int *vect = readIntVector(size); 
-  printf("%d\n", mergeSort(size, vect));
+  printf("%d\n", countInversions(vect, size));
   free(vect); 
   return 0; 
 }

Diff for: IP-Finals/2019/problem4/prob4-1.c

@@ -26,48 +26,38 @@ void createArray (int **arr, int len) {
   *arr = safeCalloc(len, sizeof(int));
 }
 
-int *copySubArray(int left, int right, int arr[]) {
-  int i, *copy;
-  copy = safeCalloc((right - left), sizeof(int));
-  for (i=left; i < right; i++) {
+int *copySubArray(int *arr, int left, int right) {
+  /* copies the subarray arr[left..right] into a new array */
+  int *copy = safeCalloc((right - left), sizeof(int));
+  for (int i = left; i < right; i++) 
     copy[i - left] = arr[i];
-  }
   return copy;
 }
 
-void mergeSort(int length, int arr[]) {
-  int l, r, mid, idx, *left, *right;
-  if (length <= 1) {
-    return;
-  }
-  mid = length/2;
-  left = copySubArray(0, mid, arr);
-  right = copySubArray(mid, length, arr);
-  mergeSort(mid, left);
-  mergeSort(length - mid, right);
-  idx = 0;
-  l = 0;
-  r = 0;
-  while ((l < mid) && (r < length - mid)) {
-    if (left[l] < right[r]) {
-      arr[idx] = left[l];
-      l++;
-    } else {
-      arr[idx] = right[r];
-      r++;
-    }
-    idx++;
-  }
-  while (l < mid) {
-    arr[idx] = left[l];
-    idx++;
-    l++;
-  }
-  while (r < length - mid) {
-    arr[idx] = right[r];
-    idx++;
-    r++;
+void mergeSort(int *arr, int length) {
+  /* sorts an array of integers in O(n log n) time */
+  int l = 0, r = 0, idx = 0, mid = length/2;
+  if (length <= 1) return;
+  
+  int *left = copySubArray(arr, 0, mid);
+  int *right = copySubArray(arr, mid, length);
+
+  mergeSort(left, mid);
+  mergeSort(right, length - mid);
+  
+  while (l < mid && r < length - mid) {
+    if (left[l] < right[r]) 
+      arr[idx++] = left[l++];
+    else 
+      arr[idx++] = right[r++];
   }
+
+  while (l < mid)
+    arr[idx++] = left[l++];
+
+  while (r < length - mid) 
+    arr[idx++] = right[r++];
+
   free(left);
   free(right);
 }
@@ -104,7 +94,7 @@ int main(int argc, char *argv[]) {
   createArray (&sorted, n);
   processInput (series, sorted, n);
 
-  mergeSort (n, sorted);
+  mergeSort (sorted, n);
   printArray (series, sorted, n, k);
   free(series);
   free(sorted);