wiedlje
/
Info10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

21.4.23 

Aufgabe 1 und 2
master
e 2023-04-21 15:27:07 +02:00
parent 1f0f1862f6
commit 69ad5177b2
2 changed files with 383 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
ArrayExperimente.java Normal file
View File

@ -0,0 +1,178 @@
/**
* 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)
{
for (int i=0; i<array.length; i++)
{
if (array[i] == gesucht)
{
return i;
}
}
return -1;
}
/**
* 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...
}
}

205
ArrayExperimenteTest.java Normal file
View File

@ -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};
}