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:loesungss10 [26.07.2013 19:48] Dawodopruefungen:bachelor:aud:loesungss10 [28.03.2016 11:56] (aktuell) 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 60: Zeile 60:
            37     69            37     69
 </code> </code>
 +
 +(Der Balancefaktor bei 69 ist 0. 0 passt sowohl zu positivem als auch negativem Vorzeichen, folglich würde hier auch eine Einfachrotation reichen.)
  
 **e)** **e)**
Zeile 217: Zeile 219:
   
  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 235:
  }  }
   
- while(j < left.length) {+ while(j < right.length) {
  result[k] = right[j];  result[k] = right[j];
   
Zeile 273: Zeile 275:
 ^ 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 313:
 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 320:
  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 350:
  
 <code> <code>
-**LO:** Falsch, da kein k vorkommt +**LO:** Falsch, schon vor der Schleife ungültig: 
- kfs = 1, kf = 1 + = 1, kf = 1, kfs = 1 
- kf! - 1 = 0+ kfs = kf! - 
 + 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 + = 1, kf = 1, kfs = 1 
- kfs + k! = 2+ kf = kfs + k! 
 + 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+= 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 390:
 </code> </code>
  
-old: +**bii)** 
- += (- 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-+
-<-- 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.