public class Arrays {
    
    public static void print(int[] feld) {
        String output = "{"; // soll mit geschweiften Klammern beginnen/enden
        
        // Erstes bis vorletztes (wegen fehlendem Komma) Element nach und
        // nach an den Ausgabestring anhängen (alternativ direkt Ausgabe):
        for (int i = 0; i <= feld.length-2; i++)
            output += feld[i] + ", ";
        
        // Letztes Element ohne Komma anfügen (sofern vorhanden).
        if (feld.length > 0)
            output += feld[feld.length-1];
        
        System.out.println(output + "}"); // ausgeben
    }
    
    public static void minUndMax(int[] feld) {
        if (feld.length < 1) {
            System.out.println("Fehler: Ein leeres Array hat weder ein maximales"
                    + " noch ein minimales Element.");
            return; // nicht weitermachen
        }
        
        // wir nehmen initial den kleinsten bzw. und größten Wert an
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        
        // durch das Feld gehen und größeren/kleineren Wert in min/max speichern
        for (int i = 0; i < feld.length; i++) {
            if (feld[i] < min)
                min = feld[i];
            if (feld[i] > max)
                max = feld[i];
        }
        
        System.out.println("Minimum = " + min + ", Maximum = " + max);
    }

    public static int[] invertieren(int[] feld) {
        // wir brauchen ein neues Array um das alte nicht zu verändern
        int[] invertiert = new int[feld.length];
        
        // geschickt durch das Array gehen (length-i "kehrt" die Reihenfolge um)
        for (int i = 0; i < feld.length; i++)
            invertiert[i] = feld[feld.length-1-i];
        
        return invertiert;
    }
    
    public static int[] schneiden(int[] feld, int laenge) {
        // neues Array für die Rückgabe anlegen
        int[] ret = new int[laenge];
        
        // maximale Länge zum kopieren ermitteln
        int maxLength = laenge; // Annahme
        if (feld.length < laenge) // feld ist kürzer als das neue Array
            maxLength = feld.length;
        
        // Elemente kopieren
        for (int i = 0; i < maxLength; i++)
            ret[i] = feld[i];
        
        return ret;
    }
    
    public static int[] linearisieren(int[][] feld) {        
        // zuerst müssen wir die Länge des linearisierten Array ermitteln
        int newLen = 0;
        for (int i = 0; i < feld.length; i++)
            newLen += feld[i].length;
        
        // neues Array anlegen, in dem dann gespeichert wird
        int[] linearisiert = new int[newLen];
        
        // Zählervariable, um an der richtigen Position speichern zu können
        int c = 0; // wir starten natürlich bei Index 0
        
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld[i].length; j++) {
                // wir speichern an die nächste freie Position im linearisierten
                // Array, erhöhen danach entsprechend die Zählervariable auf die
                // nächste freie Position:
                linearisiert[c++] =  feld[i][j];
            }
        }
        
        return linearisiert;
    }
    
    
    
    public static void main(String[] args) {
        final int ARRAY_MAX_LEN = 6;
        final int AMOUNT_ARRAYS = 20;
        final int RAND_MAX_VALUE = 10;
        
        java.util.Random R = new java.util.Random();
        
        System.out.println("Welche Funktion möchtest du testen?"
                + "\n\t1 = print\n\t2 = minUndMax\n\t3 = invertieren"
                + "\n\t4 = scheiden\n\t5 = linearisieren");
        int input = new java.util.Scanner(System.in).nextInt();
        
        if (input >= 1 && input <= 4) {
            int[][] arrays = new int[AMOUNT_ARRAYS][];
            String[] arraysAsString = new String[AMOUNT_ARRAYS];

            for (int a = 0; a < AMOUNT_ARRAYS; a++) {
                arrays[a] = new int[R.nextInt(ARRAY_MAX_LEN)];            
                for (int i = 0; i < arrays[a].length; i++)
                    arrays[a][i] = R.nextInt(RAND_MAX_VALUE);            
                arraysAsString[a] = java.util.Arrays.toString(arrays[a]);
            }

            for (int a = 0; a < AMOUNT_ARRAYS; a++) {
                switch (input) {
                    case 1:
                        System.out.print("print(" + arraysAsString[a] + "): ");
                        print(arrays[a]); break;
                    case 2:
                        System.out.print("minUndMax(" + arraysAsString[a] + "): ");
                        minUndMax(arrays[a]); break;
                    case 3:
                        System.out.print("invertieren(" + arraysAsString[a] + "): ");
                        System.out.println(java.util.Arrays.toString(invertieren(arrays[a]))); break;
                    case 4:
                        int s = R.nextInt(ARRAY_MAX_LEN);
                        System.out.print("schneiden(" + arraysAsString[a] + ", " + s + "): ");
                        System.out.println(java.util.Arrays.toString(schneiden(arrays[a], s)));
                        break;
                }
                System.out.println();
            }
        } else if (input == 5) {
            int[][][] arrays = new int[AMOUNT_ARRAYS][][];
            String[] arraysAsString = new String[AMOUNT_ARRAYS];

            for (int a = 0; a < AMOUNT_ARRAYS; a++) {
                arrays[a] = new int[R.nextInt(ARRAY_MAX_LEN)][];
                arraysAsString[a] = "[";
                for (int b = 0; b < arrays[a].length; b++) {
                    arrays[a][b] = new int[R.nextInt(ARRAY_MAX_LEN)];   
                    for (int i = 0; i < arrays[a][b].length; i++)
                        arrays[a][b][i] = R.nextInt(RAND_MAX_VALUE);
                    arraysAsString[a] += java.util.Arrays.toString(arrays[a][b]);
                    if (b != arrays[a].length-1)
                        arraysAsString[a] += ", ";
                }
                arraysAsString[a] += "]";
                
                System.out.print("linearisieren(" + arraysAsString[a] + "):\n -> ");
                System.out.println(java.util.Arrays.toString(linearisieren(arrays[a]))+"\n");
            }
        }
    }
}