Schreibtischtest
================

Durchl.	dez	rest	Ausgabe
1	7
		1
			1
	3

2	3
		1
			1
	1

3	1
		1
			1
	0
ENDE

111.

Durchl.	dez	rest	Ausgabe
1	11
		1
			1
	5

2	5
		1
			1
	2

3	2
		0
			0
	1

4	1
		1
			1
	0
ENDE

1101.

-> Ausgabe müsste 

void Umr(dez: int)
BEGINN
  rest: int;
  rest = dez % 2;
  dez = dez / 2;
  WENN dez > 0 DANN
    Umr(dez)
  ENDE
  AUSGABE(rest)
ENDE

Aufr.	int	rest	ausg
1	11
		1	
	5
2	5
		1
	2
3	2
		0
	1
4	1
		1
	0
			1
3			0
2			1
1			1

1011
	

Rekursion
=========
 - vorteil
   - bei einigen Problemen einfacher zu verstehen/programmieren
   - IHK "Rekursive sind zum passenden Problem einfacher oder eleganter zu schreiben."

 - nachteil
   - möglicher Stack-Overflow
   - IHK: "Rekursive Lösungen benötigen mehr Speicher zur Laufzeit."



Pseudocode via Privatnachricht

IHK - Muserlösung
=================
Ist auch nicht ganz sauber!
  - Fall dezimalzahl = 0 wird nicht abgefangen
  - Ausgabeschleife, ist off-by-one ( l.size(), statt l.size() - 1 )

void Umrechnung(dezimalzahl: int)
BEGINN
  rest: int;
  i: int;
  List l();
  SOLANGE (dezimalzahl > 0)
  BEGINN
    rest = dezimalzahl modulo 2;
    l.insert(rest);
    dezimalzahl = dezimalzahl div 2;
  ENDE

  ZÄHLE i VON l.size() BIS 0 SCHRITTWEITE -1
  BEGINN
    AUSGABE(l.element(i));
  ENDE
ENDE

Besprechung 13:15


Papierrolle
===========
50,8cm = 508mm
-> Breite d. Bildes = Breite d. Rolle

30,48 m/min / 30,48cm

30,48 m/min
-----------  = 100 Aufnahmen / min
0,3048 m/Aufnahme

100 Aufnahmen / min  = 6000 Aufnahmen / h
6000 Aufn./ h * 12 h / d = 72000 Aufn./d

a)
-> 72.000 Aufnahmen / Tag

400dpi == 400 Pixel / in
            2,54 cm / in

400 pixel / in
--------------  * 50,8cm = 8000 pixel
 2.54 cm / in

50,8 cm / 2,54 cm/in = 20 in
20 in * 400 pixel / in = 8000 pixel

30,48cm / 2,54 cm = 12 in
12 in * 400 pixel / in = 4800 pixel

8000 pixel * 4800 pixel = 38.400.000 pixel
16 bit / 8 bit/byte = 2 byte
38.400.000 px * 2 b/px = 76.800.000 b
76.800.000 b / 1024^2 b/MiB ~= 73,25 MiB

bb)
72.000 Aufnahmen / Tag * 73,25 MiB / Aufnahme 
    / 1024^2 MiB / TiB = 5,029 TiB / Tag

-> 6 TiB pro Tag!