forked from IF-LK-2020/array
436 lines
12 KiB
Java
436 lines
12 KiB
Java
|
|
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 ) {
|
|
|
|
if(pNumberOfElements <1){
|
|
int[]randArray=new int[0];
|
|
return randArray;
|
|
}
|
|
int [] randArray=new int[pNumberOfElements];
|
|
for(int i=0;i<randArray.length;i++){
|
|
randArray[i]=getRandomInt(pMin, pMax);
|
|
}
|
|
return randArray;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if(pNumberOfElements <1){
|
|
String[]stringArray=new String[0];
|
|
return stringArray;
|
|
}
|
|
String [] stringArray=new String[pNumberOfElements];
|
|
for(int i=0;i<stringArray.length;i++){
|
|
stringArray[i]="String" + i;
|
|
}
|
|
return stringArray;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return 0;
|
|
}
|
|
|
|
int max = pArray[0];
|
|
for( int i = 1; i < pArray.length; i++ ) {
|
|
if( pArray[i] > max ) {
|
|
max = pArray[i];
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
|
|
/**
|
|
* Berechnet die Summe aller Elemente in
|
|
* einem Zahlen-Array.
|
|
*
|
|
* Für ein leeres Array wird 0 zurück gegeben.
|
|
*/
|
|
public int sum( int[] pArray ) {
|
|
if( pArray.length == 0 ) {
|
|
return 0;
|
|
}
|
|
int sum = 0;
|
|
for( int i = 0; i < pArray.length; i++ ) {
|
|
sum += pArray[i];
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
/**
|
|
* Berechnet den Mittelwert (average) eines
|
|
* Integer-Arrays.
|
|
*
|
|
* Für ein leeres Array wird 0 zurück gegeben.
|
|
*/
|
|
public double avg( int[] pArray ) {
|
|
if( pArray.length == 0 ) {
|
|
return 0;
|
|
}
|
|
double sum = 0;
|
|
for( int i = 0; i < pArray.length; i++ ) {
|
|
sum += pArray[i];
|
|
}
|
|
return sum/pArray.length;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return false;
|
|
}
|
|
for(int i=0;i<pArray.length;i++){
|
|
if(pArray[i]== false){
|
|
return false;
|
|
}
|
|
}
|
|
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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return false;
|
|
}
|
|
for(int i=0;i<pArray.length;i++){
|
|
if(pArray[i]== true){
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return false;
|
|
}
|
|
int sum =0;
|
|
for(int i=0;i<pArray.length;i++){
|
|
if(pArray[i]== true){
|
|
sum++;
|
|
}
|
|
}
|
|
if(sum != 1){
|
|
return false;
|
|
}
|
|
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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return "";
|
|
}
|
|
String sum ="";
|
|
for(int i=0;i<pArray.length;i++){
|
|
|
|
sum=sum+pArray[i];
|
|
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return "";
|
|
}
|
|
String sum ="";
|
|
sum = sum+pArray[0];
|
|
for(int i=1;i<pArray.length;i++){
|
|
|
|
sum=sum+pSep+pArray[i];
|
|
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return new String[0];
|
|
}
|
|
for(int i=0;i<pArray.length;i++){
|
|
|
|
pArray[i]=pPrefix+pArray[i];
|
|
|
|
}
|
|
return pArray;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return new String[0];
|
|
}
|
|
String[] reverse= new String[pArray.length];
|
|
for(int i=0;i<pArray.length;i++){
|
|
reverse[pArray.length-1-i]=pArray[i];
|
|
}
|
|
return reverse;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pArray.length == 0 ) {
|
|
return 0;
|
|
}
|
|
int sum =0;
|
|
for(int i=0;i<pArray.length;i++){
|
|
if(pArray[i]>pValue){
|
|
sum++;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
/**
|
|
* 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 ) {
|
|
if( pNumberOfElements < 1 ) {
|
|
return new int[0];
|
|
}
|
|
int a = 0;
|
|
|
|
int []fib=new int[pNumberOfElements];
|
|
fib[0]=1;
|
|
for(int i=1;i<pNumberOfElements;i++){
|
|
|
|
fib[i]=a+fib[i-1];
|
|
a=fib[i-1];
|
|
}
|
|
return fib;
|
|
}
|
|
|
|
|
|
// 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]);
|
|
}
|
|
}
|
|
|
|
}
|