import java.util.ArrayList;

public class Eksempeloppgaver {

    public static void main(String[] args) {
        System.out.println("Sum til N");
        System.out.println("n=1: " + sumTilN(1)); // 1
        System.out.println("n=2: " + sumTilN(2)); // 1 + 2
        System.out.println("n=3: " + sumTilN(3)); // 1 + 2 + 3
        System.out.println("n=10: " + sumTilN(10)); // 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1

        System.out.println("Finn minste tall");
        int[] tall1 = new int[] {3};
        int[] tall2 = new int[] {4, 8};
        int[] tall3 = new int[] {3, 56, 32, 35, 1, 98};
        System.out.println("tall1: " + finnMinsteTall(tall1));
        System.out.println("tall2: " + finnMinsteTall(tall2));
        System.out.println("tall3: " + finnMinsteTall(tall3));

        System.out.println("Finn antall av");
        ArrayList<Integer> original = new ArrayList<>();
        original.add(2);
        original.add(1);
        original.add(1);
        original.add(2);
        original.add(1);
        original.add(2);
        original.add(2);
        // Lager kopier siden metodene bruker .remove()
        ArrayList<Integer> kopi1 = new ArrayList<>(original);
        ArrayList<Integer> kopi2 = new ArrayList<>(original);
        System.out.println(finnAntallAv(kopi1, 1));
        System.out.println(finnAntallAvVersjon2(kopi2, 1));
    }


    // Skriv en rekursiv metode int sumTilN(int n) som tar inn et positivt heltall n, og regner ut og returnerer summen av alle tallene fra 1 til og med n.
    public static int sumTilN(int n) {
        if (n == 1) {
            return 1;
        }
        
        return n + sumTilN(n - 1);

        // Med det foerste kallet sumTilN(3), blir det slik:
        // 3 + sumTilN(2)
        // 3 + 2 + sumTilN(1)
        // 3 + 2 + 1
    }

    // --------------------------------------------

    // Skriv en rekursiv metode som gitt et array av intĄŻer returnerer det minste tallet i arrayet.
    public static int finnMinsteTall(int[] tall) {
        int minst = finnMinst(tall, 0, 100000);
        return minst;
    }

    public static int finnMinst(int[] tall, int indeks, int minst) {
        if (indeks == tall.length) {
            return minst;
        }

        if (tall[indeks] < minst) {
            minst = tall[indeks];
        }

        minst = finnMinst(tall, indeks + 1, minst);
        return minst;
    }

    
    /*
    finnminst([4, 8], 0, 1000000) => {
        minst = 4 //siden 4 < 1000000

        minst = finnMinst([4, 8], 1, 4) => {
            minst = finnMinst([4, 8], 2, 4) => {
                    // indeks == tall.length, saa returnerer
                    return 4;
                }
            // minst er naa satt til 4 her inne
            return minst; // returner 4
            }
        // minst er naa satt til 4 her inne

        return minst // returner 4
        }
    */



    // ---------------------------------------------


    // Skriv en rekursiv metode som tar inn en arraylist av tall, og et tall ? lete etter. Metoden teller antall ganger tallet forekommer i listen.

    // [2, 3, 4, 2], 2 => 2
    // [2], 8 => 0


    // [], 1 => 0
    // [1], 1 => 1
    // [1, 2], 1 => 1

    public static int finnAntallAv(ArrayList<Integer> tall, int letEtter) {
        return finn(tall, letEtter, 0);
    }

    public static int finn(ArrayList<Integer> tall, int letEtter, int sum) {
        if (tall.isEmpty()) {
            return sum;
        }

        int t = tall.remove(0);
        if (t == letEtter) {
            sum += 1;
        }

        sum = finn(tall, letEtter, sum);
        return sum;
    }


    public static int finnAntallAvVersjon2(ArrayList<Integer> tall, int letEtter) {
        return finn(tall, letEtter, 0);
    }

    public static int finnVersjon2(ArrayList<Integer> tall, int letEtter) {
        if (tall.isEmpty()) {
            return 0;
        }

        int sum = 0;
        int t = tall.remove(0);
        if (t == letEtter) {
            sum += 1;
        }

        sum += finn(tall, letEtter, sum);
        return sum;
    }
}