Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

@@ Zeile 1: / Zeile 1: @@
+===== Lösungsversuch Miniklausur WS 2017/18 =====
+==== Aufgabe 1 (Wissensfragen) ====
+**a)** 2 und 4
+**b)** 1 und 2
+**c)** 1 (SEHR unsicher), 2, 3
+==== Aufgabe 2 (Backtracking) ====
+**a)**
+<code java>
+class ZahlUnvollstaendig extends Exception { }
+public abstract class Rechnung {
+	protected int[][] zahlen;
+	protected Rechnung(int[] operand1, int[] operand2, int[] ergebnis) {
+		this.zahlen = new int[][] { operand1, operand2, ergebnis };
+	}
+	protected long werteAus(int[] zahl) throws ZahlUnvollstaendig {
+		long erg = 0;
+		int laenge = zahl.length;
+		for(int i = 0; i<laenge;i++) {
+			if(zahl[i]<0) throw new ZahlUnvollstaendig();
+			erg+= zahl[i] * Math.pow(10, laenge-i-1);
+		}
+		return erg;
+	}
+	protected abstract boolean pruefe() throws ZahlUnvollstaendig;
+}
+</code>
+**b)**
+<code java>
+class Addition extends Rechnung {
+	protected Addition(int[] operand1, int[] operand2, int[] ergebnis) {
+		super(operand1, operand2, ergebnis);
+	}
+	@Override
+	protected boolean pruefe() throws ZahlUnvollstaendig {
+		return(werteAus(zahlen[0]) + werteAus(zahlen[1]) == werteAus(zahlen[2]));
+	}
+}
+</code>
+**c)**
+<code java>
+public class Rechenproblem {
+	private static Rechnung[] rs;
+        public static boolean loese(Rechnung[] rechnungen) {
+		rs = rechnungen;
+		return loese(0, 0, 0, 0);
+	}
+        private static boolean loese(int rIdx, int zIdx, int stIdx, int z) {
+		try {
+			for(Rechnung rechnung : rs) {
+				if(!rechnung.pruefe()) return false;
+			}
+			return true;
+		} catch(ZahlUnvollstaendig zu) {}
+		if(rIdx >= rs.length){
+			//alle Rechnungen abgearbeitet
+			return false;
+		} else if(zIdx >=3) {
+			//alle Ops /Erg der aktuellen Rechnung abgearbeitet?
+			return loese(rIdx+1,0,0,0);
+		} else if(stIdx >= rs[rIdx].zahlen[zIdx].length) {
+			//alle Stellen der aktuellen Ops /Erg abgearbeitet?
+			return loese(rIdx, zIdx+1, 0, 0);
+		} else if(rs[rIdx].zahlen[zIdx][stIdx] >= 0) {
+			// ist die Stelle schon belegt?
+			return loese(rIdx, zIdx, stIdx+1, 0);
+		} else if(z>=9) {
+			//alle moeglichen Zahlen abgearbeitet?
+			return false;
+		} else {
+			int alt = rs[rIdx].zahlen[zIdx][stIdx];
+			rs[rIdx].zahlen[zIdx][stIdx] = z;
+			if(loese(rIdx, zIdx, stIdx, z)) {
+				return true;
+			} else {
+				//backtrack
+				rs[rIdx].zahlen[zIdx][stIdx] = alt;
+				//next recursive call
+				return loese(rIdx, zIdx, stIdx, z+1);
+			}
+		}
+	}
+</code>