diff --git a/img/elektronik_3/Instrumentenverstärker.jpg b/img/elektronik_3/Instrumentenverstärker.jpg
new file mode 100644
index 0000000..9d0b21a
Binary files /dev/null and b/img/elektronik_3/Instrumentenverstärker.jpg differ
diff --git a/src/elektronik_3.typ b/src/elektronik_3.typ
index 59f045b..81b69b8 100644
--- a/src/elektronik_3.typ
+++ b/src/elektronik_3.typ
@@ -11,6 +11,11 @@ Speisungen (linear, boost, buck, inverter, charge pump)
 
 Eingangsspannungs offset nullen
 
+#image("../img/elektronik_3/Instrumentenverstärker.jpg")
+
+CMRR??? -> comon mode redejte ration
+
+
 === Verstärkerschaltungen für Detektoren
 === Schaltungen für Gepulste Sender, Laser und Gleichlichtunterdrückung von Detektoren
 === Brückenschaltungen und ihre Steuerung
diff --git a/src/informatik_3.typ b/src/informatik_3.typ
index ae42b1a..64fbd8b 100644
--- a/src/informatik_3.typ
+++ b/src/informatik_3.typ
@@ -261,7 +261,7 @@ Die variante mit "make_pair" kommt von früher und ist nicht mehr gebreuchlich.
 === Algorithmus
 ==== std::fill
 Der fill befehl ersetzt in einem bereich von iteratoren einen anderen wert.
-#table(columns: (1fr, 0.8fr), [```cpp
+#table(columns: (1fr, 0.6fr), [```cpp
 #include <iostream>
 #include <vector>
 int main(){
@@ -270,51 +270,92 @@ int main(){
     std::fill(v.begin() + 2, v.end() - 1, 3);
     return 0;
 }
-```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
-[v vor dem fill:], [`4, -2, 5, 8, 6, 9`],
-[v nach dem fill: ], [`4, -2, 3, 3, 3, 9`],) Die 5, 8 und 6 wurden durch 3 ausgetauscht.
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`4, -2, 5, 8, 6, 9`],
+[v out: ], [`4, -2, 3, 3, 3, 9`],) Die 5, 8 und 6 wurden durch 3 ausgetauscht.
 ])
 
 ==== std::copy
 Mit dem copy befehl können bereiche eines conteiner an einen anderer ort kopiert werden. \
 Kopie inerhalb des gleichen conteiners:
-#table(columns: (1fr, 0.8fr), [```cpp
+#table(columns: (1fr, 0.6fr), [```cpp
 std::vector<int> v{1, 2, 0, 0, 0, 0};
 std::copy(v.begin(), v.begin() + 2, v.begin() + 4);
-```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
-[v vor dem copy:], [`1, 2, 0, 0, 0, 0`],
-[v nach dem copy: ], [`1, 2, 0, 0, 1, 2`],)
-]
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`1, 2, 0, 0, 0, 0`],
+[v out: ], [`1, 2, 0, 0, 1, 2`],)]
 )
 Kopie in einen anderen conteiners:
-#table(columns: (1fr, 0.8fr), [```cpp
+#table(columns: (1fr, 0.6fr), [```cpp
 std::vector<int> v{1, 2, 0, 0, 0, 0};
 std::copy(v.begin(), v.begin() + 2, v.begin() + 4);
 
 std::vector<int> w(4);
 std::copy(v.begin(), v.begin() + 2, w.begin() + 2);
-```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
-[w vor dem copy:], [`0, 0, 0, 0`],
-[w nach dem copy: ], [`0, 0, 1, 2`],)
-]
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[w in:], [`0, 0, 0, 0`],
+[w out: ], [`0, 0, 1, 2`],)]
 )
 
 ==== std::reverse
 Elemente eines Conteiner umkehern.
-#table(columns: (1fr, 0.8fr), [```cpp
+#table(columns: (1fr, 0.6fr), [```cpp
 #include <algorithm>
 std::vector<int> v{1, 2, 0, 8, 0, 0};
 std::reverse(v.begin(), v.end());
-```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
-[v vor dem reverse:], [`1, 2, 0, 8, 0, 0,`],
-[v nach dem reverse: ], [`0, 0, 8, 0, 2, 1`],)
-]
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`1, 2, 0, 8, 0, 0`],
+[v out: ], [`0, 0, 8, 0, 2, 1`],)]
 )
 
 ==== std::sort
+Sortiert die Elemente des Containers der Reihe nach.
+#table(columns: (1fr, 0.6fr), [```cpp
+#include <algorithm>
+std::vector<int> v{ 4, -2, 5, 8, 6 };
+std::sort(v.begin(), v.end());
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`4, -2, 5, 8, 6`],
+[v out: ], [`-2, 4, 5, 6, 8`],)]
+)
+
 ==== std::shuffle
+Alle Elemente im Conteiner zufählig anordnen.
+#table(columns: (1fr, 0.6fr), [```cpp
+#include <algorithm>
+#include <random>
+std::random_device rd;
+std::shuffle(v.begin(), v.end(), rd);
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`1, 2, 3, 4, 5 `],
+[v out: ], [`1, 3, 5, 4, 2`],)]
+)
+
 ==== std::find
+Sucht in einem bereich nach einem Element. std::find gibt ein pointer zurück. Ist der Iterator gleich wie das ende() dann wurde im Conteiner nichts gefunden.
+#table(columns: 1fr, [```cpp
+#include <algorithm>
+std::vector<int> v{ 4, -2, 5, 8, 6};
+std::vector<int>::iterator it = std::find(v.begin(), v.end(), -2);
+if (it == v.end())
+    std::cout << "Item not found.\n";
+else
+    std::cout << "Item found: " << *it << "\n";
+```], [Output: #grid(columns: (0.3fr, 1fr), gutter: 10pt,
+[v in:], [`4, -2, 5, 8, 6`],
+[v out: ], [Item found: -2],)]
+)
+
 ==== std::equal
+Vergleicht ein Integral mit einem anderen Bereich / Conteiner. $arrow$ `std::equal(start, stop, start_der_vergleichsposition`.
+#table(columns: 1fr, [```cpp
+#include <algorithm>
+std::vector<int> v{ 1, 2, 3, 1, 2, 3, 1, 2, 3 };
+bool eq = std::equal(v.begin(), v.begin() + 1, v.begin() + 3);
+// { 1, 2, 3, 1, 2, 3, 1, 2, 3 };
+//   X  X              Y  Y
+```], [Output: \ True]
+)
 
 === Runtime complexity
 ==== Binary search tree