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:loesungss16 [08.04.2017 14:38] – pdapruefungen:bachelor:aud:loesungss16 [25.03.2020 10:18] (aktuell) – 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 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: