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:loesungss13 [19.03.2014 19:38] – Tabelle Dijkstra HAL 9000pruefungen:bachelor:aud:loesungss13 [04.04.2022 07:31] (aktuell) – Warnung hinzugefügt BobbyB
Zeile 11: Zeile 11:
 **b)** falsch\\ **b)** falsch\\
  
-**c)** true\\ +**c)** true\\  
  
 **d)** falsch\\ **d)** falsch\\
Zeile 21: Zeile 21:
 **g)** O(n). Einfügen, nach Prüfen ob doppelt vorhanden: O(n). Um einen Wert zu löschen muss dieser erst gefunden werden: O(n). O(n) + O(n) = O(n).\\ **g)** O(n). Einfügen, nach Prüfen ob doppelt vorhanden: O(n). Um einen Wert zu löschen muss dieser erst gefunden werden: O(n). O(n) + O(n) = O(n).\\
  
-**h)** wahr\\+**h)** falsch\\ (unsicher)
  
-**i)** class GenericContainer<E extends Comparable<E>>\\+Wenn wir in eine Hashtabelle einen Wert einfügen wollen, aber die Stelle bereits belegt ist, haben wir eine Primärkollision. Wenn wir dann diese durch Sondierung auflösen und unseren Wert an einen neuen Ort anlegen wollen, dieser aber auch belegt ist, dann bekommen wir eine Sekundärkollision. Der Fall hier ist aber eine Doppelkollision (siehe auch Foliensatz 11 Folie 87) 
 + 
 +**i)** class GenericContainer<E extends Comparable<E> >\\ 
 +Da in Zeile 6 auf die Methode "compareTo" zwingend zugegriffen werden muss.
  
 **j)** O(n log n) \\ **j)** O(n log n) \\
Zeile 49: Zeile 52:
 public interface Essbar { public interface Essbar {
     String menge = "0.815 kg";     String menge = "0.815 kg";
-    Vodka[] digestiv = new Vodka[100]; //+    java.util.ArrayList<Vodka> digestif = new java.util.ArrayList<Vodka>(); 
 +    /* List ist besser als Array, denn so muessen wir nicht unbedingt die Groesse festlegen */
     String verdauen(int portionen);     String verdauen(int portionen);
 } }
Zeile 57: Zeile 61:
 <code java> <code java>
  public class MilchShake extends ObstGericht implements Trinkbar{  public class MilchShake extends ObstGericht implements Trinkbar{
-    String menge = "1 Becher";+    static String menge = "1 Becher";
     String bananen = "Hola Chica";     String bananen = "Hola Chica";
     private boolean laktosefrei = false;     private boolean laktosefrei = false;
Zeile 86: Zeile 90:
 axs: axs:
 diff(const(d)) = const(0) diff(const(d)) = const(0)
-diff(v) = 1+diff(v) = const(1)
 diff(add(a, b)) = add(diff(a), diff(b)) diff(add(a, b)) = add(diff(a), diff(b))
 </code> </code>
Zeile 108: Zeile 112:
 diff(sin(a)) = mul(cos(a), diff(a)) diff(sin(a)) = mul(cos(a), diff(a))
 diff(cos(a)) = sub(const(0), mul(sin(a), diff(a)))  diff(cos(a)) = sub(const(0), mul(sin(a), diff(a))) 
 +**Besser (wenn a negativ ist):**
 +diff(cos(a)) = mul(sub(const(0), sin(a)), diff(a))
 +//Geht nicht auch folgendes:?
 +diff(cos(a)) = mul(mul(const(-1),sin(a)),diff(a))
 </code> </code>
  
Zeile 125: Zeile 133:
 i) i)
 ^ Buckets ^ 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^  ^ Buckets ^ 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 
-^ Schlüssel | V2 | V4 | V6 | V4 | V3 | V1 | +^ Schlüssel | V2 | V4 | V6 | V5 | V3 | V1 | 
  
 ii) ii)
Zeile 149: Zeile 157:
 <code java> <code java>
 double schnittDurchfluss(List<Verteiler> quelleSeite, List<Verteiler> senkeSeite){ double schnittDurchfluss(List<Verteiler> quelleSeite, List<Verteiler> senkeSeite){
-        int sum = 0;+        double sum = 0;
         for(Verteiler v : quelleSeite){         for(Verteiler v : quelleSeite){
             for(Rohr r : v.rohre){             for(Rohr r : v.rohre){
Zeile 163: Zeile 171:
 **c)** **c)**
 <code java> <code java>
 +// Achtung, diese Lösung ist ziemlich sicher falsch. Nicht rekursiv gelöst wie gefordert und damit werden auch nicht alle Lösungen gefunden
 double durchfluss(List<Verteiler> quelleSeite, List<Verteiler> senkeSeite, Verteiler senke){ double durchfluss(List<Verteiler> quelleSeite, List<Verteiler> senkeSeite, Verteiler senke){
-        Verteiler[] ssa = senkeSeite.toArray(new Verteiler[senkeSeite.size()]);      + Verteiler[] ssa = senkeSeite.toArray(new Verteiler[senkeSeite.size()]); 
-        double df = schnittDurchfluss(quelleSeite, senkeSeite); + double df = schnittDurchfluss(quelleSeite, senkeSeite); 
-        if(senkeSeite.size() == 1){          + for(Verteiler v : ssa){ 
-            return df; + if(!v.equals(senke) && senkeSeite.contains(v)){ 
-        } else { + quelleSeite.add(v); 
-            for(int i = 0; i < ssa.length; i++){              + senkeSeite.remove(v); 
-                if(!ssa[i].equals(senke) && !quelleSeite.contains(ssa[i])){ + df = Math.min(df, this.schnittDurchfluss(quelleSeite, senkeSeite)); 
-                    quelleSeite.add(ssa[i]); + senkeSeite.add(v); 
-                    ssa[i] = null; + quelleSeite.remove(v); 
-                    ArrayList<Verteiler> s = new ArrayList<Verteiler>(); + } 
-                    for(Verteiler v : ssa){ + } 
-                        if(v != null){ + return df;  
-                            s.add(v); +}
-                        } +
-                    } +
-                    df = Math.max(df, durchfluss(quelleSeite, s, senke)); +
-                    ssa[i] = quelleSeite.get(quelleSeite.size() - 1); +
-                    quelleSeite.remove(quelleSeite.get(quelleSeite.size() - 1));                     +
-                } +
-            } +
-        }        +
-        return df; +
-    } +
 </code> </code>