From 25f48e7116b6ba446b3a8bf449e4e738d535ee59 Mon Sep 17 00:00:00 2001
From: q <@>
Date: Fri, 21 Apr 2023 15:34:51 +0200
Subject: [PATCH] erhfejhgfjhwvqfjhverafjvjh4q5vhjr5v
---
Array.java | 28 ++++++
ArrayExperimente.java | 176 ++++++++++++++++++++++++++++++++
ArrayExperimenteTest.java | 205 ++++++++++++++++++++++++++++++++++++++
3 files changed, 409 insertions(+)
create mode 100644 Array.java
create mode 100644 ArrayExperimente.java
create mode 100644 ArrayExperimenteTest.java
diff --git a/Array.java b/Array.java
new file mode 100644
index 0000000..2b7d131
--- /dev/null
+++ b/Array.java
@@ -0,0 +1,28 @@
+
+/**
+ * Beschreiben Sie hier die Klasse Array.
+ *
+ * @author (Ihr Name)
+ * @version (eine Versionsnummer oder ein Datum)
+ */
+public class Array
+{
+ public static void test()
+ {
+ int[] array = new int[10];
+ array[1]= 3;
+ array[2]= 25;
+ array[3]= 40;
+ array[4]= 50;
+ array[6]= 1000;
+ array[7]= 2000;
+ array[8]= 2200;
+ array[9]= 2222;
+ System.out.println(array[1]);
+ for(int i= 0;i< array.length;i++)
+ {
+ System.out.println(array[i]);
+ }
+ }
+
+}
diff --git a/ArrayExperimente.java b/ArrayExperimente.java
new file mode 100644
index 0000000..54f8523
--- /dev/null
+++ b/ArrayExperimente.java
@@ -0,0 +1,176 @@
+
+/**
+ * Uebungen mit Arrays.
+ *
+ * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchfuehren.
+ *
+ * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch
+ * ueberpruefen
+ * - Klicke dazu im Hauptfenster auf Werkzeuge -> Testen -> Tests starten
+ * - 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 ausgegeben werden soll.
+ */
+ public static void arrayAusgeben(int[] array)
+ {
+ for(int i=0; i<array.length; i++)
+ {
+ System.out.println(array[i]);
+ }
+ }
+
+ /**
+ * 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)
+ {
+ for(int i=0; i<array.length; i++)
+ {
+ if(array[i] == gesucht)
+ {
+ return true;
+ }
+
+
+ }
+ 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;
+ }
+
+ /**
+ * Ermittelt die Summe ueber alle Arrayelemente.
+ * @param array Array, das aufaddiert wird.
+ * @returns Summe aller Arrayelemente.
+ */
+ public static int querSumme(int[] array)
+ {
+ // TODO...
+
+ // das return steht hier nur, damit der Compiler nicht meckert:
+ return -32460;
+ }
+
+ /**
+ * 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...
+ }
+
+
+
+ /**
+ * 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..9e39250
--- /dev/null
+++ b/ArrayExperimenteTest.java
@@ -0,0 +1,205 @@
+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
+ * @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.querSumme(testArray));
+
+ testArray = new int[] {0, -43, -41};
+ assertEquals(-84, ArrayExperimente.querSumme(testArray));
+
+ // einelementiges Array:
+ testArray = new int[] {51};
+ assertEquals(51, ArrayExperimente.querSumme(testArray));
+ }
+
+ @Test
+ public void testaddiereJeweilsD()
+ {
+ int[] arrayVorher = new int[] {1, -43, 3, 4, 13, 70, -41};
+ int[] testArray = new int[] {1, -43, 3, 4, 13, 70, -41};
+
+ int dazu = 1;
+ ArrayExperimente.addiereJeweilsD(testArray, dazu);
+
+ int idx = 0;
+ while(idx < testArray.length)
+ {
+ if( testArray[idx] != arrayVorher[idx] + dazu )
+ {
+ fail("Arrays unterscheiden sich an der Position " + idx + "!");
+ }
+ idx ++ ;
+ }
+ }
+
+
+
+ @Test
+ public void testarrayUmdrehen()
+ {
+ // Array mit ungerader Laenge:
+ int[] drehmich = new int[] { 1, -43, 3, 4, 13, 70, -41 };
+ int[] rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+ assertEquals(drehmich.length, rumgedreht.length);
+
+ int idx = 0;
+ while(idx < drehmich.length) {
+ if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+ fail("Ergebnisarray falsch bei Index " + idx + "!");
+ }
+ idx ++ ;
+ }
+
+ // Array mit gerader Laenge:
+ drehmich = new int[] { 1, -43, 3, 4, 70, -41 };
+ rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+ assertEquals(drehmich.length, rumgedreht.length);
+
+ idx = 0;
+ while(idx < drehmich.length) {
+ if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+ fail("Ergebnisarray falsch bei Index " + idx + "!");
+ }
+ idx ++ ;
+ }
+
+ // Array mit Laenge 1:
+ drehmich = new int[] { 1 };
+ rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+ assertEquals(drehmich.length, rumgedreht.length);
+
+ idx = 0;
+ while(idx < drehmich.length) {
+ if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+ fail("Ergebnisarray falsch bei Index " + idx + "!");
+ }
+ idx ++ ;
+ }
+ }
+
+
+
+ private boolean[][] binaer =
+ {
+ { false, false, false, false, false, false, false, false } , /* 0 */
+ { false, true , true , true , true , true , true , true } , /* 127 */
+ { false, false, false, false, false, true , true , true } , /* 7 */
+ { false, true , true , false, false, false, false, false } , /* 96 */
+ { false, false, true , false, false, true , false, false } , /* 36 */
+ { false, false, false, false, false, true , false, true } , /* 5 */
+ { false, false, false, false, false, true , false, false } , /* 4 */
+ { false, false, false, true , false, false, false, true } , /* 17 */
+ { false, true , false, false, false, false, false, true } , /* 65 */
+ { false, false, false, false, false, false, false, true } , /* 1 */
+
+ };
+
+ private byte[] dezimal = { 0, 127, 7, 96, 36, 5, 4, 17, 65, 1};
+
+
+}