public class Toolbox {
	
	/* evenSum: */
    
    public static int evenSum(int n) {
    	// Zahl <n> gerade machen, falls ungerade (Bsp.: -5 -> -4, 7 -> 6, 2 -> 2):
    	// TO DO
    	
    	// Ergebnis der Hilfsmethode zurückgeben:
    	// TO DO
    }

    /** 
     * Prüft rekursiv, ob eine Zahl gerade (true) ist oder nicht (false). 
     */
    private static boolean isEven(int n) {
    	// Rekursionsanker:
        // TO DO
        
        // Rekursive Berechnung:
        // TO DO
    }
    
    /** 
     * Hilfsfunktion, welche das tut, was evenSum tun soll, als Parameter 
     * aber einen geraden Wert erwartet. 
     */
    private static int evenSumHelper(int n) {    	
        // TO DO
    }
    
    
    /* multiplication: */    

    public static int multiplication(int x, int y) {
    	// Rekursionsanker:
        // TO DO
        
        // Rekursionsvorschrift:
        // TO DO
    }
    
    
    /* reverse: */

    public static void reverse(int[] m) {
        // rufe Hilfsmethode mit passenden Parametern auf
    }
    
    /** 
     * Vertauscht das Element am Index <pos> (beginnend beim ersten Element)
     * mit dem Element am Index <pos> rückwärts gezählt und fährt rekursiv
     * mit allen dazwischenliegenden Elementen fort.
     * 
     * Beispiel: reverse([1,2,3,4,5], 0) = 
     *           reverse([5,2,3,4,1], 1) = 
     *           reverse([5,4,3,2,1], 2) = 
     *           [5,4,3,2,1] 
     */
    private static void reverse(int[] m, int pos) {
    	// Rekursionsanker: Mitte erreicht
        // TO DO
        
        // Tausche am Index <pos>:
        // TO DO
        
        // Rekursiv mit nächster Position fortfahren:
        // TO DO
    }

    
    /* numberOfOddIntegers: */
    
    public static int numberOfOddIntegers(int[] m) {
        // rufe Hilfsmethode auf
    }
    
    /**
     * Hilfsmethode, welche als Parameter den Index übergeben bekommt, ab dem
     * die Anzahl ungerader Zahlen bestimmen soll. Dieser Index wird wie in
     * einer Schleife pro rekursivem Aufruf um 1 erhöht. Es wird dann jeweils
     * (pro rekursivem Aufruf) nur der Eintrag (im Array) an der Stelle <pos> 
     * betrachtet. Um alle darauffolgenden Zahlen kümmert sich der rekursive
     * Aufruf.
     */
    private static int numberOfOddIntegers(int[] m, int pos) {
    	// Rekursionsanker (alle Elemente aus m behandelt):
        // TO DO
        
        // Prüfe, ob Element an der aktuellen Position ungerade ist. Wenn ja,
        // dann addiere 1 zum rekursiven Aufruf mit dem nächsten Index:
        // TO DO
    }
    
    
    /* filterOdd: */

    public static int[] filterOdd(int[] m) {
    	// Erzeuge ein Array passender Größe:
    	// TO DO
    	
    	// Befülle das erzeugte Array mit der Hilfsmethode und gib es zurück:
        // TO DO
    }
    
    /**
     * Hilfsmethode, die das Ursprungsarray <m> mit einem dazugehörigen
     * Zähler <from> und das Ergebnisarray <result> mit einem zugehörigen
     * Zähler <to> erwartet. Die Methode betrachtet jeweils das Element
     * an der Position <from> und kopiert es in das Ergebnisarray (an
     * die Position <to>), falls es ungerade ist.
     */
    private static void filterOdd(int[] m, int[] result, int from, int to) {
    	// Rekursionsanker (alle Element aus m behandelt):
        // TO DO
        
        // Wenn Element an aktueller Position gerade ist, dann ohne Änderung
        // am Zielarray oder Zielposition mit nächstem Index rekursiv fortfahren.
        // Ansonsten vor dem Fortfahren Element kopieren und Zielzähler erhöhen:
        // TO DO
    }
}