Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- allgemein:test:start [25.09.2025 09:09] – [b) Speicherbedarf] lars
+++ allgemein:test:start [06.11.2025 11:03] (aktuell) – [Programmierung] lars
@@ Zeile 257: / Zeile 257: @@
 > Hinweis (aus der Aufgabe): Nutzt man ersatzweise 90 000 Scans/Tag und 48 MiB/Scan, ergibt sich $90\,000 \times 48 = 4\,320\,000$ MiB ≈ **4,12 TiB**, aufgerundet ebenfalls **5 TiB**.
-=== Aufgabe2 ===
+===== Aufgabe2 =====
+===== Beispielrechnung: Seitenscan =====
+**Gegeben:**
+  * Format: 26 × 38 cm
+  * Auflösung: 600 dpi
+  * Umrechnungsfaktor: 2,54 cm/Zoll
+  * Übertragungsrate: 150 Mbit/s
+----
-### Gegeben:
+**1. Umrechnung in Zoll**
-* **Format:** 26 cm × 38 cm
+  * 26 cm ÷ 2,54 ≈ **10,24 Zoll**
-* **Auflösung:** 600 dpi
+  * 38 cm ÷ 2,54 ≈ **14,96 Zoll**
-* **Umrechnungsfaktor:** 2,54 cm/Zoll
-* **Übertragungsrate:** 150 Mbit/s
----
+----
-### 1. Größe in Pixeln berechnen
+**2. Pixelanzahl berechnen**
-$$
+  * 10,24 Zoll × 600 dpi = **6144 px**
-\,\text{cm} = \frac{26}{2,54} \,\text{Zoll} \approx 10,24 \,\text{Zoll}
+  * 14,96 Zoll × 600 dpi ≈ **8976 px**
-$$
+  * Gesamt: 6144 × 8976 ≈ **55.161.600 Pixel**
-$$
+----
-\,\text{cm} = \frac{38}{2,54} \,\text{Zoll} \approx 14,96 \,\text{Zoll}
-$$
-Pixelanzahl:
+**3. Speicherbedarf**
-$$
+=== Farbscan (24 Bit / 3 Byte pro Pixel) ===
-,24 \times 600 = 6144 \,\text{px}
+  * 55.161.600 × 3 = **165.484.800 Byte**
-$$
+  * Umrechnung in MiB: 165.484.800 ÷ 1.048.576 ≈ **157,8 MiB**
-$$
+=== Schwarz-Weiß-Scan (1 Bit pro Pixel) ===
-,96 \times 600 \approx 8976 \,\text{px}
+  * 55.161.600 × 1 Bit = **55.161.600 Bit**
-$$
+  * Umrechnung in Byte: ÷ 8 = **6.895.200 Byte**
+  * Umrechnung in MiB: 6.895.200 ÷ 1.048.576 ≈ **6,6 MiB**
-Gesamtpixel:
+----
-$$
+**4. Übertragungszeit**
-\times 8976 \approx 55.161.600 \,\text{Pixel}
-$$
----
+  * Leitung: 150 Mbit/s = 150.000.000 Bit/s ÷ 8 = **18.750.000 B/s**
+  * In MiB/s: 18.750.000 ÷ 1.048.576 ≈ **17,87 MiB/s**
-### 2. Speicherbedarf berechnen
+=== Farbscan ===
+  * Zeit = 157,8 ÷ 17,87 ≈ **8,83 s**
+  * Aufgerundet: **0 Min 09 Sek**
-Normalerweise rechnet man mit **24 Bit = 3 Byte pro Pixel** (Farbbild).
+=== Schwarz-Weiß-Scan ===
+  * Zeit = 6,6 ÷ 17,87 ≈ **0,37 s**
+  * Aufgerundet: **0 Min 01 Sek**
-$$
+----
-.161.600 \times 3 = 165.484.800 \,\text{Byte}
-$$
-In MiB (1 MiB = 1.048.576 Byte):
+**Endergebnis:**
+  * Farbscan: **≈ 158 MiB → 0:09 Min:Sek**
+  * SW-Scan: **≈ 6,6 MiB → 0:01 Min:Sek**
-$$
-\frac{165.484.800}{1.048.576} \approx 157,8 \,\text{MiB}
-$$
-Also **~158 MiB pro Scan**.
+----
----
-### 3. Übertragungszeit berechnen
+==== Programmierung ====
-Mbit/s =
+<code csharp>
+string message = "Die Systemauslastung war an mehr als 18 Stunden höher als 80 %."; // Text Messagebox
+string title   = "MONCPU";                                                          // Titel Messagebox
+int cpuutil    = 0;                                                                 // Systemauslastung
+int cpulimit   = 0;                                                                 // Grenzwert der Systemauslastung
+int sumstd     = 0;                                                                 // Summe Stunden
-$$
+// Array mit Testdaten (24 Stunden)
-\times 10^6 \,\text{bit/s} = 18,75 \,\text{MB/s} \quad (1\,B = 8\,bit)
+int[] usedCPU = new int[24]
-$$
+{ 33,44,40,52,60,56, 33,44,40,52,60,56, 33,44,40,52,60,56, 33,44,40,52,60,56 };
-oder in MiB/s:
+// ---------------- Erweiterung MONCPU ----------------
+cpulimit = 80;                                // Grenzwert festlegen
-$$
+for (int i = 0; i < usedCPU.Length; i++)      // alle 24 Stunden prüfen
-\frac{18.750.000}{1.048.576} \approx 17,87 \,\text{MiB/s}
+{
-$$
+    cpuutil = usedCPU[i];
+    if (cpuutil > cpulimit)                   // Stunde über 80 %?
+    {
+        sumstd = sumstd + 1;                  // Zähler erhöhen
+    }
+}
-Zeit:
+// Meldung nur ausgeben, wenn mehr als 18 Stunden über 80 %
+if (sumstd > 18)
+{
+    MessageBox.Show(message, title);
+}
+</code>
-$$
+<code c>
-\frac{157,8}{17,87} \approx 8,83 \,\text{Sekunden}
+#include <stdio.h>
-$$
-Aufgerundet: **0 Min 09 Sek**
+int main() {
+    char message[] = "Die Systemauslastung war an mehr als 18 Stunden höher als 80 %.";
+    char title[]   = "MONCPU";
+    int cpuutil    = 0;    // einzelne Systemauslastung
+    int cpulimit   = 80;   // Grenzwert
+    int sumstd     = 0;    // Zähler für Stunden über 80%
----
+    // Array mit Testdaten (24 Stunden)
+    int usedCPU[24] = {33,44,40,52,60,56,33,44,40,52,60,56,
+,44,40,52,60,56,33,44,40,52,60,56};
-✅ **Endergebnis:**
+    // Alle 24 Stunden prüfen
+    for (int i = 0; i < 24; i++) {
+        cpuutil = usedCPU[i];
+        if (cpuutil > cpulimit) {
+            sumstd++;
+        }
+    }
-* Dateigröße: **~158 MiB**
+    // Meldung ausgeben, wenn mehr als 18 Stunden über 80 %
-* Übertragungszeit bei 150 Mbit/s: **0:09 Min:Sek**
+    if (sumstd > 18) {
+        printf("%s\n", message);
+    }
----
+    return 0;
+}
+</code>
-Soll ich dir das auch gleich als kleine Rechenvorlage in **DokuWiki-Syntax** ausformulieren, sodass du das für Übungen sofort übernehmen kannst?
+----
+< a2s >
+/opt/stacks/vaultwarden/
+|
++-- .env
++-- docker-compose.yml
++-- data/
++-- backup/
++-- scripts/
+</a2s>