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
pruefungen:bachelor:aud:loesungss18 [01.04.2019 11:32] – LasagneAlFornopruefungen:bachelor:aud:loesungss18 [03.08.2019 12:18] (aktuell) – LasagneAlForno
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 155: Zeile 144:
         // begleiche Schuld von S nach G:         // begleiche Schuld von S nach G:
         long dmin = Math.min(Math.abs(dS), Math.abs(dG));         long dmin = Math.min(Math.abs(dS), Math.abs(dG));
-        if (deltas.size() == 2){ 
         Schuld result = new Schuld (S, dMin, G);         Schuld result = new Schuld (S, dMin, G);
         ergebnis.add(result);         ergebnis.add(result);
-        } 
         // aktualisiere deltas von S bzw. G:         // aktualisiere deltas von S bzw. G:
         if (dmin == Math.abs(dS)) {         if (dmin == Math.abs(dS)) {
-            long dNeuG = deltas.get(G) ; +            deltas.put(G, dG - dmin);                   
-            dNeuG += dS;                               // hier habe ich: dNeuG -= dmin; +
-            deltas.put(G, dNeuG);+
             deltas.remove(S);             deltas.remove(S);
 +             // Alternative: long dNeuG = deltas.get(G) ;
 +            // dNeuG += dS; oder  dNeuG -= dmin; 
 +            // deltas.put(G, dNeuG);
        } else {        } else {
-            long dNeuS = deltas.get(S); +            deltas.put(S, dS + dmin);                  
-            dNeuS += dG;                               // hier habe ich: dNeuS += dmin; +
-            deltas.put(S, dNeuS);+
             deltas.remove(G);             deltas.remove(G);
 +             // Alternative: long dNeuS = deltas.get(S);
 +             // dNeuS += dG; oder  dNeuS += dmin;
 +             //deltas.put(S, dNeuS);
         }         }
     }     }
Zeile 175: 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 198: Zeile 190:
 </code> </code>
  
-  * 5.+==== Aufgabe 5 ==== 
   * a)   * a)
 <code java> <code java>
Zeile 247: Zeile 240:
         c--;         c--;
     } // collect values of current horizontal str8t in sh:     } // collect values of current horizontal str8t in sh:
-    while(++c < 9 && blk[row][c]) {+    while(++c < 9 && !blk[row][c]) {
         sh.add(num[row][c]);         sh.add(num[row][c]);
     }     }
Zeile 253: Zeile 246:
         r--;         r--;
     } // collect values of current vertical str8t in sv:     } // collect values of current vertical str8t in sv:
-    while(++r < 9 && blk[r][col]) {+    while(++r < 9 && !blk[r][col]) {
         sv.add(num[r][col]);         sv.add(num[r][col]);
     }     }
Zeile 296: 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"
Zeile 306: Zeile 300:
   * d) 1,2 richtig          /--Code von 2 in Eclipse eingetippt, hat nicht gemeckert. 3 sollte auch nicht richtig sein, da der rueckgabetyp sehr wohl generisch sein kann, z.b Unimodale Suche   * d) 1,2 richtig          /--Code von 2 in Eclipse eingetippt, hat nicht gemeckert. 3 sollte auch nicht richtig sein, da der rueckgabetyp sehr wohl generisch sein kann, z.b Unimodale Suche
  
-  * e) 2 ,3 sind richtig, wobei bei 3 javac -ea fuer "enable assertions" steht. (Wieso das Stoff in AuD ist, ist fraglich)+  * e) 2 ,3, 4 sind richtig, wobei bei 3 javac -ea fuer "enable assertions" steht. (Wieso das Stoff in AuD ist, ist fraglich)