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:loesungss10 [26.07.2013 19:48] – Dawodopruefungen:bachelor:aud:loesungss10 [28.03.2016 11:52] – Marcel[Inf]
Zeile 26: Zeile 26:
 **e)** Richtig **e)** Richtig
  
-**f)** 2. und 3. Antwort sind richtig+**f)** 2. und 3. Antwort sind richtig (RuntimeException oder Unterklassen oder Error oder Unterklassen müssen nicht deklariert werden.)
  
 ==== Aufgabe 2 - AVL-Bäume ==== ==== Aufgabe 2 - AVL-Bäume ====
Zeile 217: Zeile 217:
   
  while(i < left.length && j < right.length) {  while(i < left.length && j < right.length) {
- if(left[i] < right[j]) {+ if(left[i] <= right[j]) {
  result[k] = left[i++];  result[k] = left[i++];
  } else {  } else {
Zeile 233: Zeile 233:
  }  }
   
- while(j < left.length) {+ while(j < right.length) {
  result[k] = right[j];  result[k] = right[j];
   
Zeile 273: Zeile 273:
 ^ Nürnberg | Würzburg | ^ Nürnberg | Würzburg |
 ^ Nürnberg | Hof | ^ Nürnberg | Hof |
 +
 +Es sind auch leichte Abwandlungen hiervon gültig.
  
 **c)** **c)**
  
-AD Holledau <-> Passau+(Scheinbar nicht mehr Stoff aktueller Semester) 
 + 
 +Ein Euler-Pfad ist ein Pfad, der jede Kante exakt einmal enthält. 
 +Mögliche Lösung: AD Holledau <-> Passau
  
 ==== Aufgabe 7 - UML ==== ==== Aufgabe 7 - UML ====
 **a)** **a)**
  
-{{:pruefungen:bachelor:aud:screenshot1.png|:pruefungen:bachelor:aud:screenshot1.png}}+{{:pruefungen:bachelor:aud:05-08-2010-7-uml-pic00.png|:pruefungen:bachelor:aud:05-08-2010-7-uml-pic00.png}}
  
-{{:pruefungen:bachelor:aud:screenshot6.png|:pruefungen:bachelor:aud:screenshot6.png}}+{{:pruefungen:bachelor:aud:05-08-2010-7-uml-pic01.png|:pruefungen:bachelor:aud:05-08-2010-7-uml-pic01.png}}
  
 **b)** **b)**
  
-Eventuell nicht mehr Stoff aktueller Semester?+(Scheinbar nicht mehr Stoff aktueller Semester)
  
 ==== Aufgabe 8 - Rekursion und Iteration ==== ==== Aufgabe 8 - Rekursion und Iteration ====
 **a)** **a)**
  
-Kaskadenartige Rekursion, da mehrere rekursive Aufrufe im Rumpf vorkommen.+Kaskadenartige Rekursion, da mehrere rekursive Aufrufe im Rumpf vorkommen.(auf Schleife achten)
  
 **b)** **b)**
Zeile 306: Zeile 311:
 private static int knapsack (Item [ ] items , int capacity) { private static int knapsack (Item [ ] items , int capacity) {
  if(maxKnown[capacity]!= -1) {  if(maxKnown[capacity]!= -1) {
- return (maxKnown[capacity];+ return maxKnown[capacity];
  }  }
  
Zeile 313: Zeile 318:
  int spaceLeft = capacity − items [i].size;  int spaceLeft = capacity − items [i].size;
  if(spaceLeft >= 0 ) {  if(spaceLeft >= 0 ) {
- int value = knapsack (items, spaceLeft) + items [i].value;+ int value = knapsack(items, spaceLeft) + items[i].value;
  
  if(value > maxValue) {  if(value > maxValue) {
Zeile 343: Zeile 348:
  
 <code> <code>
-**LO:** Falsch, da kein k vorkommt +**LO:** Falsch, schon vor der Schleife ungültig: 
- kfs = 1, kf = 1 + k = 1, kf = 1, kfs = 1 
- kf! - 1 = 0+ kfs = kf! - 1 
 + 1 = 1 - 1 
 + 1 = 0
  
-**RO:** Richtig, Summe wird bis zum momentanen k gemacht, wie im code!+**RO:** Richtig, Summe wird bis zum momentanen k gebildet
  
-**LU:** Falsch, Summenbildung fehlt +**LU:** Falsch, schon vor der Schleife ungültig: 
- kfs = 1, kf = 1 + k = 1, kf = 1, kfs = 1 
- kfs + k! = 2+ kf = kfs + k! 
 + 1 = 1 + 1! 
 + 1 = 2
  
 **RU:** Falsch, es wird bis n-1 summiert, egal wie oft die schleife durchlaufen wird **RU:** Falsch, es wird bis n-1 summiert, egal wie oft die schleife durchlaufen wird
- kfs = 1, kf = 1 + Alternativ: Schon vor der Schleife ungültig: 
- (k + 1)! = 2+ k = 1, kf = 1, kfs = 1 
 + ... ∧ kf = (k + 1)! ∧ ... 
 + ... ∧ 1 = (1 + 1)! ∧ ... 
 + ... ∧ 1 = 2 ∧ ...
 </code> </code>
  
 **b) ii)** **b) ii)**
 <code> <code>
-Zu zeigen: {I ∧ b} => wp(A,I)+Zu zeigen: (I ∧ b) => wp(A,I)
  
 wp("kf *= k; kfs += kf; k++;", kfs = ∑ i! ∧ kf = (k-1)! ∧ 1 <= k <= n) = wp("kf *= k; kfs += kf; k++;", kfs = ∑ i! ∧ kf = (k-1)! ∧ 1 <= k <= n) =
Zeile 376: Zeile 388:
 </code> </code>
  
-old: +**b) ii)** 
- +V = (n - 1) - k
-<code> +
-wp("kf *= k, kfs = kfs + kf, k = k+1", kfs = ∑i! ∧  kf = (k-1)  ∧  1 <= k <= n) +
-= wp("kf = kf*k, kfs = kfs + kf, k = k+1" kfs = ∑i! ∧ kf = k! ∧ 1 <= k ü 1 <= n)  +
-= wp("kf = kf*k, kfs = kfs + kf, k = k+1" kfs + kf = ∑i! ∧ kf = k! 1 <= k+1 <=n) +
-= kfs + kf * k = ∑ i kf * k = k! ∧ 1 <= k + 1 <= n  +
-= kfs = ∑i! - kf*k ∧ kf = (k-1)! ∧ 0 <= k <= n-1 +
-<-- b ∧ I = ∑i! ∧ kf= (k-1)! ∧ 1 <= k <= n +
-</code>+
  
 +k wird sukzessive erhöht, während (n-1) von der Eingabe abhängig, aber im Programm selbst konstant ist.
 +V ist damit monoton fallend. Durch die Abbruchbedingung der Schleife ist V nach unten durch die 0 beschränkt.