Uebung 5/Uebung5_3/Makefile

@@ -1,52 +0,0 @@
-
-# Name of the binary for Development
-BINARY = main
-# Name of the binary for Release
-FINAL = prototyp
-# Object files
-OBJS   = backpack.o item.o main.o
-# Compiler flags
-CFLAGS = -Werror -Wall -std=c++17 -fsanitize=address,undefined -g
-# Linker flags
-LFLAGS = -fsanitize=address,undefined
-#Which Compiler to use
-COMPILER = c++
-
-
-# all target: builds all important targets
-all: binary
-
-final : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${FINAL} ${OBJS}
-	rm ${OBJS}
-
-binary : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
-
-# Links the binary
-${BINARY} : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
-
-
-# Compiles a source-file (any file with file extension .c) into an object-file
-#
-# "%" is a wildcard which matches every file-name (similar to * in regular expressions)
-# Such a rule is called a pattern rule (because it matches a pattern, see https://www.gnu.org/software/make/manual/html_node/Pattern-Rules.html),
-# which are a form of so called implicit rules (see https://www.gnu.org/software/make/manual/html_node/Implicit-Rules.html)
-# "$@" and "$<" are so called automatic variables (see https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html)
-%.o : %.cpp
-	${COMPILER} -c ${CFLAGS} -o $@ $<
-
-
-# Rules can not only be used for compiling a program but also for executing a program
-run: ${BINARY}
-	./${BINARY}
-
-
-# Delete all build artifacts
-clean :
-	rm -rf ${BINARY} ${OBJS}
-
-
-# all  and clean are a "phony" targets, meaning they are no files
-.PHONY : all clean

Uebung 5/Uebung5_3/backpack.cpp

@@ -1,91 +0,0 @@
-#include "backpack.h"
-#include <algorithm>
-#include <cmath>
-
-/*  Optimized insertion sort algorithm utilizing the Item's getRatio() function
- */
-void Backpack::sortAvailableItems() {
-  int i = 0;
-  while (i < (int)this->availableItems.size()) {
-    Item x = this->availableItems[i];
-    int j = i - 1;
-    while (j >= 0 && this->availableItems[j].getRatio() < x.getRatio()) {
-      this->availableItems[j + 1] = this->availableItems[j];
-      j--;
-    }
-    this->availableItems[j + 1] = x;
-    i++;
-  }
-}
-
-/*  Iterates through all packed items and returns the total value   */
-int Backpack::getValuePacked() {
-  int total = 0;
-  for (int i = 0; i < (int)this->packedItems.size(); i++) {
-    total += this->packedItems[i].value;
-  }
-  return total;
-}
-
-/*  the algorithm to pack the backpack  */
-void Backpack::greedyPack(bool continuous) {
-  this->packedItems
-      .clear(); /*  resets the packedItems -> removes all elements! */
-  this->currentWeight = 0; /*  ...and also sets the current weight to 0.0  */
-
-  this->sortAvailableItems(); //  sort the available items first!
-  const char *text = "";
-  float partialValue = 0.0f;
-  float partialWeight = 0.0f;
-  if (!continuous) {
-    text = "non-";
-  }
-  std::cout << "Backpack has been packed " << text
-            << "continuously:\n";                                 //  output
-  std::cout << "\t\tWeight\tValue\n";                             //  output
-  std::cout << "---------------------------------------------\n"; //  output
-
-  for (int i = 0; i < (int)this->availableItems.size();
-       i++) { //  iterate through all available items
-    if (this->currentWeight + (float)this->availableItems[i].weight <=
-        this->maxWeight) { //  check if the item still fits in the backpack
-      this->packedItems.push_back(
-          this->availableItems[i]); //  and if so, put it in there (by adding it
-                                    //  to this->packedItems)
-      currentWeight +=
-          this->availableItems[i].weight; //  adjust currentWeight accordingly
-      std::cout << "\t" << this->availableItems[i].name << ":\t"
-                << this->availableItems[i].weight << "\t"
-                << this->availableItems[i].value
-                << "\t Factor: 1.00\n"; //  output
-    } else if (continuous) {
-      float factor = (float)(this->maxWeight - this->currentWeight) /
-                     this->availableItems[i].weight;
-      factor = std::round(factor * 100) / 100;
-      std::cout << "\t" << this->availableItems[i].name << ":\t"
-                << this->availableItems[i].weight << "\t"
-                << this->availableItems[i].value << "\t Factor: " << factor
-                << std::endl;
-      partialWeight = this->availableItems[i].weight * factor;
-      partialValue = this->availableItems[i].value * factor;
-      break;
-    }
-    if ((this->currentWeight - this->maxWeight) ==
-        0) { //  if the backpack is completely full, the loop can be exited -
-             //  small optimization
-      break;
-    }
-  }
-  std::cout << "---------------------------------------------\n"; //  output
-  std::cout << "\tTotal:\t" << this->currentWeight + partialWeight << "\t"
-            << this->getValuePacked() + partialValue << "\n"; //  output
-}
-
-void Backpack::printItems() {
-  for (int i = 0; i < (int)this->availableItems.size(); i++) {
-    std::cout << this->availableItems[i].name << "\t"
-              << this->availableItems[i].weight << "\t"
-              << this->availableItems[i].value << "\t"
-              << this->availableItems[i].getRatio() << "\n";
-  }
-}

Uebung 5/Uebung5_3/backpack.h

@@ -1,31 +0,0 @@
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "item.h"
-
-#pragma once
-
-/*  Class for Backpack, consisting of a maxWeight that can be put into a
-   backpack, one that shows the weight that is currently in the backpack, a
-   vector representing all available items and a vector for the items that have
-   been placed in the backpack. There is also a constructor to increase the
-   ease/convenience of use, as well as functions to:
-        * sort the available Items based on their getRatio()
-        * greedily pack the backpack
-        * get the value of all packed items
-*/
-struct Backpack {
-  int maxWeight;
-  std::vector<Item> availableItems;
-  int currentWeight;
-  std::vector<Item> packedItems;
-
-  Backpack(float maxWeight, std::vector<Item> availableItems)
-      : maxWeight(maxWeight), availableItems(availableItems),
-        currentWeight(0){};
-  void sortAvailableItems();
-  void greedyPack(bool continuous);
-  int getValuePacked();
-  void printItems();
-};

Uebung 5/Uebung5_3/item.cpp

@@ -1,5 +0,0 @@
-#include "item.h"
-
-/*  function that returns the value/weight ratio of an item as float; used to
- * sort items    */
-float Item::getRatio() { return ((float)this->value / (float)this->weight); };

Uebung 5/Uebung5_3/item.h

@@ -1,17 +0,0 @@
-#include <string>
-
-#pragma once
-
-/*  Class for Item, containing name (string), value (int) and weight (int).
-    There is also a constructor that can be called with all member variables to
-    increase convenience. The getRatio() function returns the value/weight ratio
-*/
-class Item {
-public:
-  std::string name;
-  int weight;
-  int value;
-  Item(std::string name, int weight, int value)
-      : name(name), weight(weight), value(value){};
-  float getRatio();
-};

Uebung 5/Uebung5_3/main.cpp

@@ -1,15 +0,0 @@
-#include "backpack.h"
-#include "item.h"
-#include <vector>
-
-int main() {
-  std::vector<Item> items = {//  creation of the availableItems
-                             {"1", 5, 8},   {"2", 5, 8},   {"3", 6, 6},
-                             {"4", 8, 5},   {"5", 10, 10}, {"6", 11, 5},
-                             {"7", 12, 10}, {"8", 15, 17}, {"9", 15, 20},
-                             {"10", 30, 20}};
-  Backpack bp((float)24,
-              items);   //  creation of the backpack, utilizing the constructor
-  bp.greedyPack(false); //  greedily pack Backpack non-continuously
-  bp.greedyPack(true);  // greedily pack Backpack continuously
-}

Uebung 6/Uebung6_1/Makefile

@@ -1,52 +0,0 @@
-
-# Name of the binary for Development
-BINARY = main
-# Name of the binary for Release
-FINAL = prototyp
-# Object files
-OBJS   = mergeSortRand.o helperFunctions.o main.o
-# Compiler flags
-CFLAGS = -Werror -Wall -std=c++17 -g#-fsanitize=address,undefined -g
-# Linker flags
-LFLAGS = #-fsanitize=address,undefined
-#Which Compiler to use
-COMPILER = g++
-
-
-# all target: builds all important targets
-all: binary
-
-final : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${FINAL} ${OBJS}
-	rm ${OBJS}
-
-binary : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
-
-# Links the binary
-${BINARY} : ${OBJS}
-	${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
-
-
-# Compiles a source-file (any file with file extension .c) into an object-file
-#
-# "%" is a wildcard which matches every file-name (similar to * in regular expressions)
-# Such a rule is called a pattern rule (because it matches a pattern, see https://www.gnu.org/software/make/manual/html_node/Pattern-Rules.html),
-# which are a form of so called implicit rules (see https://www.gnu.org/software/make/manual/html_node/Implicit-Rules.html)
-# "$@" and "$<" are so called automatic variables (see https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html)
-%.o : %.cpp
-	${COMPILER} -c ${CFLAGS} -o $@ $<
-
-
-# Rules can not only be used for compiling a program but also for executing a program
-run: ${BINARY}
-	./${BINARY}
-
-
-# Delete all build artifacts
-clean :
-	rm -rf ${BINARY} ${OBJS}
-
-
-# all  and clean are a "phony" targets, meaning they are no files
-.PHONY : all clean

Uebung 6/Uebung6_1/helperFunctions.cpp

@@ -1,20 +0,0 @@
-#include "helperFunctions.h"
-#include <ctime>
-
-void printArray(int* array, int arrayLength, std::string heading) {
-    std::cout << "========== " << heading << " ==========" << std::endl;
-    for(int i = 0; i < arrayLength; i++) {
-        if(i > 0) {
-            std::cout << " - ";
-        }
-        std::cout << array[i];
-    }
-    std::cout << std::endl << "==============================================" << std::endl;
-}
-
-void generateRandomIntArray(int* array, int arrayLength) {
-    std::srand(std::time(NULL));
-    for(int i = 0; i < arrayLength; i++) {
-        array[i] = rand() % 100000 + 1;
-    }
-}

Uebung 6/Uebung6_1/helperFunctions.h

@@ -1,7 +0,0 @@
-#include <string>
-#include <iostream>
-
-#pragma once
-
-void generateRandomIntArray(int* array, int arrayLength);
-void printArray(int* array, int arrayLength, std::string heading);

Uebung 6/Uebung6_1/main.cpp

@@ -1,157 +0,0 @@
-#include <iostream>
-#include <string>
-
-#include "helperFunctions.h"
-#include "mergeSortRand.h"
-#include <vector>
-
-#define ARRAY_LENGTH 10
-
-class PerformanceTest {
-private:
-  double minExecutionTime;
-  double maxExecutionTime;
-  double totalExecutionTime;
-  std::string algorithmName;
-
-public:
-  PerformanceTest() {
-    this->minExecutionTime = 1000;
-    this->maxExecutionTime = 0;
-    this->totalExecutionTime = 0;
-    this->algorithmName = "";
-  };
-
-  double getMinExecutionTime() { return this->minExecutionTime; }
-
-  double getMaxExecutionTime() { return this->maxExecutionTime; }
-
-  double getTotalExecutionTime() { return this->totalExecutionTime; }
-
-  const std::string &getAlgorithmName() { return this->algorithmName; }
-
-  void setAlgorithmName(std::string name) { this->algorithmName = name; }
-
-  void processResult(std::chrono::high_resolution_clock::time_point startTime,
-                     std::chrono::high_resolution_clock::time_point endTime) {
-    std::chrono::duration<double, std::milli> duration = (endTime - startTime);
-    double execTime = duration.count();
-    this->totalExecutionTime += execTime;
-    if (execTime < this->minExecutionTime) {
-      this->minExecutionTime = execTime;
-      return;
-    } else if (execTime > this->maxExecutionTime) {
-      this->maxExecutionTime = execTime;
-      return;
-    }
-  }
-};
-
-class PerformanceComparison {
-private:
-  int *baseArray;
-  int arrayLength;
-  int testsetSize;
-  std::vector<PerformanceTest *> testResults;
-
-public:
-  PerformanceComparison(int arrayLength, int testsetSize) {
-    this->arrayLength = arrayLength;
-    this->testsetSize = testsetSize;
-    this->baseArray =
-        (int *)malloc(sizeof(int) * this->arrayLength * this->testsetSize);
-    generateRandomIntArray(this->baseArray,
-                           this->arrayLength * this->testsetSize);
-  }
-
-  ~PerformanceComparison() {
-    free(this->baseArray);
-    for (int i = 0; i < this->testResults.size(); i++) {
-      free(testResults[i]);
-    }
-  }
-
-  void runTest(int algorithm) {
-    PerformanceTest *pt = new PerformanceTest();
-    if (algorithm == 1) {
-      pt->setAlgorithmName("MergeSort");
-      for (int i = 0; i < this->testsetSize; i++) {
-        int testArray[this->arrayLength];
-        std::memcpy(testArray, this->baseArray + (this->arrayLength * i),
-                    this->arrayLength * sizeof(int));
-        auto startTime = std::chrono::high_resolution_clock::now();
-        mergeSort(testArray, 0, arrayLength - 1);
-        auto endTime = std::chrono::high_resolution_clock::now();
-        pt->processResult(startTime, endTime);
-      }
-
-    } else if (algorithm == 2) {
-      pt->setAlgorithmName("MergeSortRand");
-      for (int i = 0; i < this->testsetSize; i++) {
-        int testArray[this->arrayLength];
-        std::memcpy(testArray, this->baseArray + (this->arrayLength * i),
-                    this->arrayLength * sizeof(int));
-        auto startTime = std::chrono::high_resolution_clock::now();
-        mergeSortRand(testArray, 0, arrayLength - 1);
-        auto endTime = std::chrono::high_resolution_clock::now();
-        pt->processResult(startTime, endTime);
-      }
-    } else {
-      std::cerr << "Algorithm not recognized!" << std::endl;
-      exit(1);
-    }
-
-    this->testResults.push_back(pt);
-  };
-
-  void printComparison(int mode) {
-    if (mode == 1) {
-      std::cout << "Algorithm\t\tMIN\t\t\tMAX\t\t\tAVG\t\t\tTOTAL" << std::endl;
-      for (int i = 0; i < this->testResults.size(); i++) {
-        std::cout << this->testResults[i]->getAlgorithmName() << "\t\t"
-                  << this->testResults[i]->getMinExecutionTime() << "\t\t"
-                  << this->testResults[i]->getMaxExecutionTime() << "\t\t"
-                  << this->testResults[i]->getTotalExecutionTime() /
-                         this->testsetSize
-                  << "\t\t" << this->testResults[i]->getTotalExecutionTime()
-                  << std::endl;
-      }
-    } else if (mode == 2) {
-      std::cout << "Algorithm\tTOTAL\t\tAVG" << std::endl;
-      for (int i = 0; i < this->testResults.size(); i++) {
-        std::cout << this->testResults[i]->getAlgorithmName() << "\t\t"
-                  << this->testResults[i]->getTotalExecutionTime() << " \t\t"
-                  << this->testResults[i]->getTotalExecutionTime() /
-                         this->testsetSize
-                  << std::endl;
-      }
-    } else {
-      std::cerr << "Mode not recognized!" << std::endl;
-      exit(1);
-    }
-  }
-};
-
-int main() {
-  srand(time(0));
-  int array[ARRAY_LENGTH];
-  int array2[ARRAY_LENGTH];
-  generateRandomIntArray(array, ARRAY_LENGTH);
-  memcpy(array2, array, ARRAY_LENGTH * sizeof(int));
-  printArray(array, ARRAY_LENGTH, "Unsortiertes Array");
-  mergeSort(array, 0, ARRAY_LENGTH - 1);
-  printArray(array, ARRAY_LENGTH, "Array nach MergeSort");
-  mergeSortRand(array2, 0, ARRAY_LENGTH - 1);
-  printArray(array2, ARRAY_LENGTH, "Array nach MergeSortRand");
-  for (int i = 0; i < ARRAY_LENGTH; i++) {
-    if (array[i] != array2[i]) {
-      std::cout << "ERROR" << std::endl;
-      exit(0);
-    }
-  }
-
-  PerformanceComparison pc(10, 10000);
-  pc.runTest(1);
-  pc.runTest(2);
-  pc.printComparison(1);
-}

Uebung 6/Uebung6_1/mergeSortRand.cpp

@@ -1,62 +0,0 @@
-#include "mergeSortRand.h"
-//#include <cstdlib>
-#include <iostream>
-
-void merge(int array[], int left, int middle, int right) {
-  int n1 = middle - left + 1;
-  int n2 = right - middle;
-
-  int leftArray[n1];
-  int rightArray[n2];
-
-  for (int i = 0; i < n1; i++) {
-    leftArray[i] = array[left + i];
-  }
-  for (int j = 0; j < n2; j++) {
-    rightArray[j] = array[middle + j + 1];
-  }
-
-  int k = 0, l = 0, m = left;
-  while (k < n1 && l < n2) {
-    if (leftArray[k] <= rightArray[l]) {
-      array[m] = leftArray[k];
-      k++;
-    } else {
-      array[m] = rightArray[l];
-      l++;
-    }
-    m++;
-  }
-
-  while (k < n1) {
-    array[m] = leftArray[k];
-    k++;
-    m++;
-  }
-
-  while (l < n2) {
-    array[m] = rightArray[l];
-    l++;
-    m++;
-  }
-}
-
-void mergeSortRand(int array[], int left, int right) {
-  if (left < right) {
-    int middle = (rand() % (right - left + 1)) + left;
-    if (middle < left || middle > right) {
-      std::cout << "ERROR2" << std::endl;
-    }
-    mergeSortRand(array, left, middle);
-    mergeSortRand(array, middle + 1, right);
-    merge(array, left, middle, right);
-  }
-}
-void mergeSort(int array[], int left, int right) {
-  if (left < right) {
-    int middle = left + (right - left) / 2;
-    mergeSort(array, left, middle);
-    mergeSort(array, middle + 1, right);
-    merge(array, left, middle, right);
-  }
-}

Uebung 6/Uebung6_1/mergeSortRand.h

@@ -1,5 +0,0 @@
-#pragma once
-
-void merge(int array[], int left, int middle, int right);
-void mergeSort(int array[], int left, int right);
-void mergeSortRand(int array[], int left, int right);