meddl

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...
+    }
+
+   
+}

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);
+    }
+
+   
+    
+}

Methoden.java

@@ -34,4 +34,50 @@ public class Methoden
         }
         return L;
     }
+    
+    public static double max( double a, double b)
+    {
+        if(a > b){
+            return a;
+        }
+        else{
+            return b;
+        }
+        }
+        
+        public static double min( double a, double b)
+    {
+        if(a < b){
+            return a;
+        }
+        else{
+            return b;
+        }
+        }
+        
+        public static double abs( double a)
+    {
+        if(a < 0){
+            return a*-1;
+        }
+        else{
+            return a;
+        }
+        }
+        
+         public static boolean istGroß( double a)
+    {
+        if(a>1000){
+            return true;
+        }
+        else{
+            return false;
+        }
+        }
+        
+    public static boolean istBetragmäßigGroß( double a){
+            return istGroß(abs(a));
+    }
 }
+    
+