String Methode C#

gamma_matrices

Cadet 4th Year
Registriert
Sep. 2018
Beiträge
121
Hallo zusammen,
ich würde gerne wissen, wie ihr den unteren Codeabschnitt lesen würdet?

C#:
public string functionS(String s)
        {
            s = "Code";

            if (s == "1" || s.Length == 1 || s == "0")
            {
                return s;
            }
            else
            {
                return functionS(s.Substring(1)) + s.Substring(0, 1);
            }
          
        }

if-Teil:
Die Bedingung ist erfüllt, da s.Length ==1 und s = "C" wird an die Fkt. functionS zurückgegeben, fertig?

else-Teil:
Müsste man das summandweise betrachten? Oder beide Summanden zusaammen berücksichtigen?

Danke im Voraus für Unterstützungen.
 
In einem Code-Tag funktionieren keine Color-Tags. Alles was im Code-Tag steht, wird so dargestellt. Dein Quellcode sieht daher sehr verwirrend aus, nimm die Color-Tags wieder raus.

C#:
public string functionS(String s)
{
      s = "Code";
      
      if (s == "1" || s.Length == 1 || s == "0")
      {
      // BLAU
            return s;
      }
      else
      {
      // GRÜN
            return functionS(s.Substring(1)) + s.Substring(0, 1);
      } 
}
 
Danke für den Hinweis, habe ich nachhinein feststellen müssen und wurde korrgiert.
 
Ich verstehe gerade nicht ganz, was die Funktion tun soll.

Die Funktion bekommt einen Parameter s vom Typ String übergeben, danach wird s aber direkt der Wert "Code" zugeordnet. D.h. die if-Bedingung schlägt nie zu und du bist in einer Endlosschleife.
 
  • Gefällt mir
Reaktionen: Raijin
Das ist ein rekursive Funktion, sollte aber eigentlich leicht verständlich sein.

Ist das eine Hausaufabe oder sowas?


Eigentlich kann man die Funktion genau so lesen wie sie da steht:

Wenn s "1" enthält oder genau ein Zeichen lang ist (das schließt im übrigen auch ="1" mit ein, nur mal so) oder s enthält "0" (wird niemals ausgewertet, da bereits Länge = 1 getriggert hat), dann gib das Zeichen zurück.
Andernfalls wiederhole den Vorgang, aber diesmal mit verändertem s.




@Chris_S04 hat vollkommen Recht! Das habe ich beim entfernen des Color-Tags überlesen.
 
ganz vom obigen abgesehen: die if-kondition ist auch nicht so ganz sinnig, da der letzte teil nicht erreicht werden kann. fuer s == "0" gilt ja bereits s.Length == 1; also ist ersteres (an letzter stelle) ueberfluessig.
 
Die Funktion ruft sich selbst unendlich oft auf und wird das Programm abschmieren lassen.
Die eigentliche Funktion sollte eine rekursive Umkehrung von Strings sein. Also letztes Zeichen zuerst, erstes Zeichen zuletzt.

bog schrieb:
fuer s == "0" gilt ja bereits s.Length == 1; also ist ersteres (an letzter stelle) ueberfluessig.

s.Length == 1 deckt auch den Fall s == "1" ab, somit ist nur eine Bedingung nötig.
 
Die Fkt. ist eine Art Platzhalter für eine String Methode (Reverse). Ich versuche die if-Anweisung nachzuvollziehen, was sie genau hierbei tut?
 
KingLz schrieb:
Die Funktion ruft sich selbst unendlich oft auf und wird das Programm abschmieren lassen.
Die eigentliche Funktion sollte eine rekursive Umkehrung von Strings sein. Also letztes Zeichen zuerst, erstes Zeichen zuletzt.



s.Length == 1 deckt auch den Fall s == "1" ab, somit ist nur eine Bedingung nötig.

Du liegst jedenfalls richtig mit deiner Ausführung. Ich würde gerne die gesamte if-Anweisung verstehen.
Kannst du evt. bitte genau beschreiben, was in beiden Teilen (if und else) passiert?

Ich verstehe if-Teil so: s. mein Ausgangsthread, richtig?
else-teil: hmmh...?
 
gamma_matrices schrieb:
Die Fkt. ist eine Art Platzhalter für eine String Methode (Reverse). Ich versuche die if-Anweisung nachzuvollziehen, was sie genau hierbei tut?

Die Idee ist folgende:

Wir nehmen z.B. den String "abc" und wollen ihn umdrehen, schreiben aber eine Funktion (deine) die nur 1 Zeichen umdrehen kann. Aus "abc" wird so im ersten Schritt "bc" + "a". Jetzt wenden wir die Funktion auf den Rest "bc" (rekursiv) an und bekommen "c" + "b" + "a". Jetzt ist der Rest nur noch "c", auf den die Funktion aber nochmal angewendet wird. In der Funktion deklarieren wir deswegen, wenn die Eingabe nur 1 Zeichen groß ist, dann müssen wir nichts mehr umdrehen und liefern die Eingabe einfach zurück.

Ungefähr die Idee verstanden?

Bei der Funktionsweise ist die die Implementierung aktuell aber noch sehr fehlerhaft, da musste halt nochmal drüberschauen. ;)

Edit: die Reihenfolge war falsch, sry ^^.
 
Zuletzt bearbeitet:
KingLz schrieb:
Die Idee ist folgende:

Wir nehmen z.B. den String "abc" und wollen ihn umdrehen, schreiben aber eine Funktion (deine) die nur 1 Zeichen umdrehen kann. Aus "abc" wird so im ersten Schritt "bc" + "a". Jetzt wenden wir die Funktion auf den Rest "bc" (rekursiv) an und bekommen "b" + "c" + "a". Jetzt ist der Rest nur noch "b", auf den die Funktion aber nochmal angewendet wird. In der Funktion deklarieren wir deswegen, wenn die Eingabe nur 1 Zeichen groß ist, dann müssen wir nichts mehr umdrehen und liefern die Eingabe einfach zurück.

Ungefähr die Idee verstanden?

Bin mir nicht wirklich ganz sicher. Du sprichst aber hierbei nur vom if-Teil, oder?
Wird beim if-Teil denn nicht nur einmal der Wert zurückgegeben und zwar s = "C" und dann geht es weiter mit else-Teil?

KingLz schrieb:
Bei der Funktionsweise ist die die Implementierung aktuell aber noch sehr fehlerhaft, da musste halt nochmal drüberschauen. ;)

Ja, bekomme leider den Fehler Typ- oder Namespacedefinition oder Dateiende erwartet.
 
Also unsere Funktion soll einen String umdrehen, kann aber immer nur ein Zeichen auf einmal.
Dann gilt:

Wenn die Eingabe nur 1 Zeichen lang ist, dann müssen wir nichts umdrehen. (if s.Length == 1)
Ansonsten (else) drehen wir ein Zeichen um und rufen die Funktion für den Rest nochmal auf:
Der Rest vom String ist: functionS(s.Substring(1))
Das erste Zeichen ist s.Substring(0, 1)
 
KingLz schrieb:
Also unsere Funktion soll einen String umdrehen, kann aber immer nur ein Zeichen auf einmal.
Dann gilt:

Wenn die Eingabe nur 1 Zeichen lang ist, dann müssen wir nichts umdrehen. (if s.Length == 1)
Ansonsten (else) drehen wir ein Zeichen um und rufen die Funktion für den Rest nochmal auf:
Der Rest vom String ist: functionS(s.Substring(1))
Das erste Zeichen ist s.Substring(0, 1)

Ok, ich glaube jetzt wirds mir eher klarer.

if-Teil: ist immer erfüllt, da s.Length ==1.
else-Teil: vielleicht sehe cih gerade den wald voller lauter Bäume nicht. Agieren beide Summanden zusammen oder getrennt? Denn ...s.Substring(1) bezieht sich auf Indexposition 1 und s.Substring(0,1) bezieht sich immer auf das erste Zeichen
 
Du weißt wie Stringverkettung funktioniert?

Man kann (in vielen Sprachen) Strings mit + zusammenfügen.
Also "ab" + "c" ergibt den String "abc".

Substring(1) ist, der Rest ab der 1. Position, wie in meinem Beispiel. Substring(0,1) ist die 1. Position bis ausschließlich 2. Position, also nur das erste Zeichen.

Wenn s "abc" ist, dann wäre die letzte Zeile:
return functionS("bc") +"a" ;

functionS("bc") ergibt dann return functionS("c") +"b" ;
Und functionS("c") ist 1 Zeichen lang, also return "c";

In meiner vorherigen Erklärung hatte ich übrigens b und c vertauscht. Also das Ergebnis von "abc" sollte immer "cba" sein.
 
  • Gefällt mir
Reaktionen: gamma_matrices und Raijin
KingLz schrieb:
Du weißt wie Stringverkettung funktioniert?

Man kann (in vielen Sprachen) Strings mit + zusammenfügen.
Also "ab" + "c" ergibt den String "abc".

Substring(1) ist, der Rest ab der 1. Position, wie in meinem Beispiel. Substring(0,1) ist die 1. Position bis ausschließlich 2. Position, also nur das erste Zeichen.

Wenn s "abc" ist, dann wäre die letzte Zeile:
return functionS("bc") +"a" ;

functionS("bc") ergibt dann return functionS("c") +"b" ;
Und functionS("c") ist 1 Zeichen lang, also return "c";

In meiner vorherigen Erklärung hatte ich übrigens b und c vertauscht. Also das Ergebnis von "abc" sollte immer "cba" sein.

Ja natürlich...ich :hammer_alt:

Ich gehe nochmal den else-Teil durch, also:

"Code"
"ode" + "C"
"de" + "o"
"e" + "d"
"e" + "e" ===> also eine Endlosschleife!

Danke für die Unterstützung!
 
Zuletzt bearbeitet:
KingLz schrieb:
Bei der Funktionsweise ist die die Implementierung aktuell aber noch sehr fehlerhaft, da musste halt nochmal drüberschauen. ;)

Ich hatte nur gesehen gehabt, dass ich eine Klammer zu viel hatte, aber cih würde gerne zur Verifizierung das Ganze auch in der Konsole implementieren, komme aber leider trotz via Console.WriteLine() / .ReadKey nicht weiter. Ein Tipp eventuell?
 
Zeile 3 wird s immer wider auf "Code" gesetzt, von daher wird als s immer "oder übergeben und s dann wieder auf "Code" gesetzt. -> Endlosschleife.
 
Im Moment passiert folgendes:

functionS(s = irgendein String)
s = "Code"
return functionS("ode") + "C"

Da aber in functionS("Cod") s="Code" gesetzt wird, so wie beim 1. Mal auch, kommt wieder return functionS("ode") + "C".

D.h. die Funktion ruft sich selbst unendlich oft selbst auf, bis der Stack überläuft, aka das Programm abschmiert.

Edit: Ahh, war wieder falsch herum, jetzt ist richtig.
 
Zuletzt bearbeitet:
Zurück
Oben