Reverse Wörter eines Satzes ohne Verwendung von String.Aufgeteilt in C#

Kürzlich bin ich gebeten worden, in einer Diskussion zu schreiben, einen Algorithmus zu implementieren Rückseite der Wörter eines Satzes (Nicht reverse ganzer Satz) ohne Verwendung von string-Operationen wie Split/Replace/Reverse/Join außer ToCharArray und Länge. Das unten ist das, was ich ersinnen konnte in 5min Zeit. Obwohl der Algorithmus funktioniert gut, es scheint bisschen hässlich Stil der Umsetzung. Können einige Körper helfen, mich durch das Polieren der code.

string ReverseWords(string s)
{
    string reverseString = string.Empty;
    string word = string.Empty;

    var chars = s.ToCharArray();
    List<ArrayList> words = new List<ArrayList>();
    ArrayList addedChars = new ArrayList();
    Char[] reversedChars = new Char[chars.Length];
    int i = 1;
    foreach (char c in chars)
    {
        if (c != ' ')
        {
            addedChars.Add(c);
        }
        else
        {
            words.Add(new ArrayList(addedChars));
            addedChars.Clear();
        }
        if (i == s.Length)
        {
            words.Add(new ArrayList(addedChars));
            addedChars.Clear();
        }
        i++;
    }
    foreach (ArrayList a in words)
    {
        for (int counter = a.Count - 1; counter >= 0; counter--)
        {
            reverseString += a[counter];
        }
        if(reverseString.Length < s.Length)
            reverseString += " ";
    }
    return reverseString;
}

Gut, wenn Sie vermeiden Split/Replace/Reverse/Join ... es ist gonna be ein bisschen hässlich ! !
Reverse ist eine Erweiterung Methode der IEnumerable, nicht eine string-Methode.

InformationsquelleAutor gee'K'iran | 2012-12-24

.net algorithm c#string

Dies ist etwas einfacher:

string inp = "hai how are you?";
StringBuilder strb = new StringBuilder();
List<char> charlist = new List<char>();
for (int c = 0; c < inp.Length; c++ )
{

    if (inp[c] == ' ' || c == inp.Length - 1)
    {
        if (c == inp.Length - 1)
            charlist.Add(inp[c]);
        for (int i = charlist.Count - 1; i >= 0; i--)
            strb.Append(charlist[i]);

        strb.Append(' ');
        charlist = new List<char>();
    }
    else
        charlist.Add(inp[c]);
}
string output = strb.ToString();

Dies ist, was die Polierte version des obigen Algorithmus, die ich gefragt haben. Dank kovilpatti C schärfer
Hier ist ein weiterer BESTE Lösung -> stackoverflow.com/questions/1009160/...

InformationsquelleAutor Uthistran Selvaraj

Dort ist eine relativ elegante Lösung, die über einen LIFO-stack.

Frage aber klingt nach Hausaufgabe, also werde ich nur den pseudo-code.

currWord = new LIFO stack of characters
while (! end of string/array)
{
  c = next character in string/array
  if (c == some_white_space_character) {
     while (currWord not empty) {
       c2 = currWord.pop()
       print(c2)
     }
     print(c)
  }
  else
    currWord.push(c)
}

diese scheint zu laufen, der in quadratischen Zeit, bin ich richtig?
Ich glaube, dass Sie richtig sind. Interessantes Konzept aber.

InformationsquelleAutor mjv

Art von einer polierten version:-

string words = "hi! how are you!";
string reversedWords = "";

List<int> spaceEncounter = new List<int>();
spaceEncounter.Add(words.Length - 1);

for (int i = words.Length - 1; i > 0; i--)
{ 
    if(words[i].Equals(' '))
    {
        spaceEncounter.Add(i);

        for (int j = i+1; j < spaceEncounter[spaceEncounter.Count - 2]; j++)
            reversedWords += words[j];

        reversedWords += " ";
    }
}

for (int i = 0; i < spaceEncounter[spaceEncounter.Count - 1]; i++)
    reversedWords += words[i];

Schönes Beispiel für die Umkehrung der Sätze. Dank

InformationsquelleAutor Sandeep Shankar

verwenden stack in C#

string str = "ABCDEFG";
Stack<char> stack=new Stack<char>();
foreach (var c in str)
{
    stack.Push(c);
}
char[] chars=new char[stack.Count];
for (int i = 0; i < chars.Length; i++)
{
    chars[i]=stack.Pop();
}
var result=new string(chars); //GFEDCBA

InformationsquelleAutor Ali Bayat

1

Gibt es einen kleinen bug in deinem code. Aufgrund dieser, der Ausgabe-string angezeigt werden würde, wie yo are how hi! angesichts der input-string hi! how are you. Es ist abschneiden der letzten Zeichen des letzten Wortes.

Ändern:
```
spaceEncounter.Add(words.Length - 1);
```
:
```
spaceEncounter.Add(words.Length);
```
InformationsquelleAutor Sushant

Gut, Sie sagen nicht etwas über die anderen LINQ-extension-Methoden 🙂

static string ReverseWordsWithoutSplit(string input)
{
    var n = 0;
    var words = input.GroupBy(curr => curr == ' ' ? n++ : n);

    return words.Reverse().Aggregate("", (total, curr) => total + string.Concat(curr.TakeWhile(c => c != ' ')) + ' ');
}

🙂 Zustand ist, dass ich nicht verwenden-framework-features wie linq. Danke für die Antwort obwohl. Es ist sauber und schön.

InformationsquelleAutor Asad Saeeduddin

        string temp = string.Empty;
        string reversedString = string.Empty;

        foreach (var currentCharacter in testSentence)
        {
            if (currentCharacter != ' ')
            {
                temp = temp + currentCharacter;
            }
            else
            {
                reversedString = temp + " " + reversedString;
                temp = string.Empty;
            }
        }
        reversedString = temp + " " + reversedString;

InformationsquelleAutor bitbyte

Diese version arbeitet in-place, ohne zwischen-Datenstrukturen. Erstens, es kehrt die Zeichen in jedem Wort. "me too" => "em oot". Dann kehrt die ganze Zeichenfolge: "em oot" => "zu mir".

    public static string ReverseWords(string s)
    {
        if (string.IsNullOrEmpty(s))
            return s;

        char[] chars = s.ToCharArray();
        int wordStartIndex = -1;

        for (int i = 0; i < chars.Length; i++)
        {
            if (!Char.IsWhiteSpace(chars[i]) && wordStartIndex < 0)
            {
                //Remember word start index
                wordStartIndex = i;
            }
            else
            if (wordStartIndex >= 0 && (i == chars.Length-1 || Char.IsWhiteSpace(chars[i + 1]))) {
                //End of word detected, reverse the chacacters in the word range
                ReverseRange(chars, wordStartIndex, i);

                //The current word is complete, reset the start index  
                wordStartIndex = -1;
            }
        }

        //Reverse all chars in the string
        ReverseRange(chars, 0, chars.Length - 1);

        return new string(chars);
    }

    //Helper
    private static void ReverseRange(char[] chars, int startIndex, int endIndex)
    {
        for(int i = 0; i <= (endIndex - startIndex) / 2; i++)
        {
            char tmp = chars[startIndex + i];
            chars[startIndex + i] = chars[endIndex - i];
            chars[endIndex - i] = tmp;
        }            
    }

InformationsquelleAutor Boris Asipov

Wie über eine einfache rekursive Funktion, die prüft, ob ein "" und dann substring entsprechend?

    private static string rev(string inSent) { 
        if(inSent.IndexOf(" ") != -1) 
        { 
            int space = inSent.IndexOf(" "); 
            System.Text.StringBuilder st = new System.Text.StringBuilder(inSent.Substring(space+1)); 
            return rev(st.ToString()) + " " + inSent.Substring(0, space); 
        } 
        else 
        { 
            return inSent; 
        } 
    }

Das ist Java nicht C# !
Entweder Art und Weise, Logik,... Jetzt finde den Unterschied und werden Sie sicher, dass Sie mit System.Text.

InformationsquelleAutor Sakhile Vinny Daweti

Eines der am Einfachsten zu Beantworten ist wie Unten angegeben bitte gehen Sie über den

public static string ReversewordString(string Name)
    {
        string output="";
        char[] str = Name.ToCharArray();
        for (int i = str.Length - 1; i >= 0; i--)
        {
            if (str[i] == ' ')
            {
                output = output + " ";
                for (int j = i + 1; j < str.Length; j++)
                {
                    if (str[j] == ' ')
                    {
                        break;
                    }
                    output=output+ str[j];
                }
            }
            if (i == 0)
            {
                output = output +" ";
                int k = 0;
                do
                {
                    output = output + str[k];
                    k++;
                } while (str[k] != ' ');
            }
        }
        return output;
    }

InformationsquelleAutor XORG_99

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.