C#: 反转句子中的单词

Question

以下代码用于反转句子中的单词，句子中单词的顺序将保持不变，但单词本身将被颠倒。

    using System;
    using System.Text;
    
    namespace reverse_a_string
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.Write("Enter a string: ");
                string S = Console.ReadLine();
                string[] sep = S.Split(" ");
                StringBuilder Wrev = new StringBuilder(); //Word reverse
                StringBuilder Srev = new StringBuilder(); //Sentence reverse
                for (int j=0;j<sep.Length;j++)
                {                
                    for (int i = sep[j].Length - 1; i >= 0; i--)
                    {
                        Wrev.Append(sep[j][i]);                   
                    }
                    Srev.Append(Wrev);
                    Wrev.Clear();
                    Wrev.Append(" ");
                }
                Console.WriteLine(Srev);
                        
            }
        }
    }

- PatraS

---

如果您有Unicode字符，请考虑查看https://dev59.com/XmUp5IYBdhLWcg3wz58H - undefined

这个回答解决了你的问题吗？如何简单地翻转句子中每个单词的顺序。 - undefined

然后有人提到中文书写时没有空格，这使得词与字的概念变得无关紧要。 - undefined

Answer 1

对于简单的文本，您可以使用Split、Reverse、Concat和Join。

var words = Console.ReadLine()
     .Split()
     .Select(x => string.Concat(x.Reverse()));

Console.WriteLine(string.Join(" ", words));

输出

Enter a string: asd sdf dfg fgh
dsa fds gfd hgf

对于复杂的Unicode，您需要更精确地分组字符。但是，您可以利用GetTextElementEnumerator。

返回一个枚举器，通过字符串的文本元素进行迭代。

给定：

public static IEnumerable<string> ToElements(this string source)
{
   var enumerator = StringInfo.GetTextElementEnumerator(source);
   while (enumerator.MoveNext())
      yield return enumerator.GetTextElement();
}

使用方法

var words = Console.ReadLine()
   .Split()
   .Select(x => string.Concat(x.ToElements().Reverse()));

- TheGeneral

Answer 2

    static void Main(string[] args)
    {
        //method 1
        Console.Write("Enter a string: ");
        string sentence = Console.ReadLine();
        string[] words = sentence.Split(" ");
        StringBuilder destination = new StringBuilder(); //Sentence reverse
        foreach (string word in words)
        {
            destination.Append(string.Concat(new string(word.Reverse().ToArray()), " "));
        }
        Console.WriteLine(destination);

        //method 2 but need import System.Linq namespace.
        var reversedWords = string.Join(" ", sentence.Split(' ').Select(x => new String(x.Reverse().ToArray())));
        Console.WriteLine(reversedWords);
    }

- bingbing

Answer 3

让我们从定义开始；假设

单词是一个非空的由字母和撇号组成的序列

我们可以使用正则表达式（以及一点儿Linq - Reverse()）来实现一个简单的解决方案：我们只需要使用Replace函数将每个单词替换为它的Reverse()表示。

代码：

  using System.Linq;
  using System.Text.RegularExpressions;

  ...

  private static string WordReverse(string value) => 
    Regex.Replace(value ?? "", @"[\p{L}_]+", m => string.Concat(m.Value.Reverse()));

演示：

  string[] tests = new string[] {
    "Text (на русском)",
    "Simple test.",
    "Another \"text\": punctuation!"
  };
 
  Console.Write(string.Join(Environment.NewLine, tests
    .Select(test => $"{test,-30} => {WordReverse(test)}")));

结果：

Text (на русском)              => txeT (ан мокссур)
Simple test.                   => elpmiS tset.
Another "text": punctuation!   => rehtonA "txet": noitautcnup!

- Dmitry Bychenko

Answer 4

//Without Using split, Concat and reverse inbuilt method of C# - 

int count = 0;
string s = Console.ReadLine();
char[] ch = s.ToCharArray();
for(int i= ch.Length-1; i>=0; i--)
            {
                if (ch[i] != ' ')
                {
                    count++;
                }
                else if (ch[i] == ' ')
                {
                    for(int j=i+1; count>0; j++)
                    {
                        Console.Write(ch[j]);
                        count--;
                    }
                    Console.Write(" ");
                }
            }

            for (int j = 0; j <= count; j++)
            {
                Console.WriteLine(ch[j]);
            }
            Console.ReadLine();

- RPA HEM