# Teilarray von einem Array (Integer)



## Terence86 (25. Dez 2016)

Hallo Zusammen,
Zur Aufgabenstellung :
Schreiben Sie eine Klasse Felder mit einer Klassenmethode istTeilFeld(int[] f, int[] t), die
einen Wahrheitswert zurückgibt, ob die Wertefolge in t einen zusammenhängenden Teil der Wertefolge in f bildet (immer wahr, wenn t leer).
Beispiel: true für {51,2,8,33,17,2,2,7} als f und {8,33,17,2} als t .

Ich habe mir schon eine Lösung überlegt die auch für meine Beispiele die ich getestet habe soweit funktioniert. Nun zu meiner Frage, macht es Sinn die Summen der Arrays zu vergleichen?
Also in Sachen Laufzeit bei riesigen Arrays. Wenn zum Beispiel die ersten tausend gleich sind aber dann einer kommt der falsch ist. Werden die Summen schneller abgearbeitet als die ganzen Indexe zu vergleichen? (Kernfrage)
Code:

```
public static boolean istTeilFeld(int[] f, int[] t) {
        if (f.length < t.length) { // Wenn Teil-Array größer ist false
            return false;
        }
        if (t.length == 0) { // Wenn Teil-Array Null ist true.
            return true;
        }

        int sumF = 0; // Summe von F.
        int sumT = 0; // SUmme von T.

        sumF = summeFeld(f, 0, f.length);
        sumT = summeFeld(t, 0, t.length);

        if (sumF < sumT) { // Wenn Summe von T größer als F, kannt T kein
                            // Teilarray von F sein.
            return false;
        }
        boolean help = true;
        for (int i = 0; i < f.length - t.length; i++) {  //Weiter muss die Schleife nicht laufen
            if (f[i] == t[0]) {
                int[] a = new int[t.length];  // Neuer Teilarray von f mit der Länge t .
                for (int o = 0; o < t.length; o++) {
                    a[o] = f[i + o];
                }
                // if (sumT == summeFeld(f, i, (i + t.length))) {
                if (istGleich(a, t)) {
                    System.out.println("Ab Index der Stelle: " + i + " in dem Array F.");
                    return true;
                }
                help = false;
            }
        }
        return help;

    }

    public static int summeFeld(int[] a, int indexAnfang, int indexEnde) { // Summenberechnung
                                                                            // als
                                                                            // neue
                                                                            // Mehtode.

        int summe = 0;
        for (int i = indexAnfang; i < indexEnde; i++) {
            summe += a[i];
        }
        return summe;
    }

    public static boolean istGleich(int[] a, int[] b) {

        if (a == b)
            return true;
        for (int i = 0; i < a.length; i++) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
    }
```
Könnte dann auch den Vergleich der Summen am Anfang weglassen.


----------



## thecain (25. Dez 2016)

nein


----------



## Terence86 (25. Dez 2016)

Alles klar dann schenk ich mir den Summen-Vergleich.


----------

