/*

	Analysis I - Übungsblatt 1

	- Zusatzaufgabe -

	Leonhard Fellermayr <leonhard.fellermayr@campus.lmu.de>
	Mat.-Nr. 22128130XXXX

	Ergebnis (korrekte Wahrheitsbelegungen):
	
	Belegung: A=0 B=1 C=0 D=0 E=0
	Ergebnis: 1
	--
	Belegung: A=1 B=0 C=1 D=1 E=0
	Ergebnis: 1
	--
	Belegung: A=1 B=1 C=0 D=0 E=0
	Ergebnis: 1

*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define ANZ_SIEGER 5

/* ****************************************************************
   dec2bin () - Wandelt Dezimal- in Dualzahlen um.
   **************************************************************** */

int dec2bin (int mydec) {

		/* benötigte Dualzahl-Stellen */
	int	needed_cols = floor (log10 (mydec) / log10 (2));

	int	i;
	int	col_val = pow (2, needed_cols);
	int	ret_val = 0;

	for (i = needed_cols; i >= 0; i--) {

		/* if: mydec passt in Dualstellenwert der aktuellen Stelle */

		if (mydec >= col_val) {
			ret_val = ret_val * 10 + 1;
			mydec -= col_val;
		} // endif

		/* else: mydec passt an aktueller Stelle nicht, also Wert 0 */

		else

			ret_val *= 10;

		/* nächste Stelle hat stets halben Wert (.../32/16/8/4/2/1) */

		col_val /= 2;

	} // endfor

	/* Ergebnis an Aufrufer zurückgeben */

	return (ret_val);

} // dec2bin ()

/* ****************************************************************
   iterate () - Berechnet aufgrund der Logikbedingungen (erg)
   		Ergebnisse für 2^ANZ_SIEGER True-/False-Kombinationen
   **************************************************************** */

int iterate () {

	int	kt, i, erg, s[ANZ_SIEGER];
	char	*tmpstr, *belegung;

	/* Speicher für Variable belegung allozieren */

	belegung = malloc (ANZ_SIEGER + 1);	

	for (kt = 0; kt < pow (2, ANZ_SIEGER); kt++) {

		/* Dualzahlen von 0 ... 2^ANZ_SIEGER generieren */

		sprintf (belegung, "%05d", dec2bin (kt));

		/* atoi hack */

		for (i = 0; i < ANZ_SIEGER; i++) {
			sprintf (tmpstr, "%c", belegung[i]);
			s[i] = atoi (tmpstr);
		} // endfor

		/* Logikbedingungen gemäß Aufgabenstellung */

		erg =	(

			(s[1] ^ s[2]) &&	/* B XOR C */
			(s[0] | s[1]) &&	/* A OR B */
			(s[2] == s[3]) &&	/* C EQUAL D */

			/* IF E == 1 => A == 0, D == 1 */
			(((s[4] == 1) && (s[0] == 0) && (s[3] == 1)) ^ (s[4] == 0))

		);

/*

   Interessant: Wenn E 1, dann ist A 0 (lehnt ab), somit muss (wg. OR) B 1 sein,
		womit (wg. XOR) C 0 sein muss.
		C und D muessen gleich sein (da abgeschrieben), E und D aber auch.
		Da E 1 ist und C 0, ergibt sich ein Widerspruch.

		Fazit: Es gibt keine gueltige Kombination mit E 1.

*/

		printf ("Belegung: A=%d B=%d C=%d D=%d E=%d\n", s[0], s[1], s[2], s[3], s[4]);		
		printf ("Ergebnis: %d\n\n", erg);

	} // endfor

} // iterate ()

/* ****************************************************************
   main () - C stub
   **************************************************************** */

int main () {

	/* ... und los */

	iterate ();

} // main ()