erhfejhgfjhwvqfjhverafjvjh4q5vhjr5v
q
parent
885b20415c
commit
25f48e7116
|
|
@ -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]);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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...
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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};
|
||||
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue