# Längste Sequenz gleicher Int Werte



## JavaMaxpectation123 (2. Nov 2022)

Guten Abend,
bisher hat mir StackOverflow immer enorm bei der Lösungsfindung zu Übungsaufgaben der Hochschule weitergeholfen.
Dafür erstmal dankeschön an alle fleißigen beteiligten.
momentan stehe ich allerdings seit 3 Tagen auf dem Schlauch und ich komme nicht weiter.
Meine Aufgabe ist eine Scanner Eingabe zu überprüfen und die einzelnen werte der übergabe auf gleichheit mit den zuvorkommenden Int werten zu vergleichen.
meine Notizen und der (Sehr unschöne Code) sind angehangen in diesem Beitrag.
Problem ist nun das ich nicht die Ergebnisse bekomme die ich mir in meinen schönen Notizen zusammengereimt habe.
Ich vermute das der Fehler darin liegt das der alte Wert, nicht in der Variablen old zwischengespeichert wird und somit die Aussage (input == old) keinen sinn macht da diese immer Identisch sind.
Außerdem denke ich das die Variable maxNow unnötig ist und das der max wert nicht den höchsten current wert speichert
Ich hoffe das mir weitergeholfen werden kann da ich mit meinen Ideen langsam zum ende komme
Für die folgende Hilfe bedanke ich mich schonmal im vorraus.
Mir ist bewusst das ein ähnliches Thema bereits besprochen wurde allerdings möchte ich die Erstellung eines Arrays tunlichst vermeiden, da jede Ausgabelänge aufgenommen werden soll.
Eine for schleife kommt ebenfalls nicht in Frage.


input = 1 2 3;
old = 1 2 3;
die werte 1 und 2 sind != somit ist die Sequenzlänge 1
wenn der input 1 1 2 wäre
wäre die Sequenzlänge 2
wenn der input 1 1 1
wäre wäre die sequenzlänge 3, da die Inputwerte zu den old werten identisch sind
current wird solange hochgezählt wie die input werte identisch zu den old werten sind
wenn current größer als 1 ist wird die Sequenzlänge in max gespeichert und ersetzt
sobald current >= max ist nimmt max den neuen current wert
am ende wird max ausgegeben als längste kette

old soll den vorangegangenen wert speichern
current soll die Sequenzlänge der aktuellen Sequenz ausgeben
if (old == input){
current ++;
if (old != input){
current = 1;
if (current > 1)
current = max;
if (current <= 1)
max = max
current = 1;
else{
setzt current auf 1 zurück um die schleife mit current 1 zu starten
max bleibt der letzte höchste current wert bis er übertroffen wird
}
der einzige sysout bleibt max da dies die längste sequenz speichert


----------



## mihe7 (2. Nov 2022)

JavaMaxpectation123 hat gesagt.:


> if (current > 1)
> current = max;
> if (current <= 1)
> max = max


Was soll das denn bewirken?



JavaMaxpectation123 hat gesagt.:


> wenn current größer als 1 ist wird die Sequenzlänge in max gespeichert und ersetzt


Wenn current > max ist, dann hast Du ein neues Maximum, nämlich current.


JavaMaxpectation123 hat gesagt.:


> sobald current >= max ist nimmt max den neuen current wert


Exakt, wobei ein > reicht.


----------



## JavaMaxpectation123 (3. Nov 2022)

mihe7 hat gesagt.:


> Was soll das denn bewirken?
> 
> 
> Wenn current > max ist, dann hast Du ein neues Maximum, nämlich current.
> ...


Der erste Part diente für mich lediglich zum verständnis. Dieser ist nicht im Programm aufgeführt. Es soll bedeuten das current nur zu max wird wenn es größer als  1 ist und das max bei einem Input kleiner als 1 max bleibt.
Eine an für sich unnütze aussage da das Programm ja einen Input von min 1 erwartet aber das kam mir so in den Kopf für meine Notizen.
Zu deinem zweiten und dritten Punkt lässt sich sagen das hier ein.
if (current>max)
max = current
einzusetzen wäre.
Um zurück zu meinem Hauptproblem zu kehren.
Ich führe den gesamten Code in einer While Schleife in Kombination mit der hasNextInt() Methode aus.
der Input ist = nextInt()
wie bekomme ich es hin das in int old der z.B die 1 gespeichert wird und der Input dann den nextInt() nimmt der in meiner Zahlenfolge nach der 1 kommt um die beiden auf gleichheit zu überprüfen?
wenn ich old und input in sysout eintrage bekomme ich identische werte raus und das hätte ich gerne anders. Zumindest denke ich das dort mein Problem liegt, da input == old ja immer zutrifft wenn diese identisch sind und somit ja nicht auf gleichheit der Zahlenfolge sondern auf gleichheit der beiden Werte geprüft wird.


----------



## JavaMaxpectation123 (3. Nov 2022)

mihe7 hat gesagt.:


> Was soll das denn bewirken?
> 
> 
> Wenn current > max ist, dann hast Du ein neues Maximum, nämlich current.
> ...


Scanner sc = new Scanner (System.in);
while (sc.hasNextInt()){
int input = sc.nextInt();
int old = input;
int current = 0;
int max = 1;

if(old==input){
current++;
}
if(current>max){
max = current;
}
else{
current = 1;
}
}
System.out.println("Die längste Sequenz identischer Zahlen der übergabe ist "+max+" Zeichen lang")

Das ist mein Aktueller Code
Ergebnis ist das er nie eine Längere Ausgabe als 1 gibt.


----------



## Jw456 (3. Nov 2022)

```
Scanner sc = new Scanner (System.in);
        while (sc.hasNextInt()) {
           
            String Eingabe = sc.next();
           
            int i = Integer.parseInt(Eingabe);
           
            for(i = 0; i < Eingabe.length(); i++) {
               
                System.out.println(i);
         
           
        }
       
       
        }
```

das ist dein Code unverändert.

was passirt wenn keine eingabe im scanner ist also hasNextint false zurück gibt.
deine schleife ist zu ende .

bei diesem Code das selbe das ist keine warte scheife die auf eine eingabe Wartet.

```
Scanner sc = new Scanner (System.in)
while (sc.hasNextInt()){  
    int input = sc.nextInt();
    int old = input;
    int current = 0;
    int max = 1;

    if(old==input){
        current++
    }
    if(current>max){
    max = current;
    }
    else{
    current = 1;
   
}
System.out.println("Die längste Sequenz identischer Zahlen der übergabe ist "+max+" Zeichen lang")
```


----------



## Jw456 (3. Nov 2022)

Wenn dein Programm startet, hast du sicher nicht so schell  eine Tastatureingabe gemacht,  dein Prüfen  HasNext ist „false“ und deine Schleife wird nicht durchlaufen.


----------



## JavaMaxpectation123 (3. Nov 2022)

Jw456 hat gesagt.:


> ```
> Scanner sc = new Scanner (System.in);
> while (sc.hasNextInt()) {
> 
> ...


----------



## JavaMaxpectation123 (3. Nov 2022)

Jw456 hat gesagt.:


> Wenn dein Programm startet, hast du sicher nicht so schell  eine Tastatureingabe gemacht,  dein Prüfen  HasNext ist „false“ und deine Schleife wird nicht durchlaufen.


Damit kann ich was anfangen. das heißt ich versuche den Input einfach schon vor dem Schleifenbeginn zu erzeugen damit mit diesem schon gearbeitet werden kann


----------



## Jw456 (3. Nov 2022)

Du musst ja auch erst mal prüfen ob Old gleich input ist .Bevor du den input in old speicherst. 

Bei dir ist  das immer True da du ja vorher schon old= input machst.


----------



## Jw456 (3. Nov 2022)

```
Scanner sc = new Scanner (System.in)
while (sc.hasNextInt()){
    int input = sc.nextInt();
    int old = input;
    int current = 0;
    int max = 1;

    if(old==input){ // ist immer true da du in zeile 4 old den input zuweist.
        current++
    }

[/QUOTE]
```

deine old variable sollte auch nicht in der While erstellt werden. Nicht lokal in der While
max und dein zähler das selbe.

Bei jeden Schleifendurchgang werden die Variablen ja neu erstellt und geladen. Das willst du ja nicht.


----------



## JavaMaxpectation123 (3. Nov 2022)

Also die Prüfung ob es gleich ist findet in Zeile 8 Statt
heißt in zeile 4 darf old lediglich deklariert werden?
wäre if(old!=input){
old++
}
wenn old dann solange ++ zählt bis es identisch mit input ist. dann kann man ja current++ machen.
eine möglichkeit?


----------



## Jw456 (3. Nov 2022)

die variablen sollten auserhalb der schleife erstellt werden.


----------



## Jw456 (3. Nov 2022)

JavaMaxpectation123 hat gesagt.:


> wäre if(old!=input){
> old++
> }


Du willst doch zählen wie oft der User zb. 5 ununterbrochen eingibt.
Also bei gleich wird hoch gezählt. Und bei else wird der Zäher wider zurückgesetzt.
Und in old das neue input gespeichert.

Was soll dann old ++ sinnlos. Du brauchst doch das old mit der „5“ um beim neuen  durchlauf zu testen ob der User wider „5“ eingegeben hat.


----------



## temi (3. Nov 2022)

JavaMaxpectation123 hat gesagt.:


> wenn old dann solange ++ zählt bis es identisch mit input ist. dann kann man ja current++ machen.
> eine möglichkeit?


Warum sollte man so etwas machen wollen?

Du möchtest doch wissen welches die längste Sequenz aufeinander folgender gleicher Zahlen ist. Dazu brauchst du eine Variable, in der der zuletzt verarbeitete Wert steht, damit du ihn mit dem aktuellen Wert vergleiche kannst. Sind die Werte gleich, dann kannst du einen Zähler für die aktuelle Sequenz erhöhen, falls nicht, dann startet dieser Zähler wieder bei Null. Um die längste Sequenz zu finden benötigst du noch eine Variable, in der der Zählerstand der bisher längsten Sequenz gespeichert ist. Und wann geschieht das? Sobald die vorherige Sequenz endet, also der letzte Wert nicht gleich dem aktuellen Wert ist.


----------



## JavaMaxpectation123 (3. Nov 2022)

temi hat gesagt.:


> Warum sollte man so etwas machen wollen?
> 
> Du möchtest doch wissen welches die längste Sequenz aufeinander folgender gleicher Zahlen ist. Dazu brauchst du eine Variable, in der der zuletzt verarbeitete Wert steht, damit du ihn mit dem aktuellen Wert vergleiche kannst. Sind die Werte gleich, dann kannst du einen Zähler für die aktuelle Sequenz erhöhen, falls nicht, dann startet dieser Zähler wieder bei Null. Um die längste Sequenz zu finden benötigst du noch eine Variable, in der der Zählerstand der bisher längsten Sequenz gespeichert ist. Und wann geschieht das? Sobald die vorherige Sequenz endet, also der letzte Wert nicht gleich dem aktuellen Wert


erzeuge ich durch Int old = input; eine Variable die den zuletzt verarbeiteten wert speichert? Input geht rein und wird in old abgelegt. Meine Frage beantworte ich mit ja.
Die if anweisung (old == input){
current++;
}
eignet sich ebenfalls um old und input auf gleichheit zu überprüfen und wenn vorhanden den temporären Sequenzzähler zu erhöhen.
else {
current = 1;
ist für mich die gegenbedingung wenn old != input
heißt wenn die werte nicht = sind wird der zähler von 1 an neu gezählt
zu guter letzt habe ich noch if (current > max){
max = current;
um die bisher größte sequenz zu speichern bis die größte gefunden wurde.
allerding bekomme och trotzdem als ergebnis 1.
wo liegt mein Fehler, ich habe so gut es geht versucht meine Logik zu erklären aber irgendwo ist dort ja ein fehler.


----------



## Jw456 (3. Nov 2022)

das sollte doch reichen

```
Scanner sc = new Scanner(System.in);
        int input;
        int old=0;
        int max=0;
        int current = 1;
        while (sc.hasNextInt()) {
            input = sc.nextInt();
            if (old == input) {
                current++;
                 if(current > max){
                       max = current;
}
            } else {
                current=1;
                old = input;
            }
            System.out.println("Die längste Sequenz identischer Zahlen der übergabe ist " + current + " Zeichen lang");
        }
```


----------



## JavaMaxpectation123 (3. Nov 2022)

Jw456 hat gesagt.:


> das sollte doch reichen
> 
> ```
> Scanner sc = new Scanner(System.in);
> ...


Okay also ich habe es jetzt fürs erste.
Ergebnis ist nur noch max
und er gibt in bisher 3 testfällen das richtige ergebniss.
Ich bedanke mich recht herzlich für die Hilfe Jw456 und temi.
Ich wäre vermutlich besser dran gewesen wenn ich einmal alles gelöscht hätte und dann nochmal schritt für schritt durchgehe anstatt nach fehlern zu suchen.
👍👍👍


----------



## temi (3. Nov 2022)

JavaMaxpectation123 hat gesagt.:


> erzeuge ich durch Int old = input; eine Variable die den zuletzt verarbeiteten wert speichert? Input geht rein und wird in old abgelegt.


Ja, aber du überschreibst damit natürlich den letzten Wert BEVOR du den neuen Wert ausgewertet hast 

Danach sind old und input halt immer identisch.


----------



## JavaMaxpectation123 (3. Nov 2022)

temi hat gesagt.:


> Ja, aber du überschreibst damit natürlich den letzten Wert BEVOR du den neuen Wert ausgewertet hast
> 
> Danach sind old und input halt immer identisch.


genau das war mein Fehler danke nochmal! Manchmal seh ich den Wald vor Lauter Bäumen nicht, das hat mir echt alles keine ruhe mehr gelassen👍


----------



## Jw456 (3. Nov 2022)

JavaMaxpectation123 hat gesagt.:


> genau das war mein Fehler danke nochmal! Manchmal seh ich den Wald vor Lauter Bäumen nicht, das hat mir echt alles keine ruhe mehr gelassen👍


Das hatte ich dir in #9  auch schon gesagt.


----------



## MarvinsDepression (3. Nov 2022)

zu #16: Ein Sonderfall liefert meiner Meinung nach ein falsches Ergebnis. Wenn nur unterschiedliche Zahlen eingegeben werden, bleibt max immer 0, aber jede einzelene Zahl hätte doch bereits die Sequenzlänge 1. Nur wenn überhaupt keine Zahl eingegeben wurde, wäre auch die maximale Sequenzlänge 0.


----------



## Jw456 (3. Nov 2022)

MarvinsDepression hat gesagt.:


> zu #16: Ein Sonderfall liefert meiner Meinung nach ein falsches Ergebnis. Wenn nur unterschiedliche Zahlen eingegeben werden, bleibt max immer 0, aber jede einzelene Zahl hätte doch bereits die Sequenzlänge 1. Nur wenn überhaupt keine Zahl eingegeben wurde, wäre auch die maximale Sequenzlänge 0.


ja  Das max wurde  noch schnell hinzugefügt. Danke für den Tipp.


----------



## mihe7 (3. Nov 2022)

In #16 ist die Ausgabe noch in der Schleife und der Fall, dass gar keine Zahl eingegeben wurde, ist auch nicht behandelt. So dürfte das komplett aussehen:


```
Scanner sc = new Scanner(System.in);
int max = 0;
if (sc.hasNextInt()) {
    int old = sc.nextInt();
    int current = 1;
    max = 1;

    while (sc.hasNextInt()) {
        int input = sc.nextInt();
        if (old == input) {
            current++;
            if (current > max) {
                max = current;
            }
        } else {
            current = 1;
            old = input;
        }
    }
}
System.out.println("Die längste Sequenz identischer Zahlen der übergabe ist " + max + " Zeichen lang");
```


----------

