Zwei Dimensionles Array

Hallo, ich habe hier eine Aufgabe die ich überhaupt nicht verstehe und keine Ahnung habe was der Sinn überhaupt sein soll? Deshalb kann ich das auch nicht programmieren wenn ich die Aufgabe nicht verstehe kann ich mir auch keine Anleitung dazu bauen. Kann mir jemand helfen diese Aufgabe zu lösen und falls jemand den Sinn versteht mir das erklären kann? Die aufgäbe steht unten. Und auch was der Output des Programms sein soll.
Danke im Voraus.

Ich habe ein Array mit Zufallszahlen und damit soll ich:

2. Interpret the array as a time series. The first entry is the first time with the associated value etc. 3. Write a function to determine the maximum decrease in the time series. Please note that this decrease can extend over several points in time (see example)

Given: 10, 5, 6, 2, 7
Return value: 8 (10 - 2)

Given: -4, -5, 10, 9, 8, 12
Return value: 2 (10 - 8)
 
Du sollst die grösste Abnahme angeben, welche in der Serie auftritt und diese kann sich über mehrere Elemente bilden.

Zwischen den zwei Elementen darf die Zahl aber nie grösser werden, sonst zählt es nicht
 
Es gilt das maximale und minimale Element der Arrays zu ermitteln (wobei die Nebenbedingung zu beachten ist). Die ermittelten Zahlen sind dann voneinander zu subtrahieren. Für 10, 5, 6, 2, 7 : max. 10, min. 2 Für -4, -5, 10, 9, 8, 12 (negative Zahlen entfallen): max. 12, min. 8 (passt aber nicht ganz zu "Return value: 2 (10 - 8)" )
 
2. Interpret the array as a time series. The first entry is the first time with the associated value etc. 3. Write a function to determine the maximum decrease in the time series. Please note that this decrease can extend over several points in time (see example)

Given: 10, 5, 6, 2, 7
Return value: 8 (10 - 2)

Given: -4, -5, 10, 9, 8, 12
Return value: 2 (10 - 8)
Ich denke, dass das so gedacht ist.
Java:
int[] test1 = { 10, 5, 6, 2, 7 };
        int[] test2 = { -4, -5, 10, 9, 8, 12 };       
        getMaxTimeDecrease(test1);
        getMaxTimeDecrease(test2);
Java:
    public static int getMaxTimeDecrease(int[] timeSpans) {
        int max = Integer.MIN_VALUE;
        int timeStart = 0;
        int timeEnd = 0;

        for (int current = 0; current < timeSpans.length - 1; current++) {
            int start = current + 1;
            for (int i = start; i < timeSpans.length; i++) {
                int diff = timeSpans[current] - timeSpans[i];
                if (diff > max) {
                    timeStart = timeSpans[current];
                    timeEnd = timeSpans[i];
                    max = diff;
                }
            }
        }
        System.out.println(max + " (" + timeStart + "-" + timeEnd + ")");
        return max;
    }
 
Bei solchen Aufgaben helfen Skizzen enorm. Mal dir mal die Koordinatensysteme zu den zwei Beispiel inputs die du hast. Dann sollte alles klarer werden.
 
Bei solchen Aufgaben helfen Skizzen enorm. Mal dir mal die Koordinatensysteme zu den zwei Beispiel inputs die du hast. Dann sollte alles klarer werden.
Und vielleicht die Aufgabenstellung etwas klarer zu formulieren.

Given: 10, 5, 6, 2, 7
Return value: 8 (10 - 2)

Given: -4, -5, 10, 9, 8, 12
Return value: 2 (10 - 8)

Interpretieren Sie das Array als eine Serie von Zeitspannen.
Für alle a,b Element des Array ist b Nachfolger von a wenn Index(a) < Index(b)
Zeitspanne:= (a, Nachfolger(a) )
Schreiben sie eine Funktion, um die Zeitspanne mit dem größten Abnahme zu ermitteln und geben Sie diese zurück.
 
Ich denke, dass das so gedacht ist.
Java:
int[] test1 = { 10, 5, 6, 2, 7 };
        int[] test2 = { -4, -5, 10, 9, 8, 12 };      
        getMaxTimeDecrease(test1);
        getMaxTimeDecrease(test2);
Java:
    public static int getMaxTimeDecrease(int[] timeSpans) {
        int max = Integer.MIN_VALUE;
        int timeStart = 0;
        int timeEnd = 0;

        for (int current = 0; current < timeSpans.length - 1; current++) {
            int start = current + 1;
            for (int i = start; i < timeSpans.length; i++) {
                int diff = timeSpans[current] - timeSpans[i];
                if (diff > max) {
                    timeStart = timeSpans[current];
                    timeEnd = timeSpans[i];
                    max = diff;
                }
            }
        }
        System.out.println(max + " (" + timeStart + "-" + timeEnd + ")");
        return max;
    }
Danke!!
 
Und danach kann er zur Erfolgskontrolle versuchen, den Algorithmus auf lineare Laufzeit zu drücken
So wie ich das sehe wird das schwierig werden da die Anzahl der zu untersuchenden Zeitspannen sich auf

#Zeitspannen := ((n-1)*n)/2 = O(n^2) belaufen.
Beispiel:
{a,b,c,d} -> {(a,b),(a,c),(a,d)} -> {(b,c),(b,d)} -> {(c,d)}
n = 4 -> 4*3/2 = 6
Man kann vielleicht alles in einer Schleife unterbringen, aber die Laufzeit bleibt wohl n^2.

.
 
Nicht wirklich optimal aber müsste linear sein
Java:
public static void largestDistance(int[] a)
    {
        int n = a.length;
        int t1 = 0;
        int t2 = 0;
        int i = 0;
        int j = 1;
        int maxDistance = Integer.MIN_VALUE;
        while(j <= n - 1)
        {
            if(a[i] > a[j])
            {
                if(a[i] - a[j] > maxDistance)
                {
                    t1 = a[i];
                    t2 = a[j];
                    maxDistance = t1 - t2;
                }
                j++;
            }
            else if(a[j] > a[i] && i < j)
            {
                i++;
            }
            else
                j++;
        }
        System.out.println(t1 + " - " + t2 + " = " + maxDistance);
    }
 
Java:
static int getMaxTimeDecrease(int... ints) {
    int max = Integer.MIN_VALUE;
    int maxDist = Integer.MIN_VALUE;

    for (final int anInt : ints) {
        max = Math.max(max, anInt);
        maxDist = Math.max(max - anInt, maxDist);
    }

    return maxDist;
}
 
static int getMaxTimeDecrease(int... ints) { int max = Integer.MIN_VALUE; int maxDist = Integer.MIN_VALUE; for (final int anInt : ints) { max = Math.max(max, anInt); maxDist = Math.max(max - anInt, maxDist); } return maxDist; }
Ist offensichtlich linear entspricht aber nicht der Aufgabenstellung.

Java:
int[]
        test1 = { 10, 5, 6, 2, 7 };              
        System.out.println(getMaxTimeDecrease(test1));
Liefert 8 anstatt 2.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben