Einige ERgänzungen im Arbeitsheft EF

Informatik/Arbeitsheft/Arbeitsheft EF.typ

@@ -4,7 +4,7 @@
 
 #show: arbeitsheft.with(
   titel: "Programmierung mit Java",
-  kurs: "IF-EF"
+  kurs: "IF-EF",
 )
 
 = Was ist Programmierung?
@@ -13,12 +13,92 @@ _Java_ ist eine _Objektorientierte Programmiersprache_.
 
 == Was ist ein Algorithmus?
 
+#notiz[
+  Ein _Algorithmus_ ist eine eindeutige, endliche Abfolge von Befehlen zur Lösung einer Klasse von Problemen.
+]
+
+Eine _Klasse von Problemen_ bedeutet hier, dass der Algorithmus ein Problem für verschiedene Eingaben lösen kann. Beispielsweise berechnet der Algorithmus _Summe zweier Zahlen_ die Summe für beliebige Kombinationen aus ganzen Zahlen.
+
+_Eindeutig_ bedeutet, dass zu jedem Zeitpunkt eindeutig bestimmbar ist, welcher Befehl als Nächster ausgeführt wird. Das bedeutet auch, dass für dieselbe Eingabe immer dieselbe Lösung herauskommt. (Das Ergebnis von $3+5$ ist immer $8$ und nicht manchmal $12$.)
+
+_Endlich_ bedeutet, dass der Algorihtmus irgendwann zu einem Ende kommt und nicht endlos weiter arbeitet (#sym.arrow Terminiertheit).
+
+== Eigenschaften von Algorithmen
+
+/ Terminiertheit: Der Algorithmus endet nach einer endlcihen Anzahl Arbeitsschritte.
+/ Finitheit: Der Algorihtmus lässt sich mit einer endlichen Anzahl Befehlen aufschreiben.
+/ Determiniertheit: Der Algorihtmus hat eine eindeutige Abfolge von Befehlen.
+/ Determinismus: Der Algorihtmus produiert für gleiche Eingaben immer dieselbe Ausgabe.
+
+
+
+== Imperative Programmierung
+
+_Imperative Programmierung_ ist ein _Programmierparadigma_, bei dem alle Befehle eines Algorithmus hintereinander aufgeschrieben werden und in einer eindeutig definierten Abfolge ausgeführt werden. Dabei kann es Sprünge zu früheren Programmteilen geben und Programmteile, die nur unter bestimmten Bedingungen ausgeführt werden. Aber grundsätzlich gibt es eine klare Reihenfolge der Befehle.
+
+== Programmierung mit Java
+
+Quelltext #sym.arrow Compiler #sym.arrow Interpreter
 
 #pagebreak()
-= Imperative Programmierung
+= Grundlagen
+
+== Befehle nutzen
+
+#notiz(title: "Datenypen", icon: sym.excl)[
+  Eine Variable muss in Java immer einen festen _Datentyp_ bekommen. Das bedeutet, dass der _Interpreter_
+]
+
+*Aufgabe 1: Finde den Fehler*
+#grid(
+  columns: 2,
+  gutter: 5mm,
+  [a)], [b)],
+  sourcecode(```
+  int zahl1 = 5;
+  int zahl 2 = 6;
+  System.out.println(zahl1 + zahl 2)
+  ```),
+  sourcecode(```
+  char buchst1 = 72
+  char buchst2 = 'G'
+  System.out.println(buchst1 & buchst2)
+  ```),
+
+  [c)], [d)],
+  sourcecode(```
+  int zahl1 = 5;
+  int zahl 2 = 6;
+  System.out.println(zahl1 + zahl 2)
+  ```),
+  sourcecode(```
+  char buchst1 = 72
+  char buchst2 = 'G'
+  System.out.println(buchst1 & buchst2)
+  ```),
+)
+
+#pagebreak(weak: true)
+== Variablen
+
+#pagebreak(weak: true)
+== Schleifen
+
+#pagebreak(weak: true)
+== Bedingte Anweisungen
+
+#pagebreak(weak: true)
+== Programme strukturieren
+
+=== Strukturierte Zerlegung
+
+=== Programmablaufpläne
 
-_Impoerative Programmierung_ ist ein _Programmierparadigma_, bei dem alle Befehle eines Algorithmus hintereinander aufgeschrieben werden und in einer eindeutig definierten Abfolge ausgeführt werden. Dabei kann es Sprünge zu früheren Programmteilen geben und Programmteile, die nur unter bestimmten Bedingungen ausgeführt werden. Aber grundsätzlich gibt es eine klare Reihenfolge der Befehle.
+#pagebreak(weak: true)
+== Methoden
 
+#pagebreak(weak: true)
+== Parameter und Rückgaben
 
 #pagebreak()
 = Objektorientierte Modellierung

Informatik/Arbeitsheft/arbeitsheft.typ

@@ -1,69 +1,82 @@
 
 #let typst-scale = scale
-#let numbering-poly(n, size:10mm, scale:100%) = {
+#let numbering-poly(n, size: 10mm, scale: 100%) = {
   size = size * scale
   let polys = {
-    place(top+left, polygon(
-      stroke:none, fill: luma(88%),
-      (0mm, 0mm),
-      (size * 110%, 0mm),
-      (0mm, size * 110%)
-    ))
-    place(top+left, polygon(
-      stroke:none, fill: rgb(128, 128, 128, 50%),
-      (0mm, 0mm),
-      (size * 150%, 0mm),
-      (0mm, size * 80%)
-    ))
-    place(top+left, polygon(
-      stroke:none, fill: rgb(88, 88, 88, 50%),
-      (0mm, 0mm),
-      (size * 70%, 0mm),
-      (0mm, size * 110%)
-    ))
+    place(
+      top + left,
+      polygon(
+        stroke: none,
+        fill: luma(88%),
+        (0mm, 0mm),
+        (size * 110%, 0mm),
+        (0mm, size * 110%),
+      ),
+    )
+    place(
+      top + left,
+      polygon(
+        stroke: none,
+        fill: rgb(128, 128, 128, 50%),
+        (0mm, 0mm),
+        (size * 150%, 0mm),
+        (0mm, size * 80%),
+      ),
+    )
+    place(
+      top + left,
+      polygon(
+        stroke: none,
+        fill: rgb(88, 88, 88, 50%),
+        (0mm, 0mm),
+        (size * 70%, 0mm),
+        (0mm, size * 110%),
+      ),
+    )
   }
   if calc.odd(n) {
-    typst-scale(x:-100%, polys)
-    place(top+right, dx: -size*10%, dy: size*10%, text(font: ("Arial", ), fill:white, size: size*33%)[#n])
+    typst-scale(x: -100%, polys)
+    place(top + right, dx: -size * 10%, dy: size * 10%, text(font: ("Arial",), fill: white, size: size * 33%)[#n])
   } else {
     polys
-    place(top+left, dx: size*10%, dy: size*10%, text(font: ("Arial", ), fill:white, size: size*33%)[#n])
+    place(top + left, dx: size * 10%, dy: size * 10%, text(font: ("Arial",), fill: white, size: size * 33%)[#n])
   }
 
 }
 
-#let arbeitsheft( titel: none, kurs: none, ..args, body ) = {
+#let arbeitsheft(titel: none, kurs: none, ..args, body) = {
   set page(
     paper: "a4",
     margin: (
       inside: 2.4cm,
       outside: 1.8cm,
     ),
     header: {
+      set text(12pt)
       counter(page).display((n, ..) => {
         locate(loc => {
           let (last, ..) = counter(page).final(loc)
-          if n > 2 and n+1 < last {
+          if n > 2 and n + 1 < last {
             if calc.odd(n) [
-              #place(bottom+right, dx: 3mm, dy: -1em, numbering-poly(n - 2))
+              #place(bottom + right, dx: 3mm, dy: -1em, numbering-poly(n - 2))
               #kurs #h(1fr) #titel #h(1fr) #hide[#kurs]
-              #place(bottom+left, dy: .5em, line(length: 100% - 5mm, stroke:.5pt+luma(33)))
+              #place(bottom + left, dy: .5em, line(length: 100% - 5mm, stroke: .5pt + luma(33)))
             ] else [
-              #place(bottom+left, dx: -3mm, dy: -1em, numbering-poly(n - 2))
+              #place(bottom + left, dx: -3mm, dy: -1em, numbering-poly(n - 2))
               #hide[#kurs] #h(1fr) #titel #h(1fr) #kurs
-              #place(bottom+right, dy: .5em, line(length: 100% - 5mm, stroke:.5pt+luma(33)))
+              #place(bottom + right, dy: .5em, line(length: 100% - 5mm, stroke: .5pt + luma(33)))
             ]
           }
         })
       })
     },
-    footer: []
+    footer: [],
   )
 
   page(margin: (1.8cm))[
     #set align(center)
     #v(5cm)
-    #block(width: 100%, stroke: 3pt+black, fill: luma(10%), inset: 2em, radius: 1em)[
+    #block(width: 100%, stroke: 3pt + black, fill: luma(10%), inset: 2em, radius: 1em)[
       #text(fill: luma(75%), weight: "bold", size: 26pt, "Arbeitsheft")\
       #text(fill: white, weight: "bold", size: 42pt, titel)
     ]
@@ -72,22 +85,18 @@
   pagebreak()
   pagebreak()
 
-  outline(
-    title: "Inhalt"
-  )
+  outline(title: "Inhalt")
   pagebreak()
 
   set par(
     justify: true,
-    leading: 1em
+    leading: 1em,
   )
   set text(
     font: ("Cochin", "Liberation Serif", "Times", "Times New Roman"),
-    size: 12pt,
-  )
-  set heading(
-    numbering: "I.1.a"
+    size: 13pt,
   )
+  set heading(numbering: "I.1.a")
   show heading: set text(font: ("Ubuntu", "Liberation Sans", "Helvetica Neue", "Arial"))
   body
 
@@ -103,6 +112,10 @@
   pagebreak()
 }
 
-#import "@preview/gentle-clues:0.6.0": *
+#import "@preview/codelst:2.0.1": sourcecode
+
+#import "@preview/gentle-clues:0.6.0"
+#let notiz = gentle-clues.clue.with(title: none)
+
 #import "@preview/octique:0.1.0"
-#let icon = octique
+#let icon = octique.octique