2AKIFT POS Test (Group A)

2022-06-09

Max. 32 points

Name:

Task Max. Achieved
1 4
2 12
3 9
4 7
Sum 32
Benotung: <16: 5, 16-20: 4, 21-24: 3, 25-28: 2, 29-32: 1
  1. Answer the following statements indicating whether they are True or False.
    0-4 correct: 0 points, 5 correct: 1 point, 6 correct: 2 points, 7 correct: 3 points, 8 correct: 4 points.
    Statement True False
    Der mit malloc(.) reservierte Speicher muss manuell mittels Aufruf von free(.) freigegeben werden.
    Dynamische Speicherverwaltung in C is notwendig, um den gesamten vorhandenen Hauptspeicher nutzen zu können.
    Speicher für einen Array kann mit malloc(.) nicht reserviert werden.
    Dynamisch wachsende Arrays stehen in C auch ohne dynamische Speicherverwaltung zur Verfügung.
    Der Rückgabewert von malloc(.) ist void*.
    In C kann der gleiche Funktionsname mehrfach mit unterschiedlichen Parametern definiert werden.
    Die C++ Standard Template Library (STL) stellt mitunter Container Datentypen wie string und vector zur Verfügung.
    C++ Templates erlauben es, eine Funktion nur einmal zu definieren und sie dennoch mit unterschiedlichen Datentypen der Parameter zu verwenden.
  2. Welcher Text wird durch die folgenden Code Snippets in der C++-Programmiersprache auf Standard Output (Terminal) geschrieben? Schreibe den genauen Output des Snippets. Die Snippets werden als Teil von int main(.) ausgeführt und alle notwendigen #includes sind vorhanden. Wenn das Snippet nicht kompilierbar ist oder zu einem Absturz führen würde, so ist das Wort “ERROR” als Antwort zu geben. Erzeugt das Snippet keinen Output (wenn beispielsweise kein printf oder dergleichen aufgerufen wird), so ist "-" als richtige Antwort zu verwenden.
    1. std::vector<std::string> names = {"Pat", "Chris", "Sue", "Steve"};
      for (const auto& name : names) {
      std::cout << name << " ";
      }
      Pat Chris Sue Steve
    2. std::vector<int> values = {1, 2, 3};
      for (auto it = values.rbegin(); it != values.rend(); it++) {
      std::cout << *it << std::endl; // dereference the iterator
      }
      3
      2
      1
    3. int array[] = {1, 2, 3, 4};
      int* array_ptr = array;
      int count = sizeof(array) / sizeof(int);
      int value = 0;
      while (count--) {
      value += *array_ptr++;
      }
      printf("%d\n", value);
      10
    4. char str[] = "students";
      char* haystack = str;
      char needle = 's';
      int occ = 0;
      while (*haystack) {
      if (*haystack == needle) { occ++; }
      haystack++;
      }
      printf("%d\n", occ);
      2
    5. typedef struct treenode TreeNode;
      struct treenode {int value; TreeNode *left; TreeNode *right;};
      TreeNode *node = (TreeNode*) malloc(sizeof(TreeNode));
      node->value = 123; node->left=NULL; node->right=NULL;
      printf("%d\n", node->value);
      123
    6. std::vector<int> values = {1, 2, 3};
      values.push_back(4);
      for (const auto& value: values) {
      std::cout << value << ' ';
      }
      1 2 3 4
  3. C Programmierung
    Gegeben ist folgender struct
    struct intarray {
    size_t reserved; // available storage
    size_t elements; // current number of elements
    int* array;
    };
    Erstelle einen Typen IntArray, mit dem Instanzen von struct intarray erstellt werden können. Implementiere die Funktion IntArray* ia_create(), welche einen neuen IntArray zurück gibt, dessen array Platz für 100 Elemente hat. Setze den Wert von reserved auf 100 und den Wert von elements auf 0.
    Implementiere weiters die Funktion size_t ia_count(IntArray* ia, int elem), welche zurück gibt, wie oft elem in ia->array enthalten ist.
    1 Punkt für den Typedef
    1 Punkt für beide korrekten Funktionsnamen und Signaturen
    1 Punkt für das Reservieren von Speicher für IntArray
    1 Punkt für das Reservieren von Speicher für array
    1 Punkt für das korrekte Anpassen von reserved und elements
    1 Punkt für das korrekte Ermitteln von count
    1 Punkt für die dafür notwendige Schleife
    je 1 Punkt für beide korrekten Rückgabewerte
    typedef struct intarray IntArray;

    IntArray* ia_create() {
    IntArray* ia = (IntArray*) malloc(sizeof(IntArray));
    ia->reserved = 100;
    ia->elements = 0;
    ia->array = (int*) malloc(ia->reserved * sizeof(int));
    return ia;
    }

    size_t ia_count(IntArray* ia, int elem) {
    size_t count = 0;
    for (size_t i = 0; i < ia->elements; ++i) {
    if (ia->array[i] == elem) count++;
    }
    return count;
    }
  4. C++ Programmierung
    Implementiere die Funktion std::pair<double, double> quadratic(double a, double b, double c) welche die quadratische Gleichung mit den Koeffizienten a, b und c löst und die beiden Nullstellen x1 und x2 als std::pair zurückgibt. Wer std::pair lieber nicht verwenden möchte, kann auch einen eigenen struct für diesen Zweck implementieren, um beide Werte zurückgeben zu können. In diesem Fall muss natürlich die Signatur der Funktion quadratic angepasst werden.
    Die Formel für quadratische Gleichungen lautet x1,2=b±b24ac2a. Es kann die Funktion sqrt verwendet werden. Auf komplexe Zahlen braucht keine Rücksicht genommen zu werden.
    1 Punkt den korrekten Funktionsnamen und die korrekte Signatur
    2 Punkte für korrektes Handling von std::pair oder Deklaration und Verwendung des Structs inkl. anpassen der Signatur
    1 Punkt für die Berechnung der Wurzel
    je 1 Punkt für die Berechnung von x1 und x2
    1 Punkt für die Rückgabe der beiden korrekten Werte
    std::pair<double, double> quadratic(double a, double b, double c) {
    double root(sqrt(b * b - 4 * a * c));
    double x1((-b + root) / (2 * a));
    double x2((-b - root) / (2 * a));
    std::pair<double, double> result(x1, x2);
    return result;
    }