Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » aud » Lösungsversuch   (Übersicht)

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige ÜberarbeitungVorherige Überarbeitung
Nächste Überarbeitung		Vorherige Überarbeitung
Letzte ÜberarbeitungBeide Seiten, nächste Überarbeitung
pruefungen:bachelor:aud:loesungss17 [19.10.2017 18:24] – solution 3a,b added jonpostpruefungen:bachelor:aud:loesungss17 [24.07.2019 14:44] – Kleine Verbesserung in Aufgabe 6b) + Formatierung angepasst. dom
Zeile 7: Zeile 7:
 **b)** 2 und 3 **b)** 2 und 3
  
-**c)** 2 und 4+**c)** 4
  
 **d)** 2 und 4 **d)** 2 und 4
Zeile 25: Zeile 25:
   * zu 4)   * zu 4)
     *=>  Eine endrekursive Methode kann unmittelbar entrekursiviert werden.     *=>  Eine endrekursive Methode kann unmittelbar entrekursiviert werden.
 +   * zu c) 
 +    *=>  Laufzeit ist O(log(n))
  
 ==== Aufgabe 2 Suchen und O-Kalkül ==== ==== Aufgabe 2 Suchen und O-Kalkül ====
Zeile 107: Zeile 108:
          
     return r;     return r;
 +}
 +</code>
 +
 +<code java>
 +static KTree fromPostfix(LinkedList<KOp> postfix) {
 +    Stack<KTree> s = new Stack<>();
 +    for(KOp o : postfix) {
 +        switch(o) {
 +            case AND:
 +            case OR:
 +                KTree r = s.pop();
 +                KTree l = s.pop();
 +                s.push(new KTree(o, l, r));
 +                break;
 +            case NOT:
 +                s.push(new KTree(o, s.pop()));
 +                break;
 +            default:
 +                s.push(new KTree(o));
 +        }
 +    }
 +    return s.pop();
 +}
 +</code>
 +
 +====Aufgabe 4 Listen ===
 +**a)**
 +<code java>
 +public boolean contains(E e) {
 +    Node cur = head;
 +    for(int l = LEVELS - 1; l >= 0; l--) {
 +        while(cur.next[l] != null && cur.next[l].e.compareTo(e) <= 0) {
 +            if(cur.next[l].e.compareTo(e) == 0) {
 +                return true;
 +            }
 +            cur = cur.next[l];
 +        }
 +    }
 +    return false;
 +}
 +</code>
 +
 +**b)**
 +<code java>
 +private Node[] getPred(E e) {
 +    Node[] last = (Node []) Array.newInstance(Node.class, LEVELS);
 +    Node cur = head;
 +    for(int l = LEVELS - 1; l >= 0; l--) {
 +        while(cur.next[l] != null && cur.next[l].e.compareTo(e) < 0) {
 +            cur = cur.next[l];
 +        }
 +        last[l] = cur;
 +    }
 +    return last;
 +}
 +</code>
 +
 +**c)**
 +<code java>
 +public boolean insert(E e) {
 +    Node newN = new Node(e);
 +    int newL = getRandomLevel();
 +    if(contains(e)) {
 +        return false;
 +    }
 +    Node[] pred = getPred(e);
 +    for(int l = newL; l >= 0; l--) {
 +        newN.next[l] = pred[l].next[l];
 +        pred[l].next[l] = newN;
 +    }
 +    return true;
 +}
 +
 +public boolean delete(E e) {
 +    if(!contains(e)) {
 +        return false;
 +    }
 +    Node[] pred = getPred(e);
 +    for(int l = LEVELS - 1; l >= 0; l--) {
 +        if(pred[l].next[l] != null) {
 +            pred[l].next[l] = pred[l].next[l].next[l];
 +        }
 +    }
 +    return true;
 +}
 +</code>
 +
 +====Aufgabe 5 ADT====
 +**a)**
 +
 +as2gh(Create, Create, k) = Node(New, k)
 +
 +as2gh(Add(n, ns), as, k) = Edge(as2gh(ns, as, k), k, n)
 +
 +as2gh(Create, Add(ns, as), k) = Node(as2gh(ns, as, k+1), k)
 +
 +**b)**
 +
 +flatten(Add(Create, as)) = flatten(as)
 +
 +flatten(Add(Add(n, ns), as)) = Add(n, flatten(Add(ns, as)))
 +
 +**c)**
 +
 +as2af(as) = as2afh(length(as)+1, as, flatten(as))
 +
 +as2afh(si, Create, af)) = Add(si, af)
 +
 +as2afh(si, Add(ns, as), af) = Add(si, as2afh(si+length(ns), as, af))
 +
 +====Aufgabe 6 Graphen====
 +**a)**
 +<code java>
 +boolean isSafe(boolean g[][], int cs[], int v, int c) {
 +    for (int n = 0; n < g.length; n++) {
 +        if (g[v][n] == true && c == cs[n]) {
 +             // Kante vorhanden und Farbe bereits vergeben
 +            return false;
 +        }
 +    }
 +    return true;
 +}
 +</code>
 +**b)**
 +<code java>
 +boolean helper(boolean g[][], int cs[], int m, int v) {
 +    // base case
 +    if (v >= g.length) {
 +        return true;
 +    }
 +    
 +    // try different colors for vertex v
 +    for (int c = 1; c <= m; c++) {
 +        if (isSafe(g, cs, v, c)) {
 +            int color = cs[v];  // aktuelle Farbe sichern
 +            cs[v] = c;  // neue Farbe setzen 
 +            
 +            if (helper(g, cs, c, v + 1)) { // Rekursion
 +                return true;
 +            }
 +            // backtrack
 +            cs[v] = color;
 +        }
 +    }
 +    // keine Loesung gefunden -> Schritt zurueck
 +    return false;
 +}
 +</code>
 +
 +**c)**
 +<code java>
 +int[] color(boolean g[][], int m) {
 +    int[] cs = new int[g.length];
 +    
 +    if (!helper(g, cs, m, 0)) {
 +        return null;
 +    }
 +    return cs;
 } }
 </code> </code>