a) 2 und 4 b) 1 und 2 c) 1 (SEHR unsicher), 2, 3

a)

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;
}

b)

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]));
	}
}

c)

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);
			}
		}
	}

a) ops

  diff: MathExp = MathExp 

axs

  diff(add(x,y)) = 0 
  diff(v()) = 1 
  diff(add(x,v()) = add(0,1)
  

b)

axs

  diff(sub(x,y)) = sub(diff(x),diff(y)) 
  diff(mul(x,y) = add(mul(diff(x),y),mul(diff(y),x))
  

c)

axs

  diff(sin(f)) = mul(cos(f),diff(f))
  diff(cos(f)) = mul(sub(0,sin(f)),diff(f))