From 066f0190d960eab467598972bb5207c010e66d39 Mon Sep 17 00:00:00 2001
From: Domen <@>
Date: Fri, 4 Apr 2025 15:31:08 +0200
Subject: [PATCH] i want to kms and i want it riiight awayyy yeaaah yeahhh
---
ArrayExperimente.java | 229 ++++++++++++++++++++++++++++++++++++++
ArrayExperimenteTest.java | 206 ++++++++++++++++++++++++++++++++++
Doppelschleifen.java | 12 ++
3 files changed, 447 insertions(+)
create mode 100644 ArrayExperimente.java
create mode 100644 ArrayExperimenteTest.java
diff --git a/ArrayExperimente.java b/ArrayExperimente.java
new file mode 100644
index 0000000..5d039fe
--- /dev/null
+++ b/ArrayExperimente.java
@@ -0,0 +1,229 @@
+
+/**
+ * Uebungen mit Arrays.
+ *
+ * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchfuehren.
+ *
+ * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch
+ * ueberpruefen
+ * - Klicke mit der rechten Maustaste auf die ArrayExperimenteTest (grün)
+ * -> "Alles Testen"
+ * - Sobald du glaubst, eine Funktion fertig programmiert zu haben,
+ * startest du die Tests und ueberzeugst dich im Testergebnisfenster,
+ * dass der Test fuer diese Funktion erfolgreich durchgelaufen ist.
+ * - Falls er fehlschlaegt, kannst du dort auf den entsprechenden Test klicken
+ * und nachschauen, was genau fehlgeschlagen ist.
+ *
+ */
+public class ArrayExperimente
+{
+ public static int beispiel[]= new int[] {1, 3, 4, -13, 0, 70, -111};
+ public static int nochnArray[]= new int[] {20,21,22,23,24,25,26};
+
+ /**
+ * Gibt das uebergebene Array auf der Konsole aus.
+ * @param array, das Array, das ausgegeben werden soll.
+ */
+ public static void arrayAusgeben(int[] array)
+ {
+ for(int i=0; i<array.length; i++) // Durchläuft das ganze Array
+ {
+ System.out.println(array[i]); // und gebe dein Eintrag an der Stelle i aus
+ }
+ }
+
+
+ /**
+ * Zum Ausprobieren: Erstellt ein neues int-Array und füllt alle Einträge mit 42
+ * anschließend wird das Array auf der Konsole ausgegeben
+ */
+ public static void zumAusprobieren()
+ {
+ //Erstellt ein neues int-Array
+ int[] meinArray = new int[10];
+
+ //Gehe mit einer vor Schleife durch dass Array
+ for(int i=0; i<meinArray.length; i++)
+ {
+ //TODO: Hier musst du nurnoch den jeweiligen Wert mit 42 belegen
+ }
+
+ //Gebe das Array auf der Konsole aus
+ arrayAusgeben(meinArray);
+ }
+
+ /**
+ * Zum Ausprobieren: Wie eben, nur jetzt soll das Array mit den Werten
+ * 0, 1, 2, ... 9 belegt werden
+ */
+ public static void zumAusprobieren2()
+ {
+ //TODO:
+ //Erstelle ein neues Array und belege es mit den Einträgen 0 bis 9
+ //Du brauchst wieder eine for-Schleife
+ //Gebe anschließend das das Array auf der Konsole aus
+ }
+
+
+
+ /**
+ * Der Funktion wird ein Array übergeben.
+ * Die Funktion erhoeht nun jeden Eintrag um eins.
+ * Es wird kein neues Array angelegt.
+ * @param array Zu manipulierendes Array. Es darf nicht leer sein.
+ */
+ public static void addiereJeweilsEins(int[] array)
+ {
+ // TODO...
+ //Du brauchst wieder eine for-Schleife
+ }
+
+
+
+ /**
+ * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag".
+ * Es wird kein neues Array angelegt.
+ * @param array Zu manipulierendes Array. Es darf nicht leer sein.
+ * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert.
+ */
+ public static void addiereJeweilsD(int[] array, int zuschlag)
+ {
+ // TODO...
+ }
+
+
+
+ /**
+ * Ermittelt die Summe ueber alle Arrayelemente.
+ * @param array Array, das aufaddiert wird.
+ * @returns Summe aller Arrayelemente.
+ */
+ public static int summe(int[] array)
+ {
+ // TODO...
+ //Hinweis: Du benötigst eine Variable
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -32460;
+ }
+
+
+
+ /**
+ * Ermittelt, ob ein Wert im Array vorkommt, d.h. ob
+ * eines der Arrayelemente diesen Wert hat.
+ * @param gesucht zu suchender Wert.
+ * @param array Array, in dem gesucht wird.
+ * @returns ob gesucht im Array vorkommt.
+ */
+ public static boolean istEnthalten(int gesucht, int[] array)
+ {
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return false;
+ }
+
+
+
+ /**
+ * Ermittelt, an welchem Index im Array der Wert "gesucht" vorkommt.
+ * @param gesucht Wert, nach dem im Array gesucht wird.
+ * @param array Array, in dem gesucht wird.
+ * @returns den Index, an dem gesucht im Array vorkommt; -1, falls es
+ * nicht vorkommt.
+ */
+ public static int indexVon(int gesucht, int[] array)
+ {
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -3245646;
+ }
+
+
+
+ /**
+ * Ermittelt den Wert des groessten im Array enthaltenen Elements.
+ * @param array Array, in dem gesucht wird. Es darf
+ * nicht leer sein.
+ * @returns Den groessten vorkommenden Wert.
+ */
+ public static int maxWert(int[] array)
+ {
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -346;
+ }
+
+
+
+ /**
+ * Ermittelt den Index des groessten im Array enthaltenen Elements.
+ * @param array Array, in dem gesucht wird.
+ * @returns Den Index des groessten vorkommenden Werts.
+ */
+ public static int maxIndex(int[] array)
+ {
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -324688;
+
+ }
+
+
+
+ /**
+ * Ermittelt den Index des groessten im Array enthaltenen Elements.
+ * @param array Array, in dem gesucht wird.
+ * @returns Den Index des groessten vorkommenden Werts.
+ */
+ public static int maxIndexKuerzer(int[] aray)
+ {
+ // TODO: Formuliere diese Funktion als Einzeiler, indem du
+ // Funktionen, die du oben schon geschrieben hast, geschickt aufrufst.
+ // Diese Variante einfacher zu formulieren als mit einer Schleife
+ // (braucht allerdings mehr Rechenschritte).
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -3244786;
+ }
+
+
+ /**
+ * Erstellt ein neues Array, in dem die Elemente des
+ * urspruenglichen Array in der umgekehrten Reihenfolge drin sind.
+ * @param array urspruengliches Array, darf nicht null sein
+ * @returns neues Array mit umgekehrter Reihenfolge.
+ */
+ public static int[] arrayUmdrehen(int[] array)
+ {
+ // fuer diese Funktion darf man ein neues Array anlegen, das
+ // die Eintraege von wendeArray in umgedrehter Reihenfolge enthaelt.
+
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return null;
+
+
+ }
+
+ /**
+ * Dreht im bestehenden Array dessen Elemente in
+ * die umgekehrte Reihenfolge. Man sagt, die Funktion bearbeitet
+ * das Array "in place".
+ * @param wendeArray urspruengliches Array
+ */
+ public static void arrayUmdrehenInPlace(int[] array)
+ {
+ // Diese Funktion loest die gleiche Aufgabe wie die obere, darf
+ // dafuer aber KEIN zusaetzliches Array benutzen, sondern muss
+ // (bis auf einzelne int-Variable) im wendeArray arbeiten.
+ // TODO...
+ }
+
+
+}
diff --git a/ArrayExperimenteTest.java b/ArrayExperimenteTest.java
new file mode 100644
index 0000000..8479ecb
--- /dev/null
+++ b/ArrayExperimenteTest.java
@@ -0,0 +1,206 @@
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import java.util.Arrays;
+
+/**
+ * The test class ArrayExperimenteTest.
+ *
+ * @author Urs Lautebach
+ * überarbeitet Ho, 24
+ * @version 2017-10
+ */
+public class ArrayExperimenteTest
+{
+ /**
+ * Sets up the test fixture.
+ *
+ * Called before every test case method.
+ */
+ @Before
+ public void setUp()
+ {
+ }
+
+ /**
+ * Tears down the test fixture.
+ *
+ * Called after every test case method.
+ */
+ @After
+ public void tearDown()
+ {
+ }
+
+ @Test
+ public void testistEnthalten()
+ {
+ int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+ assertTrue(ArrayExperimente.istEnthalten(1000, testArray));
+ assertTrue(ArrayExperimente.istEnthalten(-41, testArray));
+ assertTrue(ArrayExperimente.istEnthalten(1, testArray));
+ assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+
+ testArray = new int[] {66};
+ assertTrue(ArrayExperimente.istEnthalten(66, testArray));
+ assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+
+ testArray = new int[] {};
+ assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+ }
+
+ @Test
+ public void testindexVon()
+ {
+ int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+ assertEquals(0, ArrayExperimente.indexVon(1, testArray));
+ assertEquals(1, ArrayExperimente.indexVon(-43, testArray));
+ assertEquals(9, ArrayExperimente.indexVon(-41, testArray));
+ assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+
+ testArray = new int[] {66};
+ assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+ assertEquals(0, ArrayExperimente.indexVon(66, testArray));
+
+ testArray = new int[] {};
+ assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+ }
+
+
+
+ @Test
+ public void testmaxWert()
+ {
+ int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+ assertEquals(1000, ArrayExperimente.maxWert(testArray));
+
+ testArray = new int[] {0, -43, -41};
+ assertEquals(0, ArrayExperimente.maxWert(testArray));
+
+ testArray = new int[] {-43, -41};
+ assertEquals(-41, ArrayExperimente.maxWert(testArray));
+
+ testArray = new int[] {66};
+ assertEquals(66, ArrayExperimente.maxWert(testArray));
+ }
+
+ @Test
+ public void testmaxIndex()
+ {
+ int[] testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41};
+ assertEquals(2, ArrayExperimente.maxIndex(testArray));
+
+ testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41, 5367};
+ assertEquals(8, ArrayExperimente.maxIndex(testArray));
+
+ testArray = new int[] {0, -43, -41};
+ assertEquals(0, ArrayExperimente.maxIndex(testArray));
+
+ testArray = new int[] {-43, -41};
+ assertEquals(1, ArrayExperimente.maxIndex(testArray));
+
+ testArray = new int[] {-41};
+ assertEquals(0, ArrayExperimente.maxIndex(testArray));
+ }
+
+ @Test
+ public void testquersumme()
+ {
+ int[] testArray = new int[] {1, -43, 3, 4, 13, 70, -41};
+ assertEquals(7, ArrayExperimente.summe(testArray));
+
+ testArray = new int[] {0, -43, -41};
+ assertEquals(-84, ArrayExperimente.summe(testArray));
+
+ // einelementiges Array:
+ testArray = new int[] {51};
+ assertEquals(51, ArrayExperimente.summe(testArray));
+ }
+
+ @Test
+ public void testaddiereJeweilsEins()
+ {
+ int[] test = new int[] {1, -43, 3, 4, 13, 70, -41};
+ int[] ergebnis = new int[] {2, -42, 4, 5, 14, 71, -40};
+
+ ArrayExperimente.addiereJeweilsEins(test);
+
+ assertArrayEquals(ergebnis, test);
+
+ }
+
+ @Test
+ public void testaddiereJeweilsD()
+ {
+ int[] test = new int[] {1, -43, 3, 4, 13, 70};
+ int d = 5;
+ int[] ergebnis = new int[] {6, -38, 8, 9, 18, 75};
+
+
+ ArrayExperimente.addiereJeweilsD(test, d);
+
+ assertArrayEquals(ergebnis, test);
+ }
+
+
+
+ @Test
+ public void testarrayUmdrehen()
+ {
+ // Array mit ungerader Laenge:
+ int[] test = new int[] { 1, -43, 3, 4, 13, 70, -41 };
+ int[] umgedreht = ArrayExperimente.arrayUmdrehen(test);
+ int[] ergebnis = new int[] { -41, 70, 13, 4, 3, -43, 1 };
+
+ assertEquals(ergebnis.length, umgedreht.length);
+ assertArrayEquals(ergebnis, umgedreht);
+
+ // Array mit gerader Laenge:
+ test = new int[] { 1, -43, 3, 4, 70, -41 };
+ umgedreht = ArrayExperimente.arrayUmdrehen(test);
+ ergebnis = new int[] {-41, 70, 4, 3, -43, 1};
+
+ assertEquals(ergebnis.length, umgedreht.length);
+ assertArrayEquals(ergebnis, umgedreht);
+
+ // Array mit Laenge 1:
+ test = new int[] { 1 };
+ ergebnis = new int[] {1};
+ umgedreht = ArrayExperimente.arrayUmdrehen(test);
+
+ assertEquals(ergebnis.length, umgedreht.length);
+ assertArrayEquals(ergebnis, umgedreht);
+ }
+
+ @Test
+ public void testarrayUmdrehenInPlace()
+ {
+ // Array mit ungerader Laenge:
+ int[] test = new int[] { 1, -43, 3, 4, 13, 70, -41 };
+ ArrayExperimente.arrayUmdrehenInPlace(test); //test umdrehen
+ int[] ergebnis = new int[] { -41, 70, 13, 4, 3, -43, 1 };
+
+ assertEquals(ergebnis.length, test.length);
+ assertArrayEquals(ergebnis, test);
+
+ // Array mit gerader Laenge:
+ test = new int[] { 1, -43, 3, 4, 70, -41 };
+ ArrayExperimente.arrayUmdrehenInPlace(test);
+ ergebnis = new int[] {-41, 70, 4, 3, -43, 1};
+
+ assertEquals(ergebnis.length, test.length);
+ assertArrayEquals(ergebnis, test);
+
+ // Array mit Laenge 1:
+ test = new int[] { 1 };
+ ergebnis = new int[] {1};
+ ArrayExperimente.arrayUmdrehenInPlace(test);
+
+ assertEquals(ergebnis.length, test.length);
+ assertArrayEquals(ergebnis, test);
+ }
+
+
+
+}
diff --git a/Doppelschleifen.java b/Doppelschleifen.java
index b7accb9..c260c49 100644
--- a/Doppelschleifen.java
+++ b/Doppelschleifen.java
@@ -29,4 +29,16 @@ public class Doppelschleifen
}
}
+
+ public static int muster(int n){
+
+ for(int a = 1; a<=n; a++){
+
+ for(int b = 1;b <=a; b++){
+ System.out.print("*");
+ }
+ System.out.println();
+ }
+ return n;
+}
}