# Maximale Differenz



## Neuling0211 (25. Mrz 2018)

Hi Leute, 

wie mein Benutzername ja schon zu erkenne gibt, bin ich echt neu hier und habe eine echt schwere Aufgabe zu bewältigen, die weder ich noch jemand aus meinem Kurs versteht oder durchblickt. Das Problem ist der Kursleiter hat kein Mitleid und hat den Abgabetermin heute in einer Woche angesetzt.  Falls also jemand sehr begabt unter euch ist und Mitleid mit Neulingen hat, bitte um Hilfe!!

Folgende Aufgabe ist gestellt worden:

• Maximale Differenz:

 Gegeben sei eine Folge von ganzen Zahlen, dargestellt als Feld f[1:n] für n≥0. Entwirf einen Algorithmus, der die maximale Differenz zwischen zwei benachbarten Werten in dieser Folge berechnet. Für n≤1 soll das Ergebnis 0 sein. Eine Funktion int abs(↓int x) zur Berechnung des Absolutbetrags kann vorausgesetzt,werden. 
Beispiele: 1 2 3 4 5 => 1
 6 9 13 2 –5 0 => 11 
1 1 1 => 0


----------



## Robat (25. Mrz 2018)

Wie stellst du dir die Hilfe denn vor?
Unlösbar ist die Aufgabe jedenfalls nicht. Was genau verstehst du nicht?


----------



## Javinner (25. Mrz 2018)

Neuling0211 hat gesagt.:
			
		

> Das Problem ist der Kursleiter hat kein Mitleid und hat den Abgabetermin heute in einer Woche angesetzt


Das Problem sehe ich an einer ganz anderen Stelle 
Zeig doch mal dein Lösungsversuch, benutze dabei die Code-Tags.


----------



## Xyz1 (25. Mrz 2018)

Neuling0211 hat gesagt.:


> Beispiele: 1 2 3 4 5 => 1
> 6 9 13 2 –5 0 =>



Das ist oben kein normales Minuszeichen....
Profis hätten das wohl so gemacht:

```
public static void main(String[] args) {
        int td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{, }).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();

        td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{1,}).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();

        td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{2, 3,}).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();

        //////

        td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{1, 2, 3, 4, 5,}).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();

        td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{6, 9, 13, 2, -5, 0,}).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();

        td = 0;
        for (Iterator<Integer> iterator = new SubIntIter(new int[]{1, 1, 1,}).iterator(); iterator.hasNext();) {
            Integer x = iterator.next();
            Integer y = iterator.next();
            int d = d(x, y);
            if (d > td) {
                td = d;
            }
        }
        System.out.println("td = " + td);
        System.out.println();
    }

    static int d(int ax, int ay) {
        int size = Math.abs(ax - ay);
        return size;
    }
}

class SubIntIter implements Iterable<Integer> {
    int[] array;

    SubIntIter(int[] array) {
        this.array = array;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int c = 0;
            int d = 0;

            @Override
            public boolean hasNext() {
                return c < ((array.length << 1) - 2);
            }

            @Override
            public Integer next() {
                return array[(c++ / 2) + (d++ % 2)];
            }
        };
    }
}
```


```
td = 0

td = 0

td = 1

td = 1

td = 11

td = 0
```

(An einigen Stellen noch verkomplizierter, aber besser lesbar aufgemalt  )


----------



## Xyz1 (25. Mrz 2018)

Aber google nochmal nach "java difference between two ints"
Da bin ich hier gelandet: https://stackoverflow.com/questions/38078503/how-to-get-the-difference-between-two-integers
Wenn ax sehr klein UND ay sehr groß, könnte es da unerwünschte Probleme geben.
Außerdem müssen jede Schleife noch ausrefactored werden in jw Methoden.


----------



## mrBrown (25. Mrz 2018)

DerWissende hat gesagt.:


> Profis hätten das wohl so gemacht:


Profis hätten das mit Sicherheit nicht so gemacht, nur Leute mit sehr viel Selbstüberschätzung halten das für eine "Profi-Lösung".


----------



## Xyz1 (25. Mrz 2018)

@mrBrown Du hast keine A....
Achne ich wollte ja nicht unfreundlich sein...
@Neuling0211 Beherzige einfach die zwei Hinweise mit der d-Methode und der zusätzlichen Methode und
@ Moderator Thematitel nachträglich geändert, denn es wurde nach Profis gefragt.


----------



## DrZoidberg (25. Mrz 2018)

DerWissende hat gesagt.:


> Das ist oben kein normales Minuszeichen....
> Profis hätten das wohl so gemacht: ...


Hör bitte auf Anfänger zu trollen.
Iteratoren galten vielleicht in den 90ern mal als professionelle Lösung aber heutzutage machen echte Profis sowas natürlich mit Lambda Ausdrücken.

Hier mal ein stark vereinfachter Lösungsansatz:

```
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
import java.util.function.Consumer;
import java.util.function.BiConsumer;

public class MaxDiff {
 
  @SuppressWarnings("unchecked")
  static <T> void groupElems(Supplier<T> s, Consumer<Supplier<List<T>>> c) {
    final Object[] lastElem = {null};
  
    c.accept(() -> {
      T a;
      if(lastElem[0] != null) {
        a = (T)lastElem[0];
      } else {
        a = s.get();
      }
      T b = s.get();
      lastElem[0] = b;
      return Arrays.asList(a,b);
    });
  }
 
  static <T> void listToSupplier(List<T> list, Consumer<Supplier<T>> c) {
    final int[] idx = {0};
  
    c.accept(() -> list.get(idx[0]++));
  }
 
  @SuppressWarnings("unchecked")
  static <T, U> void mapSupplier(Supplier<T> s, BiConsumer<T, Consumer<U>> f, Consumer<Supplier<U>> c) {
    c.accept(() -> {
      final Object[] a = {null};
      f.accept(s.get(), r -> {
        a[0] = r;
      });
      return (U)a[0];
    });
  }
 
  static <T> void forEach(Supplier<T> s, Consumer<T> c) {
    try {
      while(true) {
        c.accept(s.get());
      }
    } catch(IndexOutOfBoundsException e) {
    }
  }
 
  static void findMax(Supplier<Integer> s, Consumer<Integer> c) {
    final int[] max = {0};
  
    forEach(s, d -> {
      if(d > max[0]) max[0] = d;
    });
  
    c.accept(max[0]);
  }
 
  static void abs(int n, Consumer<Integer> c) {
    if(n < 0) {
      c.accept(-n);
    } else {
      c.accept(n);
    }
  }
 
  public static void main(String[] args) {
    Integer[] numbers = {6, 9, 13, 2, -5, 0};
    List<Integer> list = Arrays.asList(numbers);
  
    listToSupplier(list, s -> {
      groupElems(s, s2 -> {
        mapSupplier(s2, (List<Integer> l, Consumer<Integer> c) -> abs(l.get(0) - l.get(1), c), s3 -> {
          findMax(s3, max -> {
            System.out.println(max);
          });
        });
      });
    });
  }
}
```


----------



## Flown (25. Mrz 2018)

@DrZoidberg ist das dein ernst? o0


----------



## mrBrown (25. Mrz 2018)

Ich hoffe einfach mal auf Sarkasmus...


----------



## Elenteria (26. Mrz 2018)

Was du hier Tun musst ist definitiv nicht unmöglich.

1. Setzte den Maximalwert auf 0.
2. Gehe die Folge vom Ersten bis zum Vorletzten Element durch.
  2.1. Berechne die Differenz aus dem aktuellen Element mit dem Darauffolgendem
  2.2. Ist die Differenz größer als der aktuelle Maximalwert, setzte den Maximalwert auf die Differenz
3. Gib den Maximalwert zurück.


----------



## Neuling0211 (26. Mrz 2018)

*Wow Danke!*
An alle die sich hier beteiligt haben richtet sich ein fettes Dankeschön!

Das Ganze scheint ja hinzuhauen und zu funktionieren nur habe ich Bedenken dass der Kursleiter hier nicht Verdacht schöpft, denn vieles was da im Quellcode steht, haben wir eigentlich noch garnicht gelernt 
Und als Streber habe ich auf Ihn wohl kaum gewirkt haha...
Könnte jemand eine vereinfachte Variante schreiben, auch wenn das für euch Profis wahrscheinlich schwerer ist als die eigentliche Funktion. 
* Bitte um Hilfe!!* LG


----------



## mrBrown (26. Mrz 2018)

Ignorier die beiden Code-Beispiele, das ist beides nur trollen und keine wirkliche Hilfe und hat absolut nichts mit "gutem" Programmieren zu tun.


Wo hängt es denn bei dir? die nötigen Schritte stehen ja in #11


----------



## Elenteria (26. Mrz 2018)

https://www.java-forum.org/thema/di...schleichen-von-loesungen-fuer-aufgaben.63088/

Phase 3: 
Ihr seid doch Profis, für euch ist das doch leicht


----------



## DrZoidberg (26. Mrz 2018)

Also die Code-Beispiele, die bis jetzt gepostet wurden, solltest du natürlich nicht verwenden. Die waren alle nicht ganz ernst gemeint. Da würde dein Kursleiter ganz sicher Verdacht schöpfen.
Nimm lieber das hier

```
public class MaxDiff {
  public static void main(String[] args) {
    int[] zahlen = {6, 9, 13, 2, -5, 0};
    int max = 0;
    for(int i = 0; i < zahlen.length - 1; i++) {
      int d = Math.abs(zahlen[i] - zahlen[i+1]);
      if(d > max) max = d;
    }
    System.out.println(max);
  }
}
```
Du kannst auch versuchen den Code noch etwas abzuändern, damit er grössere Ähnlichkeit mit dem hat, was ihr bisher im Kurs besprochen habt.


----------



## Javinner (26. Mrz 2018)

mrBrown hat gesagt.:


> Wo hängt es denn bei dir?


Ich denke, daran.. 


> Könnte jemand eine vereinfachte Variante schreiben


----------



## Neuling0211 (26. Mrz 2018)

@DrZoidberg Vielen Dank, das sieht super aus.
Ist zwar keine Variante, wo der Benutzer die Zahlenfolge eingibt(bis 0 eingegeben wird), ist aber meine Schuld da ich es nicht erwähnt habe.

Und für alle die meinen ich will mir hier bloß Lösungen ergattern, ich habe extra am Anfang geschrieben: Sollte jemand Mitleid mit mir und meinen Kollegen haben. Ergo diejenigen, auf die das zutrifft sind so lieb und helfen, die anderen sollten sich nicht mal angesprochen fühlen.


----------



## Javinner (26. Mrz 2018)

@Neuling0211 
Mitleid.. wenn ich es schön höre  Hiermit klinke ich mich aus..


----------



## Meniskusschaden (26. Mrz 2018)

Neuling0211 hat gesagt.:


> die anderen sollten sich nicht mal angesprochen fühlen.


Na ja, man kann es auch einfach armselig finden. Die Aufgabe ist so einfach, dass man sie auch dann lösen können sollte, wenn an der immer wieder kehrenden Ausrede mit dem ungeeigneten Kursleiter etwas dran wäre. Mitleid ist da wirklich unangebracht.


----------



## Xyz1 (26. Mrz 2018)

mrBrown hat gesagt.:


> und hat absolut nichts mit "gutem" Programmieren zu tun


Woher willst du denn wissen was gut/schlecht...
Achne, vielleicht ist es besser zu ignorieren. 

@DrZoidberg Du kapselst das ja in zusätzliche Tupel.... unnötig, wie ich meine.
@Neuling0211 Das Problem ist vielleicht das von euch vielleicht so etwas verlangt wird wie in #15 steht und steht es ja da schon....
Obwohl zoid sich auch nicht egal ist, ob da ein underflow stattfindet oder nicht....
@Meniskusschaden Ob der Kursleiter un-geeignet ist ist doch unerheblich....


----------



## DefconDev (1. Apr 2018)

Also sollte ich die Aufgabe richtig verstehen, ist die Aufgabe ziemlich simple. Defakto hast du ein Array mit werten deren jeweiliger Index mit dem Index plus 1 verrechnet wird, daraufhin wird die Differenz in ein neues Array gespeichert. Sobald die Berechnung fertig ist für die Differenzen, wird das neue Array auf den höchsten Wert geprüft, Arrays.sort(neuesArray), der letzte Index ist dann der höchste Wert. Wenn du jetzt noch die Indizes des ersten Array abspeichern musst, dann kannst du das noch in der Schleife machen, die die Diff ermittelt.


Korrigiert mich wenn ich falsch liege, aber sollte das die Aufgabe sein, ist durchaus machbar.


Edit: ignoriert mich, ich habe diesen Post geschrieben weil ich nur die ersten Posts gelesen habe und Seite 2 nicht gelesen habe.


----------

