Denkfehler bei einfacher Schleife

EinNickname9

Bekanntes Mitglied
Hallo,

ich möchte alle Zeichen einer Zeichenfolge um shift Schritte in eine Richtung verschieben. Es soll dabei kein zusätzliches Array benutzt werden...

Das ist mein bisheriger Ansatz:

Java:
    public static char[] shiftImproved(final char[] txt, final int shift) {
        for (int i = 1; shift * (i - 1) + shift <= txt.length; i *= 2) {
            for (int j = 0; j < shift; j++) {
                int i1 = (shift * (i - 1) + j) % txt.length;
                int i2 = (shift * (i - 1) + j + shift) % txt.length;
                char temp = txt[i1];
                txt[i1] = txt[i2];
                txt[i2] = temp;
            }
        }
        System.out.println("txt = " + Arrays.toString(txt));
        return txt;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag".toCharArray(), i);
        }
    }

Und das ist die Ausgabe:

i = 1
txt = [u, t, G, n, e, , T, g, a]
i = 2
txt = [a, e, n, , G, u, g, t, T]
i = 3
txt = [e, n, , T, a, g, G, u, t] ✅
i = 4
txt = [u, t, e, a, g, n, , T, G]
i = 5
txt = [n, T, a, g, , G, u, t, e] ✅
i = 6
txt = [e, n, , T, a, g, G, u, t] ✅
i = 7
txt = [t, e, n, , T, g, a, G, u]
i = 8
txt = [u, t, e, n, , T, a, g, G] ✅
i = 9
txt = [G, u, t, e, n, , T, a, g] ✅

Kann mir vielleicht jemand sagen, was ich falsch mache? Danke. 😊
 

kneitzel

Top Contributor
Also irgendwie verstehe ich deinen Ansatz in keiner Weise. Dein Code ist auch extrem unleserlich...

Du könntest ja mal erläutern, was Dein Code überhaupt machen soll :)

Generell würde ich da einfach heran gehen und es wie immer unterteilen:

a) Du kannst eine Methode Schreiben, die um genau eine Stelle verschiebt. Das ist ja auch einfach, da man einfach ein Element nimmt und dann immer mit den nachfolgenden Zeichen tauscht.
b) das kannst Du dann in einer Schleife n mal aufrufen

Beides ist einfach und übersichtlich zu schreiben mit Code, der einfach zu lesen und zu verstehen ist.
 

LimDul

Top Contributor
Das ist nicht effizient, eine Schleife n-mal aufzurufen (n*n Laufzeit, also quadratische Laufzeit).
Quadratisch ist es nicht, es ist O(n*m) mit n = Länge des Arrays und m = Anzahl der Verschiebungen
Aber ja, 100% effizient ist es nicht - aber solange die Effizienz nicht gefragt ist, ist es selten sinnvoll die von vornerein einzubauen
Ist das denn mein Problem?
Ja. ich hab überhaupt keine Idee, was das die äußere Schleife machen soll und warum da irgendwas rauskommen soll, was eine Verschiebung ist. Das ist schlicht nicht verständlich. i nimmt die Werte 1, 2, 4, und bricht irgendwann ab. Warum das quadrieren von i irgendwas mit einer Verschiebung um n Stellen zu tun hat ist mir schleierhaft.
 

kneitzel

Top Contributor
Das ist nicht effizient, eine Schleife n-mal aufzurufen (n*n Laufzeit, also quadratische Laufzeit).
Das ist doch auch die Komplexität von Deinem Code. Du hast auch zwei verschachtelte Schleifen.
Ist das denn mein Problem?
Scheint zumindest so. zumindest fällt es uns schwer, Dir zu helfen und Du selbst scheinst da auch nicht durchzublicken, sonst hättest Du ja kaum den Thread erstellt.
 

LimDul

Top Contributor
Im Endeffekt ist die Herausforderung bei der Aufgabe, das kein weiteres Array verwendet werden darf. Das heißt, ich muss bei der Verschiebung aufpassen, dass ich nicht Dinge doppelt verschiebe (Das aus Position 1 kommt auf 5 - aber das aus 5 kommt vielleicht auf 9 - oder je nach Länge auf Position 2). Sprich, wenn man einmal durch das Array durchgeht und alles um shift verschiebt kommt vermutlich nicht das richtige raus.

Jetzt gibt es zwei Ansätze die man machen kann:

a) Den @kneitzel vorgeschlagen hat, dass konkret für einen shift um 1 zu implementieren und das dann entsprechend oft durchzuführen
b) Das Problem in einen effizienten Algorithmus überführen, der jedes Element nur einmal anfasst. Das ist aber deutlich aufwendiger und setzt voraus, dass man diesen Algorithmus auch erstmal überhaupt beschreiben kann in Worten bevor man ihn implementiert.

Ich würde an der Stelle a) machen, solange b) nicht gefordert ist.
 

EinNickname9

Bekanntes Mitglied
Das ist doch auch die Komplexität von Deinem Code.
Nein ist es nicht. Das würde man durch genaues Hinsehen sehen oder durch Zählen der tatsächlichen Schritte.

Scheint zumindest so. zumindest fällt es uns schwer, Dir zu helfen und Du selbst scheinst da auch nicht durchzublicken, sonst hättest Du ja kaum den Thread erstellt.
Ja vielleicht geht es auch einfacher, aber ich sehe nicht, wie.
 

Robertop

Aktives Mitglied
Wenn die Aufgabenstellung wirklich nur ist, dass alle Zeichen um shift Schritte verschoben werden, brauchst du nur eine Schleife mit der temp Variable, die ein Zeichen vorhält, damit es nicht verloren geht.

Die äußere Schleife in deiner Funktion kann ich ehrlich gesagt auch nicht nachvollziehen. Was soll die bezwecken?
 

kneitzel

Top Contributor
Und generell immer schön sauber bleiben was den Code angeht:
- klare Bezeichner! (Was ist i, j, i1, i2 in deinem Code?)
- Vernünftige Ausdrücke! ("shift * (i - 1) + shift" ist z.B. "shift * i")
- Und wenn Code nicht sofort erkennbar ist, was da passiert: Unterteilen! Du kannst die innere for Schleife ja ggf. auch in eine eigene Methode auslagern mit vernünftigem Bezeichner und schon hat man es leichter, den Code zu verstehen.
 

Jw456

Top Contributor
Wenn das Array 10 Felder hat muss die Schleife 10 mal laufen.

pos = 0
Vor dem ersten lauf Wert von Pos0 in Merker1 merken.
pos + shift

Schleife

Wert auf pos in Merker2
Wert von Merker1 auf pos setzen
Merker1= Merker2
pos + shift
Testen ob pos größer als Array
Wenn ja pos = pos - arraylänge-1
 
Zuletzt bearbeitet:

kneitzel

Top Contributor
Wenn die Aufgabenstellung wirklich nur ist, dass alle Zeichen um shift Schritte verschoben werden, brauchst du nur eine Schleife mit der temp Variable, die ein Zeichen vorhält, damit es nicht verloren geht.
Kannst Du den Algorithmus einmal kurz Vorstellen? Das dürfte nicht ganz so einfach sein fürchte ich, denn Du musst ja erkennen, was Du schon verschoben hast und was nicht.

Also um es deutlich zu machen:
A B C D und um 3 verschieben:
A muss zum D, wie gehst Du mit dem D weiter vor? Das kommt direkt zum C und Du machst beim C weiter? Was ist der Abbruch? Das dann irgendwann etwas wieder beim A landet?

Dann nehmen wir A B C D und verschieben um 2:
A auf C, C kommt dann auf A -> Abbruch weil etwas bei A gelandet ist?

Also die möglichen Fälle machen es schon etwas komplexer fürchte ich. Zumindest die zwei Fälle: n%shift == 0 oder eben nicht.
 

Mart

Top Contributor
Java:
weiterschieben( char array. int buchstabenposition im array , shift)
{
    dein buchstabe = array [ buchstabenposition ]
    position = possition buchstabenposition im array + shift
    if ( überlauf am ende )
    {
        position = position am anfang dann finden
    }
    if ( nicht am ende des arrays angelangt )
    {
    array = weiter schieben ( char array , buchstabenposition im array +1 , shift )
    array [ position ] = deinbuchstabe
    return array
    }
    else
    {
        array [ position ] = deinbuchstabe
        return array
    }
}
das wäre der pseudo code für eine rekursive methode

die kannst du umwandeln in eine for schleife falls dir das was hilft
 

LimDul

Top Contributor
Java:
weiterschieben( char array. int buchstabenposition im array , shift)
{
    dein buchstabe = array [ buchstabenposition ]
    position = possition buchstabenposition im array + shift
    if ( überlauf am ende )
    {
        position = position am anfang dann finden
    }
    if ( nicht am ende des arrays angelangt )
    {
    array = weiter schieben ( char array , buchstabenposition im array +1 , shift )
    array [ position ] = deinbuchstabe
    return array
    }
    else
    {
        array [ position ] = deinbuchstabe
        return array
    }
}
das wäre der pseudo code für eine rekursive methode

die kannst du umwandeln in eine for schleife falls dir das was hilft
Das funktioniert nicht so einfach. Mit einem Durchlauf ist es extrem tricky und nicht so einfach.

Einfach mal durchspielen mit den Fällen, die Kneitzel genannt hat.


Edit:
Wobei rekursiv kann es funktionieren, das stimmt.
Aber leider lässt sich das nicht in eine Schleife umwandeln ohne einen Stack = Zusätzliches Array zu nutzten.

Sprich eine rekursive Lösung ist im Sinne der Aufgabenstellung keine Hilfe.
 

Mart

Top Contributor
Das funktioniert nicht so einfach. Mit einem Durchlauf ist es extrem tricky und nicht so einfach.

Einfach mal durchspielen mit den Fällen, die Kneitzel genannt hat.
woran sollte es scheitern, das array bleibt bis zum ende unverändert

und dann sortiert jede methode seinen buchstaben ein

das funktioniert da bin ich mir safe weil es an sich das einsortieren in 2 arrays gleichzusetzen ist
nur ich bleibe in einem array

ich sehe nicht worin das scheitern sollte
 

LimDul

Top Contributor
woran sollte es scheitern, das array bleibt bis zum ende unverändert

und dann sortiert jede methode seinen buchstaben ein

das funktioniert da bin ich mir safe weil es an sich das einsortieren in 2 arrays gleichzusetzen ist
nur ich bleibe in einem array

ich sehe nicht worin das scheitern sollte
Ich habs editiert, ich hab einen Denkfehler gehabt. Es funktioniert, ist aber keine Hilfe, weil es rekursiv ist und sich nicht in eine Schleife umwandeln lässt ohne ein zusätzliches array zu bauen.

Dafür bräuchtest du eine rekursive Lösung ohne die zusätzlichen lokalen Variabeln.
 

Mart

Top Contributor
wenn man den durchlauf hat mit "abc" und shift 1 ist
ist es so
Methoden aufruf mit array
abc => a position 2=> weiterschieben
abc => b position 3=> weiterschieben
abc => c position 1=> am ende vom array dh jetzt einsetzen
c an position 1
b an position 2
a an position 3

und wehe jetzt kommt der array an stelle 0 haken xD
 

Mart

Top Contributor
ich halte die aufgabe ein, kein zusätzliches array und verschieben, sehe kein problem damit es rekursiv zu machen


das ist das gleiche wie wenn du die türme von hanoi iterativ machen willst... toll ist anders
 

LimDul

Top Contributor
wenn man den durchlauf hat mit "abc" und shift 1 ist
ist es so
Methoden aufruf mit array
abc => a position 2=> weiterschieben
abc => b position 3=> weiterschieben
abc => c position 1=> am ende vom array dh jetzt einsetzen
c an position 1
b an position 2
a an position 3

und wehe jetzt kommt der array an stelle 0 haken xD
Du hast kein Array - aber bei der Umwandlung in eine Schleife brauchst du eins, weil du bei drei Rekursionen 3x die lokale Variable dein buchstabe hast.

Du musst du bei der rekursiven Lösung elemenieren. Ansonsten verletzt du die Aufgabenstellung, weil du den Call-Stack als Array implizit nutzt.
 

LimDul

Top Contributor
ich halte die aufgabe ein, kein zusätzliches array und verschieben, sehe kein problem damit es rekursiv zu machen


das ist das gleiche wie wenn du die türme von hanoi iterativ machen willst... toll ist anders
Ok, wenn man so argumentiert hast du durchaus recht - kommt jetzt auf die konkrete Aufgabenstellung an und was an Wissen bekannt & genutzt werden darf :)
 

kneitzel

Top Contributor
Es funktioniert, ist aber keine Hilfe, weil es rekursiv ist
Doch schon. Es ist eine ganz interessante Sache. Es geht ja nur um das Array.

Also geht man rekursiv durch und merkt sich Platz und wert auf dem Hinweg und setzt es auf dem Rückweg.
Java:
    public static void shift(char[] chars, int shift) {
        shift(chars, shift, 0);
    }
    
    public static void shift(char[] chars, int shift, int pos) {
        if (pos >= chars.length) return;

        char value = chars[pos];
        shift(chars, shift, pos+1);
        chars[(pos+shift)%chars.length] = value;
    }

Den es geht hier ja rein akademisch um eine Vermeidung eines Arrays. Rekursion ist da durchaus eine gute Alternative, denn es wird kein Array verwendet.

Eine Idee, die mir auch durch den Kopf ging: Eine Queue der Länge shift verwenden - wobei das dann sehr ähnlich zu "Array" Datenstruktur ist.
 

Mart

Top Contributor
Java:
void schieben (  array , shift )
    position = 0;
Character merker = array[0];
for ( i = 0 , array.length)
{
     position = ( position + shift ) % array.length
     Character zwischenspeicherFürMerker = array[position]
array[position] = merker;
merker = zwischenspeicherfürmerker
       
}

das ist das einfachste was ich mir vorstellen kann zu bauen als for schleife
man hüpft halt kreuz und quer durch das array

ist ungetestet
 

EinNickname9

Bekanntes Mitglied
Java:
void schieben (  array , shift )
    position = 0;
Character merker = array[0];
for ( i = 0 , array.length)
{
     position = ( position + shift ) % array.length
     Character zwischenspeicherFürMerker = array[position]
array[position] = merker;
merker = zwischenspeicherfürmerker
      
}

das ist das einfachste was ich mir vorstellen kann zu bauen als for schleife
man hüpft halt kreuz und quer durch das array

ist ungetestet
Vielen lieben Dank. Es funktioniert noch nicht ganz, aber es ist bessergeworden:

Java:
    public static char[] shiftImproved(final char[] txt, final int shift) {
        int position = 0;
        char temp = txt[0];
        for (int i = 0; i <= txt.length; i++) {
            position = (position + shift) % txt.length;
            char temp2 = txt[position];
            txt[position] = temp;
            temp = temp2;
        }
        System.out.println("txt = " + Arrays.toString(txt));
        return txt;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag".toCharArray(), i);
        }
        for (int i = 1; i < 10; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag!".toCharArray(), i);
        }
    }

i = 1
txt = [g, G, u, t, e, n, , T, a] ✅
i = 2
txt = [a, g, G, u, t, e, n, , T] ✅
i = 3
txt = [G, u, t, e, n, , G, a, g]
i = 4
txt = [ , T, a, g, G, u, t, e, n] ✅
i = 5
txt = [n, , T, a, g, G, u, t, e] ✅
i = 6
txt = [G, u, t, G, n, , T, a, g]
i = 7
txt = [t, e, n, , T, a, g, G, u] ✅
i = 8
txt = [u, t, e, n, , T, a, g, G] ✅
i = 9
txt = [G, u, t, e, n, , T, a, g] ✅

i = 1
txt = [!, G, u, t, e, n, , T, a, g] ✅
i = 2
txt = [T, u, g, e, G, , t, a, n, !]
i = 3
txt = [a, g, !, G, u, t, e, n, , T] ✅
i = 4
txt = [t, u, n, e, T, , g, a, G, !]
i = 5
txt = [G, u, t, e, n, , T, a, g, !] (✅)
i = 6
txt = [g, u, G, e, t, , n, a, T, !]
i = 7
txt = [e, n, , T, a, g, !, G, u, t] ✅
i = 8
txt = [n, u, T, e, g, , G, a, t, !]
i = 9
txt = [u, t, e, n, , T, a, g, !, G] ✅

Auffällig ist, dass es für i=3 nicht funktioniert, für 1, 2 und 4 hingegen schon. Woran liegt das? Kann es etwas mit "gerade"/"ungerade" zu tun haben? 🤔

Vielen Dank, diese Aufgabe ist sehr knifflig!
 

Mart

Top Contributor
Java:
public static char[] shiftImproved(final char[] txt, final int shift) {
    int position = 0;
    char temp = txt[0];
    System.out.println(txt.length);
    boolean moduloProtect =txt.length % shift == 0;
    for (int i = 0; i < txt.length; i++) {

        position = ((position + shift)%txt.length);

        char temp2 = txt[position];
        System.out.println(position + " " +temp);
        txt[position] = temp;
        temp = temp2;
        if ( position == 0 && moduloProtect)
        {
            position = position +1 ;
            temp = txt[1];
        }
    }
    System.out.println("txt = " + Arrays.toString(txt));
    return txt;
}

public static void main(String[] args) {
    shiftImproved("Guten Ta".toCharArray(),2);
    shiftImproved("Guten Ta".toCharArray(),3);
}
}
ich muss mich entshculdigen da ich vergessen hatte mit einzukalkulieren dass sich die schleife im kreis drehen kann ... so funktioniert es

und jetzt siehst du diesen aufwand vs die rekursive variante
 

Mart

Top Contributor
Ja stimmt

PS aber bei shift 3 und Array länge 9
Was macht da das modulo?
Pos 3,6, und nun
6 + 3 =9 und jetzt modulo 9 ist pos gleich 0 und nicht 9.

Deshalb ein klassisches prüfen.
jap hab ich gerade gepostet wie du gepostet hast... hab die korrektur eingebaut um den loop zu verhindern


es ist halt ... das problem war wie gemacht für rekursion xD
 

Mart

Top Contributor
das problem lag daran
in der idee kommst du nie wieder bei der 0 an da sich der sprung in der mitte des strings überschniedet und somit kommst ud bei array[1] irgendwann an und dann kannst du die zweite hälfte bespringen

jedoch wenn shift ein teiler von dem array ist liefert der modulo zweimal 0

jedoch darfst du bei der idee nicht zweimal auf 0 kommen dh ich erzwinge es dass ich um 1 nach vorne geh um den sprung zu schaffen und nicht permanent auf 0 wieder zu kommen




ich hoffe ich habe dich nicht verwirrt dadurch aber es gehört dazu den fehler zu finden und nun musste ich den fehler sogar in miener eigenne logik finden was noch schlimmer ist xD
 

Jw456

Top Contributor
Wenn du vor der Schleife die pos auf shift setzt
In der Schleife erst
Merker2 =Array[pos-1]
Array[pos-1]=Merker1
Merker1=Merker2
Pos=pos+shift

Dann prüfen ob pos größer als das
Array ist wenn ja pos = pos - arrray Länge - 1

Wichtig die variable Pos ist immer eins mehr als der Index von dem Array.
Array[pos-1]=merker


Bei shift 3
Pos 3,6,9,2,5,8,1,4,7
Index 2,5,8,1 4,7,0,3,6

Bin nur am Handy und da ist coden schlecht. Deshalb so
 

Jw456

Top Contributor
So ganz kommplet ist der Code wie ich es beschrieben habe auch nicht wenn der shift grosser ist bei dem Beispiel 9 Felder ab shift 4
 

Mart

Top Contributor
vom groben denken daran wie du es umsetzen möchtest wirst du auf folgenden fehler treffen

array der länge 10
pos = 0
shift = 3000 -> pos = 3000 - 10 -1
=> out of bounds

da du einen doppelten überlauf nicht behandelst soweit ich das erkennen kann



WAS MIR ZUSÄTZLICH EINFÄLLT

wenn 0 als shift übergeben wird sollte das gleiche array zurückgegeeben werden ansonsten läufst du in eine exception jedoch ist das gleiche array richtiger als in die exception zu laufen
und dass keine negativen zahlen übergeben werden dürfen, vllt macht man es mit einer richtung ob man von links oder von rechts shifted
 

Jw456

Top Contributor
vom groben denken daran wie du es umsetzen möchtest wirst du auf folgenden fehler treffen

array der länge 10
pos = 0
shift = 3000 -> pos = 3000 - 10 -1
=> out of bounds

da du einen doppelten überlauf nicht behandelst soweit ich das erkennen kann



WAS MIR ZUSÄTZLICH EINFÄLLT

wenn 0 als shift übergeben wird sollte das gleiche array zurückgegeeben werden ansonsten läufst du in eine exception jedoch ist das gleiche array richtiger als in die exception zu laufen
und dass keine negativen zahlen übergeben werden dürfen, vllt macht man es mit einer richtung ob man von links oder von rechts shifted
Habe ich auch schon gemerkt
 

EinNickname9

Bekanntes Mitglied
... so funktioniert es
Funktioniert Post #32? Das Problem scheinen echt die Teiler der Eingabedatenlänge zu sein.

Ich mach jetzt FA, weil ich kapier heute echt gar nix mehr...

Danke euch für jede Anstrengung.

Aber hier nochmal schnell die Anforderungen:
- Verschiebung aller Zeichen um shift Stellen,
- iterativer Algorithmus,
- zusätzliche Speicherplatzanforderung: O(1),
- Laufzeitanforderung: O(n),
- clean code.
 

Mart

Top Contributor
Funktioniert Post #32? Das Problem scheinen echt die Teiler der Eingabedatenlänge zu sein.

Ich mach jetzt FA, weil ich kapier heute echt gar nix mehr...

Danke euch für jede Anstrengung.

Aber hier nochmal schnell die Anforderungen:
- Verschiebung aller Zeichen um shift Stellen,
- iterativer Algorithmus,
- zusätzliche Speicherplatzanforderung: O(1),
- Laufzeitanforderung: O(n),
- clean code.
#32 sollte funktionieren aber keine angabe auf gewähr


dass es clean code wird müssen die cases die oben von mir genannt wurden noch implementiert werden
 

EinNickname9

Bekanntes Mitglied
Tut mir leid, Mart. Du hast mir Blödsinn als eine valide Lösung verkauft:

Java:
    public static char[] shiftImproved(final char[] txt, final int shift) {
        int position = 0;
        char temp = txt[0];
        for (int i = 0; i < txt.length; i++) {
            position = (position + shift) % txt.length;
            char temp2 = txt[position];
            txt[position] = temp;
            temp = temp2;
            if (position == 0 && txt.length % shift == 0) {
                position = 1;
                temp = txt[1];
            }
        }
        System.out.println("txt = " + Arrays.toString(txt));
        return txt;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag".toCharArray(), i);
        }
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag!".toCharArray(), i);
        }
    }

i = 1
txt = [g, G, u, t, e, n, , T, a]
i = 2
txt = [a, g, G, u, t, e, n, , T]
i = 3
txt = [T, n, t, G, u, , e, u, g] 💥

hmm ....
 

Mart

Top Contributor
Tut mir leid, Mart. Du hast mir Blödsinn als eine valide Lösung verkauft:

Java:
    public static char[] shiftImproved(final char[] txt, final int shift) {
        int position = 0;
        char temp = txt[0];
        for (int i = 0; i < txt.length; i++) {
            position = (position + shift) % txt.length;
            char temp2 = txt[position];
            txt[position] = temp;
            temp = temp2;
            if (position == 0 && txt.length % shift == 0) {
                position = 1;
                temp = txt[1];
            }
        }
        System.out.println("txt = " + Arrays.toString(txt));
        return txt;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag".toCharArray(), i);
        }
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag!".toCharArray(), i);
        }
    }

i = 1
txt = [g, G, u, t, e, n, , T, a]
i = 2
txt = [a, g, G, u, t, e, n, , T]
i = 3
txt = [T, n, t, G, u, , e, u, g] 💥

hmm ....
siehe kommentar #32


du bist noch auf dem alten stand
 

Mart

Top Contributor
Java:
public static char[] shiftImproved(final char[] txt, final int shift) {
    int position = 0;
    char temp = txt[0];
    System.out.println(txt.length);
    boolean moduloProtect =txt.length % shift == 0;
    for (int i = 0; i < txt.length; i++) {

        position = ((position + shift)%txt.length);

        char temp2 = txt[position];
        System.out.println(position + " " +temp);
        txt[position] = temp;
        temp = temp2;
        if ( position == 0 && moduloProtect)
        {
            position = position +1 ;
            temp = txt[1];
        }
    }
    System.out.println("txt = " + Arrays.toString(txt));
    return txt;
}

public static void main(String[] args) {
    shiftImproved("Guten Ta".toCharArray(),2);
    shiftImproved("Guten Ta".toCharArray(),3);
}
}
ich muss mich entshculdigen da ich vergessen hatte mit einzukalkulieren dass sich die schleife im kreis drehen kann ... so funktioniert es

und jetzt siehst du diesen aufwand vs die rekursive variante
das da
 

Mart

Top Contributor
Tut mir leid, Mart. Du hast mir Blödsinn als eine valide Lösung verkauft:

Java:
    public static char[] shiftImproved(final char[] txt, final int shift) {
        int position = 0;
        char temp = txt[0];
        for (int i = 0; i < txt.length; i++) {
            position = (position + shift) % txt.length;
            char temp2 = txt[position];
            txt[position] = temp;
            temp = temp2;
            if (position == 0 && txt.length % shift == 0) {
                position = 1;
                temp = txt[1];
            }
        }
        System.out.println("txt = " + Arrays.toString(txt));
        return txt;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag".toCharArray(), i);
        }
        for (int i = 1; i < 15; i++) {
            System.out.println("i = " + i);
            shiftImproved("Guten Tag!".toCharArray(), i);
        }
    }

i = 1
txt = [g, G, u, t, e, n, , T, a]
i = 2
txt = [a, g, G, u, t, e, n, , T]
i = 3
txt = [T, n, t, G, u, , e, u, g] 💥

hmm ....
ausserdem ist das dein code 😂
 

Barista

Top Contributor
Also das Verschieben um eine Position nach rechts würde durch Vertauschen funktionieren:

Verschieben um eine Position nach rechts durch Vertauschen:
a b c d e

um eine Position tauschen

b a c d e
| |
+-+

b c a d e
  | |
  +-+

b c d a e
    | |
    +-+

b c d e a
      | |
      +-+

Die nächste Idee wäre, dies zu skalieren:
Verschieben um zwei Positionen nach rechts durch Vertauschen:
a b c d e

um zwei Positionen tauschen

c b a d e
|   |
+---+

c d a b e
  |   |
  +---+

c d e b a
    |   |
    +---+

c d e a b
      | |
      +-+

Der letzte Tausch ist irgendwie komisch.

Ich habe keine Idee, dies in einen Algorithmus zu giessen.

Also ist IMHE mehrmals um eine Position Verschieben die einzig mögliche Lösung.
 

Barista

Top Contributor
Ein Trick wäre noch, den Stack als Speicher für die temporären Merker zu verwenden, also einen rekursiven Algorithmus zu verwenden/erschaffen.

Das ist ein bisschen Betrug und meist ist die Stackgröße auch nicht besonders gross
 

Mart

Top Contributor
Ein Trick wäre noch, den Stack als Speicher für die temporären Merker zu verwenden, also einen rekursiven Algorithmus zu verwenden/erschaffen.

Das ist ein bisschen Betrug und meist ist die Stackgröße auch nicht besonders gross
mein ding funktioniert ja nur er hat das falsche kopiert und es soll insitu ohne rekursion sein
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
T Klassen Denkfehler im Klassen "dynamisch" instanzieren? Java Basics - Anfänger-Themen 4
CptK Methoden Timer & Mathematischer Denkfehler Java Basics - Anfänger-Themen 7
DanielsLPecke Denkfehler in kA Java Basics - Anfänger-Themen 8
m²labs Denkfehler in verschachteltem for Java Basics - Anfänger-Themen 2
D Denkfehler in der If-Anweisung Java Basics - Anfänger-Themen 3
C OOP Verwaltungssystem von MP3 Dateien/ Strukturfehler bzw. Denkfehler Java Basics - Anfänger-Themen 5
I OOP This-Referenzs > wo liegt mein Denkfehler? Java Basics - Anfänger-Themen 24
R Java Reiter Denkfehler Java Basics - Anfänger-Themen 4
D denkfehler, bereich verschieben awt Java Basics - Anfänger-Themen 3
D Denkfehler Singleton Java Basics - Anfänger-Themen 53
G Kleiner Denkfehler Java Basics - Anfänger-Themen 23
S Denkfehler? bei Sortiertem einfügen? Java Basics - Anfänger-Themen 4
T Problem mit Lehrzeichen und String bei einfacher Chiffre Java Basics - Anfänger-Themen 8
N Methoden Einfacher SekundenTimer/Stopuhr in Java Java Basics - Anfänger-Themen 2
X Streams und Ausgabe - lässt sich das einfacher schreiben oder schöner schreiben? Java Basics - Anfänger-Themen 5
H wie mehrere variablen in einfacher for-schleife? Java Basics - Anfänger-Themen 2
N Einfacher Rechner (für mich nicht so einfach) Java Basics - Anfänger-Themen 5
? Klassen einfacher Fehler in einem Java Programm. Java Basics - Anfänger-Themen 5
V Einfacher vergleich von Arrays geht schief Java Basics - Anfänger-Themen 2
K Seltsames Ergebnis in Netbeans bei einfacher Multiplikation Java Basics - Anfänger-Themen 5
O Ein einfacher Chatbot (simuliert chat) Java Basics - Anfänger-Themen 7
R Einfacher Regex Java Basics - Anfänger-Themen 3
L Einfacher Methodenaufruf vs. Objekt Java Basics - Anfänger-Themen 4
K Einfacher random namen weitergeben Java Basics - Anfänger-Themen 4
A Lässt sich dieser Ausdruck irgendwie einfacher schreiben? Java Basics - Anfänger-Themen 4
H Einfacher Editor, Einfache Handelsanweisungen Java Basics - Anfänger-Themen 2
H Geht dieser Code noch einfacher (try catch finally) Java Basics - Anfänger-Themen 7
P Geht dieser Code noch einfacher? Java Basics - Anfänger-Themen 16
R Einfacher Timer geht nicht Java Basics - Anfänger-Themen 7
M Einfacher Timer ;) Java Basics - Anfänger-Themen 15
M Einfacher Swing Wizard Java Basics - Anfänger-Themen 3
El_Lobo Methoden Zu viele Getter- und Settermethoden - geht das einfacher? Java Basics - Anfänger-Themen 3
P falsches ergebnis bei einfacher berechnung Java Basics - Anfänger-Themen 3
M Einfacher Fenster-Ablauf Java Basics - Anfänger-Themen 5
M Gittermuster mit Stringbuilder und einfacher Schleife erstellen Java Basics - Anfänger-Themen 19
T Collections Werte aus einer HashMap auslesen, oder gehts auch einfacher ? Java Basics - Anfänger-Themen 6
D Code einfacher,eleganter programmieren Java Basics - Anfänger-Themen 24
F Datentypen Welchen Wert hat ein einfacher Datentyp nach der Deklaration? Java Basics - Anfänger-Themen 6
C einfacher Link zu *.html Datei möglich? Java Basics - Anfänger-Themen 4
Hindi93 Einfacher Code funktioniert nicht... Java Basics - Anfänger-Themen 6
P Einfacher Rechner Java Basics - Anfänger-Themen 2
T Einfacher Kalender Java Basics - Anfänger-Themen 17
B Frage zu einfacher Rechnung Java Basics - Anfänger-Themen 3
B Hilfe bei einfacher Funktion - Possible loss of precision Java Basics - Anfänger-Themen 2
G Einfacher Anfang mit Hibernate Java Basics - Anfänger-Themen 4
M ein einfacher button.. ich verzweifel...... Java Basics - Anfänger-Themen 41
F Von int zu double bei einfacher Rechnung Java Basics - Anfänger-Themen 2
C Einfacher Installer Java Basics - Anfänger-Themen 2
Chucky Einfacher Taschenrechner Verbesserungsvorschläge Java Basics - Anfänger-Themen 13
G Problem mit einfacher For-Schleife und Double Wert Java Basics - Anfänger-Themen 4
D Probleme bei einfacher Rechnung Java Basics - Anfänger-Themen 3
SergioCK Do while Schleife wiederholen Java Basics - Anfänger-Themen 14
M For-Schleife Java Basics - Anfänger-Themen 20
el_pato DialogFenster wird nicht in Schleife geöffnet? Java Basics - Anfänger-Themen 30
J if-Schleife innerhalb einer if-Schleife wird in der Konsole nicht gelesen Java Basics - Anfänger-Themen 4
paulen1 Methoden Unerwünschte Ausgabe bei System.out.print in For-Schleife Java Basics - Anfänger-Themen 8
S Array mit for-Schleife besetzen Java Basics - Anfänger-Themen 7
CptK For-Schleife in Thread nach jedem Durchlauf pausieren Java Basics - Anfänger-Themen 35
M for schleife ohne geschweifte Klammer Java Basics - Anfänger-Themen 15
H For-Schleife bis Index von Eingabe laufen lassen Java Basics - Anfänger-Themen 24
Informatikf Methoden While Schleife Java Basics - Anfänger-Themen 3
U geschachtelte if-Schleife Java Basics - Anfänger-Themen 15
M While Schleife? Java Basics - Anfänger-Themen 4
Poppigescorn Quersumme Berechnen mit einer While Schleife Java Basics - Anfänger-Themen 13
I Potenz berechnen mit for-Schleife Java Basics - Anfänger-Themen 3
J Koordinaten per Schleife ausgeben Java Basics - Anfänger-Themen 6
S Schleife funktioniert nicht Java Basics - Anfänger-Themen 2
M For Schleife/ArrayList Java Basics - Anfänger-Themen 12
OZAN86 Methoden for schleife Java Basics - Anfänger-Themen 3
G --i versus i++ in for-Schleife Java Basics - Anfänger-Themen 11
OZAN86 For Schleife von 1-50 die Zahlen werden durch ein Komma getrennt Java Basics - Anfänger-Themen 10
M Wie kann ich Werte die in einer While Schleife sind weiter genutzt werden? Java Basics - Anfänger-Themen 7
T for-each-Schleife, verschiedene Datentypen Java Basics - Anfänger-Themen 1
T Methode um Array mit for-each-Schleife auszulesen Java Basics - Anfänger-Themen 7
Jana01 Schleife Java Basics - Anfänger-Themen 12
H Kann eine while-Schleife ein Programm blockieren? Java Basics - Anfänger-Themen 8
D For Schleife Java Basics - Anfänger-Themen 8
D Doppelte For Schleife / Array Java Basics - Anfänger-Themen 3
TimoN11 Array -> Schleife wieder von vorne durchlaufen lassen Java Basics - Anfänger-Themen 1
O Methode in while-Schleife aufrufen geht nur beim ersten Mal Java Basics - Anfänger-Themen 2
T Variable in for Schleife ansprechen ohne Array ? Java Basics - Anfänger-Themen 25
M log4j als separate Dateien in Schleife? Java Basics - Anfänger-Themen 6
A Wie schaffe ich das eine while Schleife addiert danach subtrahirt? Java Basics - Anfänger-Themen 1
HoT verschiedene ArrayLists mit ähnlichem Namen in for-Schleife aufrufen Java Basics - Anfänger-Themen 3
U Problem mit dem initialisieren meines Strings in einer Schleife Java Basics - Anfänger-Themen 5
Khaled-Abo Ziffern unterscheiden mittels einer For-Schleife Java Basics - Anfänger-Themen 6
Tino1993 for-Schleife, die eine vorgegebene Anzahl von Zeichen ausgibt Java Basics - Anfänger-Themen 3
T Bestimmte Zahlen ausgeben mit einer whilfe Schleife Java Basics - Anfänger-Themen 21
J for /while Schleife Java Basics - Anfänger-Themen 5
A While Schleife - buubelsort methode Java Basics - Anfänger-Themen 2
A eine neue normale String-Array von einer String-Array, die in for schleife ist, schaffen Java Basics - Anfänger-Themen 3
DorFey Schrittweises abändern des GUI während for-Schleife / pausieren einer for-Schleife Java Basics - Anfänger-Themen 3
P Bedingung in Schleife wird nicht ausgeführt Java Basics - Anfänger-Themen 5
J Wie kann ich hier eine While schleife einbauen? Java Basics - Anfänger-Themen 3
S While-Schleife geht in Endlosschleife über, warum? Java Basics - Anfänger-Themen 6
K Erste Schritte Programm geht aus Schleife, warum? Java Basics - Anfänger-Themen 2
N for Schleife durch Rekursion ersetzen Java Basics - Anfänger-Themen 6
N Probleme beim printen von Arrays durch for Schleife Java Basics - Anfänger-Themen 3
I Java zweidimensionales array befüllen mit for-schleife Java Basics - Anfänger-Themen 2
S Do-While-Schleife Java Basics - Anfänger-Themen 2

Ähnliche Java Themen


Oben