rekursiv reverse String ausgeben

[Sirius3]

@zsanzhar: wenn Du in jedem Schritt nur ein Buchstabenpaar austauschst, dann hast Du automatisch eine Schleife, bzw. Rekursion.

[StareDog]

ich soll die aufgabe ebenso lösen

Code: Alles auswählen

s ="Das Haus ist blau"

def reverse(s,l,r):  
    if l == r:
        return s[l]
    else:
        return str(reverse(s,l+1,r))+s[l]
print(reverse(s,3,14))

Zu meinem Code/Gedankengang
wenn ich den das wort bis Stelle l+1 erzeugt habe, kann ich auch das wort l hinzufügen. Da ich aber das wort bis l+1 noch nichtg weiß muss ich den buchstaben l+1 herausfinden und dazu rufe ich l+2 auf, bis der letzte Buchstabe in meinem Fall s[l] = s[r] =14 gefunden wurde und dann die erste Ziffer der Lösung ist und somit dann die weiteren Buchstaben des wortes angefügt werden können vom algorithmus.

ich weiß nicht, aber ich lese heraus, dass ihr meint, dass in jedem schritt zwei buchstaben miteinander getauscht werden sollen?
3-14
4-13
5-12
6-11
7-10
8-9

das heißt 6 Schritte und der Rekursionsabbruch findet statt wenn r = l+1 ist.

[__blackjack__]

@StareDog: In dem konkreten Beispiel ist die Rekursion zu ende wenn r == l + 1 ist, das muss aber nicht bei jeder Eingabe der Fall sein.

Man kann das auch anders lösen als durch vertauschen von einem Buchstabenpaar pro Iterationsschritt, aber das wäre dann IMHO komplizierter. Das einzige ”Problem” bei Python ist, das Zeichenketten unveränderbar sind, womit das Buchstaben vertauschen ineffizient ist. Aber das rekursiv zu lösen ist ja eh schon keine Python-Lösung.

[__blackjack__]

Hier mal die „vertausche zwei Zeichen in jedem Rekursionsschritt“-Variante in Io implementiert. Io hat im Gegensatz zu Python auch Zeichenketten die veränderbar sind, weshalb das nicht ganz so ineffizient ist wie in Python.

Code: Alles auswählen

#!/usr/bin/env io

Sequence swap := method(i, j,
    tmp := self at(i)
    self atPut(i, self at(j))
    self atPut(j, tmp)
)

reverse := method(sequence, start, end,
    if(start >= end,
        sequence
    ,
        reverse(sequence swap(start, end), start + 1, end - 1)
    )
)

main := method(reverse("Das Haus ist grün." asMutable, 3, 12) println)

isLaunchScript ifTrue(main)

Die Alternative wäre im Rekursionsschritt den Präfix der nicht umgedreht werden soll, gefolgt vom Buchstaben am zweiten Index, gefolgt vom umgedrehten Teil zwischen den beiden Indizes (Rekursiver aufruf), gefolgt vom Buchstaben am ersten Index, gefolgt vom Suffix der nicht umgedreht werden soll, zu bestimmen. Das mit Prä- und Suffix ist eigentlich nur beim ersten Aufruf nötig, denn in jedem rekursiven Aufruf sind diese beiden Teilzeichenketten leer. Der Ansatz als Bash-Skript:

Code: Alles auswählen

#!/bin/bash

Reverse() {
    local string=$1
    local start=$2
    local end=$3
    
    if (( start >= end )); then
        echo "$string"
    else
        local prefix=${string:0:start}
        local left_character=${string:start:1}
        local middle=${string:start+1:end-start-1}
        local reversed_middle=$(Reverse "$middle" 0 $(( ${#middle} - 1 )))
        local right_character=${string:end:1}
        local suffix=${string:end+1}
        echo "$prefix$right_character$reversed_middle$left_character$suffix"
    fi
}

Reverse 'Das Haus ist grün.' 3 12