Info10Rep/ArrayExperimente.java

/**
 * 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...
    }

   
}