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