commit 99f1bb2c797be632668fb31458c6e7d3a7d63522 Author: Jonas Neugebauer Date: Tue Aug 25 22:52:43 2020 +0200 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..84adb3f --- /dev/null +++ b/.gitignore @@ -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* + diff --git a/Arrays.java b/Arrays.java new file mode 100644 index 0000000..28a9700 --- /dev/null +++ b/Arrays.java @@ -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 pNumberOfElements + * zufällig gewählten Zahl-Elementen im Bereich pMin + * bis pMax (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 pMin + * und pMax (exklusive). + */ + private int getRandomInt( int pMin, int pMax ) { + return rand.nextInt(pMax-pMin)+pMin; + } + + /** + * Erstellt ein String-Array mit pNumberOfElements + * Text-Elementen der Form String 1, String 2. + * + * 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 pNumberOfElements + * 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 alle Elemente in einem Array von + * Wahrheitswerten true sind. Sonst wird + * false zurück gegeben. + * + * Für ein leeres Array wird false zurück gegeben. + */ + public boolean and( boolean[] pArray ) { + return true; + } + + /** + * Prüft, ob mindestens ein Element in einem Array von + * Wahrheitswerten true ist. Sonst wird + * false zurück gegeben. + * + * Für ein leeres Array wird false zurück gegeben. + */ + public boolean or( boolean[] pArray ) { + return true; + } + + /** + * Prüft, ob genau ein Element in einem Array von + * Wahrheitswerten true ist. Sonst wird + * false zurück gegeben. (Bei keinmal true + * oder mehr als einmal true.) + * + * Für ein leeres Array wird false 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 ["String 1","String 2"] wird "String 1String 2". + * + * (Der + Operator verknüpft zwei Strings miteinander: + * "Foo" + "Bar" ergibt "FooBar".) + * + * 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 pSep getrennt + * hintereinander verknüpft sind. + * + * Aus ["String 1","String 2"] wird mit dem Aufruf + * pSep = ";" zum Beispiel "String 1;String 2". + * + * 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 pPrefix und gibt + * das Array mit den veränderten Werten zurück. + * + * Aus ["String 1","String 2"] wird mit pPrefix = "+" + * zum Beispiel ["+String 1","+String 2"]. + */ + public String[] prefix( String[] pArray, String pPrefix ) { + return null; + } + + /** + * Erstellt ein neues String-Array, in dem die Elemente aus pArray + * in umgekehrter Reihenfolge vorkommen. + * + * Aus ["String 1","String 2"] wird zum Beispiel + * ["String 2","String 1"]. + */ + public String[] reverse( String[] pArray ) { + return null; + } + + /** + * Zählt, wie viele Elemente im Zahlen-Array + * größer als pValue sind. + * + * Für pArray = int[]{1,2,3,4,5} und + * pValue = 3 wäre das Ergebnis dann + * 2. + * + * 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 pNumberOfElements + * 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]); + } + } + +} diff --git a/ArraysTest.java b/ArraysTest.java new file mode 100644 index 0000000..ad7803b --- /dev/null +++ b/ArraysTest.java @@ -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 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 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 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); + } + +} diff --git a/package.bluej b/package.bluej new file mode 100755 index 0000000..e3d4157 --- /dev/null +++ b/package.bluej @@ -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