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:loesungss16 [08.04.2017 14:38] – pdapruefungen:bachelor:aud:loesungss16 [25.03.2020 10:17] – kat04
Zeile 50: Zeile 50:
   * zu 3)    * zu 3) 
              *Grad ist differenziert zu betrachten hinsichtlich "gerichtete" und "ungerichtete" Graphen.               *Grad ist differenziert zu betrachten hinsichtlich "gerichtete" und "ungerichtete" Graphen. 
-             *Gerichtete Graphen ist der Grad die Anzahl an Knoten, mit den ein Knoten direkt in Verbindung steht.  +             *Ungerichtete Graphen ist der Grad die Anzahl an Knoten, mit den ein Knoten direkt in Verbindung steht.  
-             *Ungerichtete Graphen haben Eingangs- und Ausgangsknoten, wobei der Eingangsknoten die Anzahl der Elternknoten repräsentiert. +             *Gerichtete Graphen haben Eingangs- und Ausgangsknoten, wobei der Eingangsknoten die Anzahl der Elternknoten repräsentiert. 
  
   * zu 4)    * zu 4) 
Zeile 100: Zeile 100:
              *  Ein Graph ist induzierter Teilgraph von G, wenn alle seine Knoten eine Teilmenge der Knoten von G sind und wenn seine Kanten auch in G existieren.               *  Ein Graph ist induzierter Teilgraph von G, wenn alle seine Knoten eine Teilmenge der Knoten von G sind und wenn seine Kanten auch in G existieren. 
  
-**h)** 2 und 3+**h)** 2 und 4
   * zu 1)   * zu 1)
              * this kann nicht in einem statischen Kontext verwendet werden, sonst Fehler => Cannot use this in a static context              * this kann nicht in einem statischen Kontext verwendet werden, sonst Fehler => Cannot use this in a static context
Zeile 108: Zeile 108:
  
   * zu 3)    * zu 3) 
-            * anscheinend doch, nur der konkrete nutzen ist mir nicht bekannt+            * falsch, siehe [[https://stackoverflow.com/questions/28173541/does-the-main-method-in-java-have-to-be-static|Externer Link]]
  
   * zu 4)    * zu 4) 
-            * Genau genommen initialisiert die Laufzeitumgebung jede Objekt- und Klassenvariable zunächst mit 0, null oder false und später mit einem Wert. Daher ist die Nullung von Hand nicht nötig: +            * Genau genommen initialisiert die Laufzeitumgebung jede Objekt- und Klassenvariable zunächst mit 0, null oder false und später mit einem Wert. Daher ist die Nullung von Hand nicht nötig: genau das sagt die Antwort, also richtig  
 +            *  
  
  
Zeile 137: Zeile 139:
 **e)** **e)**
  
-Darstellung als Array: 28,24,13,21,19,3,7+Darstellung als Array: 3,19,7,28,24,11,12,42
  
 **f)** **f)**
Zeile 181: Zeile 183:
 <code java> <code java>
         public E previous() {         public E previous() {
- // TODO Auto-generated method stub 
  if(prev != null){  if(prev != null){
  E vTmp=prev.v;  E vTmp=prev.v;
Zeile 241: Zeile 242:
  
 ==== Aufgabe 5 ADT ==== ==== Aufgabe 5 ADT ====
-**a) ** + 
-  getCol(Step(l), x, y) = true falls getCol(l, x, y) = false +   
-  getCol(Step(l), x, y) = false sonst+ **a) ** 
 +<code java> 
 +  getCol(Step(l), x, y) = NOT(getCol(l,x,y), falls x = getX(l) && y = getY(l) 
 +  getCol(Step(l), x, y) =     getCol(l,x,y), sonst 
 +</code>
      
  **b) **  **b) **
-  getDir(Step(l)) = (d+3)%4 falls getCol(l,x,y) = false +<code java>   
-  getDir(Step(l)) = (d+1)%4 sonst +  getDir(Step(l)) = (getDir(l) + 3) % 4, falls getCol(l, getX(l), getY(l)) == false 
-   +  getDir(Step(l)) = (getDir(l) + 1) % 4, sonst 
 +</code> 
 +     
  **c) **  **c) **
-  getX(Step(l)) = x+1 falls (getDir = 0 & getCol(l,x,y) = false) || (getDir = 2 & getCol(l,x,y) = true) +<code java> 
-  getX(Step(l)) = x - 1 falls (getDir = 0 & getCol(l,x,y) = true) || (getDir = 2 & getCol(l,x,y) = false) +  getX(Step(l)) = getX(l) + 1, falls getDir(Step(l)) == 1 // + und - vertauscht? 1 = Westen, also nach links also -1 
-  getX(Step(l)) = x sonst+  getX(Step(l)) = getX(l) - 1, falls getDir(Step(l)) == 3 //wie oben nur umgekehrt, auch in den Bildern zu sehen 
 +  getX(Step(l)) = getX(l), sonst  
 +</code>   
 +   
 + ** d) ** 
 +<code> 
 +Beachte: Das Koordinatensystem ist nach unten geklappt, d.h. die y-Werte drehen sich bei den Blickrichtungen Norden/Sueden um.  
 +Wo steht das? Reine Interpretationssache. Das Raster im Bild ist nach oben auch positiv... 
 + 
 +---------> x 
 +| 
 +| 
 +| 
 +y 
 +</code> 
 +<code java> 
 +          public class LangtonAntJava{ 
 +               boolean[][] raster = new boolean[4711][4242]; 
 +               int x = 666, y = 666, d = 0; // Position und Richtung 
 +               void step(){ 
 +                   if(raster[x][y]){ 
 +                       d = (d+1)%4; 
 +                   } else { 
 +                       d = (d+3)%4; 
 +                   } 
 +                   raster[x][y] = !raster[x][y]; 
 +                   if(d == 0){ 
 +                       y -= 1;  
 +                   } else if (d == 1){ 
 +                       x += 1;    // muesste hier nicht x -= 1 stehen, da Blickrichtung nach Osten? Stimme dem zu. Autor kennt, wie bei c) schon erwähnt, die Himmelsrichtungen nicht. 
 +                   } else if (d == 2){ 
 +                       y += 1;  
 +                   } else if (d == 3){ 
 +                       x -= 1;    // muesste hier nicht x += 1 stehen, da Blickrichtung nach Westen?  
 +                   } 
 +               } 
 +           } 
 +</code> 
        
 ==== Aufgabe 6 Binäre Suche ==== ==== Aufgabe 6 Binäre Suche ====
Zeile 303: Zeile 348:
  abDiff-=2*(a.get(p));  abDiff-=2*(a.get(p));
  b.add(a.remove(p));  b.add(a.remove(p));
- helfer(p);+ helfer(p); //sollte hier nicht auch p+1 stehen? sonst mach ich den gleichen Schritt nochmal // Nein, da ja der aktuelle Wert der Stelle P entfernt wird, wenn du jetzt p +1 machen würdest, würdest du einen Wert überspringen 
  
  // Backtracking zur 2. Rekursion:  // Backtracking zur 2. Rekursion: