Zwei Dimensionles Array

Diskutiere Zwei Dimensionles Array im Java Basics - Anfänger-Themen Bereich.
F

Fynn

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)
 
T

thecain

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
 
M

M.L.

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)" )
 
M

Meniskusschaden

Blender3D

Blender3D

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;
    }
 
L

lennero

Bei solchen Aufgaben helfen Skizzen enorm. Mal dir mal die Koordinatensysteme zu den zwei Beispiel inputs die du hast. Dann sollte alles klarer werden.
 
Blender3D

Blender3D

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.
 
F

Fynn

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!!
 
Blender3D

Blender3D

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.

.
 
L

lennero

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);
    }
 
mrBrown

mrBrown

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;
}
 
Blender3D

Blender3D

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.
 
Thema: 

Zwei Dimensionles Array

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben