maxim.derksen
/
array
forked from IF-LK-2020/array
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial commit

This commit is contained in:
Jonas Neugebauer 2020-08-25 22:52:43 +02:00
commit 99f1bb2c79
4 changed files with 740 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.gitignore vendored Normal file
View File

@ -0,0 +1,25 @@
# ---> Java
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

311
Arrays.java Normal file
View File

@ -0,0 +1,311 @@
import java.util.Random;
/**
* Verschiedene Übungen zu Arrays.
*
* TODO:
* Implementiere die Methoden nach der Beschreibung im jeweiligen
* Kommentar. Teste deine Umsetzungen regelmäßig mit den Test-Methoden
* in der Klasse {@link ArraysTest}.
*
* Du kannst die Methoden in beliebiger Reihenfolge implementieren. Such
* dir also die für dich interessantesten raus.
*
* Einige Methoden sind schon vollständig implementiert, und können
* als Beispiel dienen. Die Methoden {@link #printArray(int[])},
* {@link #printArray(String[])} und {@link #printArray(boolean[])}
* geben ein Array auf der Kommandozeile aus und können bei der Fehlersuche
* helfen. Denke auch daran, den Debugger zu nutzen.
*/
public class Arrays {
// Interner Zufallsgenerator
private Random rand;
public Arrays() {
// Neuen Zufallsgenerator erstellen
rand = new Random();
}
/**
* Erstellt ein Integer-Array mit <var>pNumberOfElements</var>
* zufällig gewählten Zahl-Elementen im Bereich <var>pMin</var>
* bis <var>pMax</var> (exklusive).
*
* Wird ein negativer Wert für die Anzahl Elemente angegeben,
* dann wird ein leeres Array zurück gegeben.
*
* @see #getRandomInt(int, int)
*/
public int[] generateIntArray( int pNumberOfElements, int pMin, int pMax ) {
return null;
}
/**
* Erzeugt eine Zufallszahl zwischen <var>pMin</var>
* und <var>pMax</var> (exklusive).
*/
private int getRandomInt( int pMin, int pMax ) {
return rand.nextInt(pMax-pMin)+pMin;
}
/**
* Erstellt ein String-Array mit <var>pNumberOfElements</var>
* Text-Elementen der Form <code>String 1</code>, <code>String 2</code>.
*
* Wird ein negativer Wert für die Anzahl Elemente angegeben,
* dann wird ein leeres Array zurück gegeben.
*/
public String[] generateStringArray( int pNumberOfElements ) {
return null;
}
/**
* Erstellt ein Boolean-Array mit <var>pNumberOfElements</var>
* zufällig gewählten Wahrheitswerten.
*
* Wird ein negativer Wert für die Anzahl Elemente angegeben,
* dann wird ein leeres Array zurück gegeben.
*
* @see Random#nextBoolean()
*/
public boolean[] generateBooleanArray( int pNumberOfElements ) {
if( pNumberOfElements < 1 ) {
return new boolean[0];
}
boolean[] result = new boolean[pNumberOfElements];
for( ; pNumberOfElements > 0; pNumberOfElements-- ) {
result[pNumberOfElements-1] = rand.nextBoolean();
}
return result;
}
/**
* Sucht in einem Integer-Array das kleinste Element.
*
* Für ein leeres Array wird 0 zurück gegeben.
*/
public int min( int[] pArray ) {
if( pArray.length == 0 ) {
return 0;
}
int min = pArray[0];
for( int i = 1; i < pArray.length; i++ ) {
if( pArray[i] < min ) {
min = pArray[i];
}
}
return min;
}
/**
* Sucht in einem Integer-Array das größte Element.
*
* Für ein leeres Array wird 0 zurück gegeben.
*/
public int max( int[] pArray ) {
return 0;
}
/**
* Berechnet die Summe aller Elemente in
* einem Zahlen-Array.
*
* Für ein leeres Array wird 0 zurück gegeben.
*/
public int sum( int[] pArray ) {
return 0;
}
/**
* Berechnet den Mittelwert (average) eines
* Integer-Arrays.
*
* Für ein leeres Array wird 0 zurück gegeben.
*/
public double avg( int[] pArray ) {
return 0;
}
/**
* Prüft, ob <b>alle</b> Elemente in einem Array von
* Wahrheitswerten <code>true</code> sind. Sonst wird
* <code>false</code> zurück gegeben.
*
* Für ein leeres Array wird <code>false<code> zurück gegeben.
*/
public boolean and( boolean[] pArray ) {
return true;
}
/**
* Prüft, ob <b>mindestens ein</b> Element in einem Array von
* Wahrheitswerten <code>true</code> ist. Sonst wird
* <code>false</code> zurück gegeben.
*
* Für ein leeres Array wird <code>false<code> zurück gegeben.
*/
public boolean or( boolean[] pArray ) {
return true;
}
/**
* Prüft, ob <b>genau ein</b> Element in einem Array von
* Wahrheitswerten <code>true</code> ist. Sonst wird
* <code>false</code> zurück gegeben. (Bei keinmal <code>true</code>
* oder mehr als einmal <code>true</code>.)
*
* Für ein leeres Array wird <code>false<code> zurück gegeben.
*/
public boolean xor( boolean[] pArray ) {
return true;
}
/**
* Erzeugt aus einem String-Array einen neuen String,
* in dem alle Elemente des Arrays hintereinander
* verknüpft sind.
*
* Aus <code>["String 1","String 2"]</code> wird <code>"String 1String 2"</code>.
*
* (Der <code>+</code> Operator verknüpft zwei Strings miteinander:
* <code>"Foo" + "Bar"</code> ergibt <code>"FooBar"</code>.)
*
* Für ein leeres Array wird ein leerer String zurück gegeben.
*/
public String concat( String[] pArray ) {
return "";
}
/**
* Erzeugt aus einem String-Array einen neuen String,
* in dem alle Elemente des Arrays durch <var>pSep</var> getrennt
* hintereinander verknüpft sind.
*
* Aus <code>["String 1","String 2"]</code> wird mit dem Aufruf
* <code>pSep = ";"</code> zum Beispiel <code>"String 1;String 2"</code>.
*
* Für ein leeres Array wird ein leerer String zurück gegeben.
*/
public String join( String[] pArray, String pSep ) {
return "";
}
/**
* Setzt vor jeden String im Array das Prefix <var>pPrefix</var> und gibt
* das Array mit den veränderten Werten zurück.
*
* Aus <code>["String 1","String 2"]</code> wird mit <code>pPrefix = "+"</code>
* zum Beispiel <code>["+String 1","+String 2"]</code>.
*/
public String[] prefix( String[] pArray, String pPrefix ) {
return null;
}
/**
* Erstellt ein neues String-Array, in dem die Elemente aus <var>pArray</var>
* in umgekehrter Reihenfolge vorkommen.
*
* Aus <code>["String 1","String 2"]</code> wird zum Beispiel
* <code>["String 2","String 1"]</code>.
*/
public String[] reverse( String[] pArray ) {
return null;
}
/**
* Zählt, wie viele Elemente im Zahlen-Array
* größer als <var>pValue</var> sind.
*
* Für <code>pArray = int[]{1,2,3,4,5}</code> und
* <code>pValue = 3</var> wäre das Ergebnis dann
* <code>2</code>.
*
* Für ein leeres Array wird 0 zurück gegeben.
*/
public int over( int[] pArray, int pValue ) {
return 0;
}
/**
* Erstellt ein Integer-Array mit den ersten <var>pNumberOfElements</var>
* Fibonacci-Zahlen.
*
* Die ersten sechs Fibonacci-Zahlen sind: 1,1,2,3,5,8,...
*
* (Wenn du nicht weißt, was die Fibonacci-Zahlen sind hilft Wikipedia.)
*
* Wird ein negativer Wert für die Anzahl Elemente angegeben,
* dann wird ein leeres Array zurück gegeben.
*/
public int[] generateFibonacci( int pNumberOfElements ) {
return null;
}
// Ausgabe-Methoden
// Ab hier ist schon alles implementiert :)
/**
* Gibt die Elemente eines Integer-Array auf der Kommandozeile aus.
*/
public void printArray( int[] pArray ) {
boolean first = true; // Nötig um nicht zu viele Kommata zu setzen
// Zählschleife für den Durchlauf durchs Arrays
for( int i = 0; i < pArray.length; i++ ) {
// Kommata als Trenner
if( !first ) {
System.out.print(",");
} else {
first = false;
}
// Array-Element ausgeben
System.out.print(pArray[i]);
}
}
/**
* Gibt die Elemente eines String-Array auf der Kommandozeile aus.
*/
public void printArray( String[] pArray ) {
boolean first = true; // Nötig um nicht zu viele Kommata zu setzen
// Zählschleife für den Durchlauf durchs Arrays
for( int i = 0; i < pArray.length; i++ ) {
// Kommata als Trenner
if( !first ) {
System.out.print(",");
} else {
first = false;
}
// Array-Element ausgeben
System.out.print(pArray[i]);
}
}
/**
* Gibt die Elemente eines Boolean-Array auf der Kommandozeile aus.
*/
public void printArray( boolean[] pArray ) {
boolean first = true; // Nötig um nicht zu viele Kommata zu setzen
// Zählschleife für den Durchlauf durchs Arrays
for( int i = 0; i < pArray.length; i++ ) {
// Kommata als Trenner
if( !first ) {
System.out.print(",");
} else {
first = false;
}
// Array-Element ausgeben
System.out.print(pArray[i]);
}
}
}

362
ArraysTest.java Normal file
View File

@ -0,0 +1,362 @@
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
/**
* Test-Klasse für Array-Übungen.
*/
public class ArraysTest {
private Arrays arrays;
@Before
public void setUp() {
arrays = new Arrays();
}
@Test
public void testGenerateIntArray() {
int[] arr;
for( int i = 0; i < 50; i += 5 ) {
arr = arrays.generateIntArray(i, 0, 100);
assertNotNull("Int-Array darf nicht <null> sein.", arr);
assertEquals("Arraylänge passt nicht.", i, arr.length);
}
arr = arrays.generateIntArray(-6, 0, 100);
assertEquals("Bei negativer pNumberOfElements muss das Array leer sein.", 0, arr.length);
}
@Test
public void testGenerateStringArray() {
String[] arr;
for( int i = 0; i < 50; i += 5 ) {
arr = arrays.generateStringArray(i);
assertNotNull("String-Array darf nicht <null> sein.", arr);
assertEquals("Arraylänge passt nicht.", i, arr.length);
}
arr = arrays.generateStringArray(-8);
assertEquals("Bei negativer pNumberOfElements muss das Array leer sein.", 0, arr.length);
}
@Test
public void testGenerateBooleanArray() {
boolean[] arr;
for( int i = 0; i < 50; i += 5 ) {
arr = arrays.generateBooleanArray(i);
assertNotNull("Boolean-Array darf nicht <null> sein.", arr);
assertEquals("Arraylänge passt nicht.", i, arr.length);
}
arr = arrays.generateBooleanArray(-4);
assertEquals("Bei negativer pNumberOfElements muss das Array leer sein.", 0, arr.length);
}
@Test
public void testMin() {
int min;
min = arrays.min(new int[]{1,4,12,15,28});
assertEquals("min(1,4,12,15,28)", 1, min);
min = arrays.min(new int[]{5,4,3,2,1,0});
assertEquals("min(5,4,3,2,1,0)", 0, min);
min = arrays.min(new int[]{1,2,3,4,5,-6,-7,-8});
assertEquals("min(1,2,3,4,5,-6,-7,-8)", -8, min);
min = arrays.min(new int[]{10000});
assertEquals("min(10000)", 10000, min);
min = arrays.min(new int[]{});
assertEquals("min()", 0, min);
}
@Test
public void testMax() {
int max;
max = arrays.max(new int[]{1,4,12,15,28});
assertEquals("max(1,4,12,15,28)", 28, max);
max = arrays.max(new int[]{5,4,3,2,1,0});
assertEquals("max(5,4,3,2,1,0)", 5, max);
max = arrays.max(new int[]{1,2,3,4,5,-6,-7,-8});
assertEquals("max(1,2,3,4,5,-6,-7,-8)", 5, max);
max = arrays.max(new int[]{-10000});
assertEquals("max(-10000)", -10000, max);
max = arrays.max(new int[]{});
assertEquals("max()", 0, max);
}
@Test
public void testSum() {
int sum;
sum = arrays.sum(new int[]{1,4,12,15,28});
assertEquals(60, sum);
sum = arrays.sum(new int[]{5,4,3,2,1,0});
assertEquals(15, sum);
sum = arrays.sum(new int[]{1,2,3,4,5,-6,-7,-8});
assertEquals(-6, sum);
sum = arrays.sum(new int[]{-10000,10000});
assertEquals(0, sum);
sum = arrays.sum(new int[]{4});
assertEquals(4, sum);
sum = arrays.sum(new int[]{});
assertEquals(0, sum);
}
@Test
public void testAvg() {
double avg;
avg = arrays.avg(new int[]{1,4,12,15,28});
assertEquals(12.0, avg, 0.0001);
avg = arrays.avg(new int[]{5,4,3,2,1,0});
assertEquals(2.5, avg, 0.0001);
avg = arrays.avg(new int[]{1,2,3,4,5,-6,-7,-8});
assertEquals(-0.75, avg, 0.0001);
avg = arrays.avg(new int[]{-10000,10000});
assertEquals(0.0, avg, 0.0001);
avg = arrays.avg(new int[]{4});
assertEquals(4.0, avg, 0.0001);
avg = arrays.avg(new int[]{});
assertEquals(0.0, avg, 0.0001);
}
@Test
public void testAnd() {
boolean bln;
bln = arrays.and(new boolean[]{true,true,true,true});
assertTrue(bln);
bln = arrays.and(new boolean[]{true});
assertTrue(bln);
bln = arrays.and(new boolean[]{true,false,true,true});
assertFalse(bln);
bln = arrays.and(new boolean[]{false,false,false,false});
assertFalse(bln);
bln = arrays.and(new boolean[]{false});
assertFalse(bln);
bln = arrays.and(new boolean[]{});
assertFalse(bln);
}
@Test
public void testOr() {
boolean bln;
bln = arrays.or(new boolean[]{true,true,true,true});
assertTrue(bln);
bln = arrays.or(new boolean[]{true});
assertTrue(bln);
bln = arrays.or(new boolean[]{true,false,true,true});
assertTrue(bln);
bln = arrays.or(new boolean[]{false,false,false,false});
assertFalse(bln);
bln = arrays.or(new boolean[]{false});
assertFalse(bln);
bln = arrays.or(new boolean[]{});
assertFalse(bln);
}
@Test
public void testXor() {
boolean bln;
bln = arrays.xor(new boolean[]{true,true,true,true});
assertFalse(bln);
bln = arrays.xor(new boolean[]{true});
assertTrue(bln);
bln = arrays.xor(new boolean[]{true,false,true,true});
assertFalse(bln);
bln = arrays.xor(new boolean[]{true,false,false,false});
assertTrue(bln);
bln = arrays.xor(new boolean[]{false,false,false,false});
assertFalse(bln);
bln = arrays.xor(new boolean[]{false,false,false,true});
assertTrue(bln);
bln = arrays.xor(new boolean[]{false});
assertFalse(bln);
bln = arrays.xor(new boolean[]{});
assertFalse(bln);
}
@Test
public void testConcat() {
String str;
str = arrays.concat(new String[]{"Foo","Bar"});
assertEquals("FooBar", str);
str = arrays.concat(new String[]{"Foo","Bar","Foo"});
assertEquals("FooBarFoo", str);
str = arrays.concat(new String[]{});
assertEquals("", str);
}
@Test
public void testJoin() {
String str;
str = arrays.join(new String[]{"Foo","Bar"}, ";");
assertEquals("Foo;Bar", str);
str = arrays.join(new String[]{"Foo","Bar","Foo"}, "----");
assertEquals("Foo----Bar----Foo", str);
str = arrays.join(new String[]{}, "");
assertEquals("", str);
}
@Test
public void testPrefix() {
String[] arr;
arr = arrays.prefix(new String[]{"Foo","Bar","Hello"}, "--");
assertNotNull(arr);
assertEquals(3, arr.length);
assertEquals("--Foo", arr[0]);
assertEquals("--Bar", arr[1]);
assertEquals("--Hello", arr[2]);
arr = arrays.prefix(new String[]{}, "");
assertNotNull(arr);
assertEquals(0, arr.length);
}
@Test
public void testReverse() {
String[] arr;
arr = arrays.reverse(new String[]{"Foo","Bar","Hello"});
assertNotNull(arr);
assertEquals(3, arr.length);
assertEquals("Hello", arr[0]);
assertEquals("Bar", arr[1]);
assertEquals("Foo", arr[2]);
arr = arrays.reverse(new String[]{"Foo","Bar"});
assertNotNull(arr);
assertEquals(2, arr.length);
assertEquals("Bar", arr[0]);
assertEquals("Foo", arr[1]);
arr = arrays.reverse(new String[]{});
assertNotNull(arr);
assertEquals(0, arr.length);
}
@Test
public void testOver() {
int count;
count = arrays.over(new int[]{1,4,12,15,28}, 10);
assertEquals(3, count);
count = arrays.over(new int[]{1,4,12,15,28}, 2);
assertEquals(4, count);
count = arrays.over(new int[]{1,4,12,15,28}, 28);
assertEquals(0, count);
count = arrays.over(new int[]{1,4,12,15,28}, -100);
assertEquals(5, count);
count = arrays.over(new int[]{1}, 1);
assertEquals(0, count);
count = arrays.over(new int[]{1}, 2);
assertEquals(0, count);
count = arrays.over(new int[]{1}, 0);
assertEquals(1, count);
count = arrays.over(new int[]{}, 0);
assertEquals(0, count);
count = arrays.over(new int[]{}, 100);
assertEquals(0, count);
count = arrays.over(new int[]{}, -10);
assertEquals(0, count);
}
@Test
public void testGenerateFibonacci() {
int[] fib;
fib = arrays.generateFibonacci(1);
assertNotNull(fib);
assertEquals(1, fib.length);
assertEquals(1, fib[0]);
fib = arrays.generateFibonacci(2);
assertNotNull(fib);
assertEquals(2, fib.length);
assertEquals(1, fib[0]);
assertEquals(1, fib[1]);
fib = arrays.generateFibonacci(4);
assertNotNull(fib);
assertEquals(4, fib.length);
assertEquals(1, fib[0]);
assertEquals(1, fib[1]);
assertEquals(2, fib[2]);
assertEquals(3, fib[3]);
fib = arrays.generateFibonacci(6);
assertNotNull(fib);
assertEquals(6, fib.length);
assertEquals(1, fib[0]);
assertEquals(1, fib[1]);
assertEquals(2, fib[2]);
assertEquals(3, fib[3]);
assertEquals(5, fib[4]);
assertEquals(8, fib[5]);
fib = arrays.generateFibonacci(0);
assertNotNull(fib);
assertEquals(0, fib.length);
fib = arrays.generateFibonacci(-4);
assertNotNull(fib);
assertEquals(0, fib.length);
}
}

42
package.bluej Executable file
View File

@ -0,0 +1,42 @@
#BlueJ package file
dependency1.from=ArraysTest
dependency1.to=Arrays
dependency1.type=UsesDependency
editor.fx.0.height=738
editor.fx.0.width=1052
editor.fx.0.x=232
editor.fx.0.y=7
objectbench.height=130
objectbench.width=1256
package.divider.horizontal=0.6
package.divider.vertical=0.8099861303744799
package.editor.height=577
package.editor.width=1145
package.editor.x=0
package.editor.y=0
package.frame.height=820
package.frame.width=1296
package.numDependencies=1
package.numTargets=2
package.showExtends=true
package.showUses=true
project.charset=UTF-8
readme.height=58
readme.name=@README
readme.width=47
readme.x=10
readme.y=10
target1.height=170
target1.name=ArraysTest
target1.showInterface=false
target1.type=UnitTestTargetJunit4
target1.width=140
target1.x=400
target1.y=50
target2.height=160
target2.name=Arrays
target2.showInterface=false
target2.type=ClassTarget
target2.width=180
target2.x=110
target2.y=190