Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » aud » Forendiskussionen   (Ü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:loesungss18 [02.04.2019 17:53] – andi-erlangenpruefungen:bachelor:aud:loesungss18 [31.05.2019 11:41] – SpeedyGonzalez
Zeile 7: Zeile 7:
  
 ==== Aufgabe 1 ==== ==== Aufgabe 1 ====
-  * 1.a) +  * a) 
 <code java> <code java>
 long aDP(int n) { long aDP(int n) {
Zeile 18: Zeile 18:
  
 long aDP(int n, long[] a, long[] b) { long aDP(int n, long[] a, long[] b) {
-    if(a[n] != -1) { + if(n ==0) return 1; 
-        return a[n]; + if(n == 1) return 0; 
-    } + if(a[n] == -1){ 
-    long resultA; + a[n]=aDP(n-2, a, b) + 2*bDB(n-1, a, b); 
-    if(n == 0) {  + } 
-        resultA = 1; + return a[n];
-    } else if(n == 1) { +
-        resultA = 0; +
-    } else { +
-        resultA = aDP(n-2, a, b) + 2*bDP(n-1, a, b);          //muss hier nicht a[n]=... stehen statt resultA=... +
-    } +
-    a[n] = resultA; +
-    return a[n];+
 } }
  
 long bDP(int n, long[] a, long[] b) { long bDP(int n, long[] a, long[] b) {
-    if(b[n] != -1) { + if(n ==0) return 0; 
-    return b[n]; + if(n ==1) return 1; 
-    } + if(b[n] == -1){ 
-    long resultB; + b[n]=aDP(n-1, a, b) + bDB(n-2, a, b); 
-    if(n == 0 || n == 1) { + } 
-        resultB = n; + return b[n];
-    }else { +
-        resultB = aDP(n -1, a, b) + bDP(n-2, a, b); +
-    } +
-    b[n] = resultB; +
-    return b[n];+
 } }
 </code> </code>
  
-  * 1.b) +  * b) 
 <code java> <code java>
 long aIter(int n) { long aIter(int n) {
Zeile 56: Zeile 44:
     a[1] = 0;     a[1] = 0;
     b[1] = 1;     b[1] = 1;
 +    
     for (int i = 2; i <= n; i++){     for (int i = 2; i <= n; i++){
         a[i] = a[i-2] + 2*b[i-1];         a[i] = a[i-2] + 2*b[i-1];
Zeile 64: Zeile 53:
 </code> </code>
  
-  * 2.a) +==== Aufgabe 2 ==== 
 +  * a) 
  
 ^ A    ^ B     ^ C     ^ D    ^ E      ^ Prio-Queue  ^ ^ A    ^ B     ^ C     ^ D    ^ E      ^ Prio-Queue  ^
Zeile 75: Zeile 65:
 | 0      | 10     | 5     | 9    | 8     | [ ]  |  | 0      | 10     | 5     | 9    | 8     | [ ]  | 
  
-  * 2.b) A -> C -> E -> B +  * b) A -> C -> E -> B 
-  * 2.c)+ 
 +  * c)
  
 ^ uj    ^ vi     ^ wk     ^ γj,k alt    ^ γj,i,k     ^ γj,k neu  ^ ^ uj    ^ vi     ^ wk     ^ γj,k alt    ^ γj,i,k     ^ γj,k neu  ^
Zeile 90: Zeile 81:
 |C |E |D|5|4|4| |C |E |D|5|4|4|
  
- * 3.+==== Aufgabe 3 ==== 
 <code java> <code java>
 class Schuld { class Schuld {
Zeile 99: Zeile 91:
 } }
 </code> </code>
-a)+  *a)
 <code java> <code java>
 HashMap<String, Long> deltas(List<Schuld> schulden) { HashMap<String, Long> deltas(List<Schuld> schulden) {
Zeile 109: Zeile 101:
         dAlt = dAlt == null ? 0L : dAlt;         dAlt = dAlt == null ? 0L : dAlt;
         ds.put(s.s, dAlt - s.b);              ds.put(s.s, dAlt - s.b);     
-         //muss es nicht heissen dAlt + s.b? +    
 +   
         // eingehender Betrag (zu Geldgeber):         // eingehender Betrag (zu Geldgeber):
         dAlt = ds.get(s.g);         dAlt = ds.get(s.g);
-        dAlt = dAlt == null ? 0L +        dAlt = dAlt == null ? 0L : dAlt;
-                                    : dAlt;+
         ds.put(s.g, dAlt + s.b);            ds.put(s.g, dAlt + s.b);   
-        //muss es nicht heissen dAlt - s.b? +        
-        // Z.B. ist A Geldgeber ggü. B und D, gibt also 60. Ist ggü. C Schuldner in Höhe von 10. +        //Anmerkung: A ist z.B. Schuldner gegenueber B und D und Geldgeber gegenueber C (s.Zeile 2 S.6)!
-        //Laut der Angabe ist ∆A: -50, mit den hier Im Lösungsvorschlag angegebenen Vorzeichen würde sich für +
-        // ∆A aber +50 ergeben wenn ich mich nicht täusche. +
-        //Anmerkung: du taeuscht dich, A ist Schuldner gegenueber B und D und Geldgeber gegenueber C (s.Zeile 2 S.6)!+
     }     }
     return ds;     return ds;
Zeile 125: Zeile 114:
 </code> </code>
  
-b) +  *b) 
 <code java> <code java>
 List<Schuld> minimiere(List<Schuld> schulden) { List<Schuld> minimiere(List<Schuld> schulden) {
Zeile 159: Zeile 148:
         // aktualisiere deltas von S bzw. G:         // aktualisiere deltas von S bzw. G:
         if (dmin == Math.abs(dS)) {         if (dmin == Math.abs(dS)) {
-            deltas.put(G, dG - dmin);                   // Alternative: long dNeuG = deltas.get(G) ;  dNeuG += dS; oder  dNeuG -= dmin;    deltas.put(G, dNeuG);+            deltas.put(G, dG - dmin);                   
             deltas.remove(S);             deltas.remove(S);
 +             // Alternative: long dNeuG = deltas.get(G) ;
 +            // dNeuG += dS; oder  dNeuG -= dmin; 
 +            // deltas.put(G, dNeuG);
        } else {        } else {
-            deltas.put(S, dS + dmin);                   // Alternative: long dNeuS = deltas.get(S);   dNeuS += dG; oder  dNeuS += dmin;    deltas.put(S, dNeuS);+            deltas.put(S, dS + dmin);                  
             deltas.remove(G);             deltas.remove(G);
 +             // Alternative: long dNeuS = deltas.get(S);
 +             // dNeuS += dG; oder  dNeuS += dmin;
 +             //deltas.put(S, dNeuS);
         }         }
     }     }
Zeile 169: Zeile 164:
 } }
 </code> </code>
 +
 +
 +==== Aufgabe 4 ====
  
 <code java> <code java>
-  * 4.a)+  * a)
            remove(Add(s,v1),v2) = remove (s,v2) falls v1 == v2            remove(Add(s,v1),v2) = remove (s,v2) falls v1 == v2
                                                Add(remove(s,v2),v1) sonst                                                Add(remove(s,v2),v1) sonst
                                                                                  
-  * 4.b)+  * b)
            contains(Add(s, v1), v2) = true falls v1 == v2            contains(Add(s, v1), v2) = true falls v1 == v2
                                                   contains(s,v2) sonst                                                   contains(s,v2) sonst
-  * 4.c)+  * c)
            addAll(Add(s1; v); s2) = Add(addAll(s1,s2), v)            addAll(Add(s1; v); s2) = Add(addAll(s1,s2), v)
-  * 4.d)+  * d)
            eval(Decision(v; t; f); s) = eval (t,s) falls contains(s,v) == true            eval(Decision(v; t; f); s) = eval (t,s) falls contains(s,v) == true
                                                    eval (f,s) sonst                                                    eval (f,s) sonst
-  * 4.e)+  * e)
            collect(Decision(v; t; f)) = Add(addAll(collect(t), collect(f)),v)            collect(Decision(v; t; f)) = Add(addAll(collect(t), collect(f)),v)
                                                                                                                    
-  * 4.f)+  * f)
            isBDD(Decision(v; t; f)) = isBDD(t)            isBDD(Decision(v; t; f)) = isBDD(t)
                                                ^ isBDD(f)                                                  ^ isBDD(f)  
Zeile 192: Zeile 190:
 </code> </code>
  
-  * 5.+==== Aufgabe 5 ==== 
   * a)   * a)
 <code java> <code java>
Zeile 290: Zeile 289:
 </code> </code>
    
-  * 6.+==== Aufgabe 6 ==== 
  
   * a) 3,4 richtig          /--2 recht sicher auch, steht so zumindest auf den TÜ- Folien/ 2 ist falsch, QuickSort kann in-situ implementiert werden siehe Vorlesungsfolie "Überblick über die Sortierverfahren"   * a) 3,4 richtig          /--2 recht sicher auch, steht so zumindest auf den TÜ- Folien/ 2 ist falsch, QuickSort kann in-situ implementiert werden siehe Vorlesungsfolie "Überblick über die Sortierverfahren"