C# 用C中的最后一个单词替换第一个单词#

我想替换C#中的以下行。将第一个单词替换为最后一个单词。我还必须从最后一个单词中删除“[”和“]”

string oldString = "200 abc def abc [a18943]"

输出应该是

string newString="a18943 abc def abc"; 

---

谢谢，这里有一个方法。注意，我假设字符串至少有1个单词长

string oldString = "200 abc def abc [a18943]";
string[] words = oldString.Split(' ');
StringBuilder sb = new StringBuilder(words[words.Length-1].Trim('[', ']'));
for (int i = 1; i < words.Length-1; i++)
{
    sb.Append (" ");
    sb.Append (words[i]);
}
string newString = sb.ToString();

string oldString=“200 abc def abc[a18943]”；
string[]words=oldString.Split（“”）；
StringBuilder sb=新的StringBuilder（单词[words.Length-1]。修剪（“[”，“]）；
for（int i=1；i

---

哎呀，修复了上面的一个打字错误。我不用先编译就可以编写代码。：-）

虽然很难看，但它很管用

string[] a = oldString.Split(' ');
var result = a.Skip( a.Length-1)
            .Select(w => w.Replace("[","").Replace("]",""))
            .Concat( a.Take( a.Length -1 ).Skip(1)).ToArray();

var newString = string.Join(" ", result);

尝试：

---

为了好玩，我写了一个小基准测试来测试所有这些答案（包括上面的另一个答案）。以下是在我的工作站（32位Core 2 Duo@2.66GHz）上使用发布版本重复5次的结果：

• 林克：10.545秒
• 我的拆分+StringBuilder方式：3.633秒
• 威贝克的分裂和连接方式！：3.32秒
• （未编译）正则表达式：3.845秒
• （已编译）正则表达式：12.431秒

结果：wipeck的Split and Join解决方案获胜，但（OP selected）regex解决方案只慢了15%，这让我很惊讶。我还以为会100%甚至更糟。NET正则表达式开发人员的速度令人赞叹

我认为，我自己的解决方案（使用Split和StringBuilder）针对速度进行了优化，但需要更多的代码，实际上并不能提高速度。啊

最令人惊讶的是，我尝试了一个已编译的正则表达式解决方案，它几乎比未编译的正则表达式慢3倍（而且我没有在结果中包括编译时间——包括编译时间，结果会更糟）。编译的regex perf advantage就到此为止

正如我所预料的，LINQ非常慢——所有这些额外对象和方法调用的开销真的加起来了

以下是测试代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

class Timer : IDisposable
{
    private DateTime _start;
    private string _name;

    public Timer(string name)
    {
        _name = name;
        _start = DateTime.Now;
    }
    public void Dispose()
    {
        TimeSpan taken = DateTime.Now - _start;
        Console.WriteLine(string.Format ("{0} : {1} seconds", _name, taken.TotalMilliseconds / 1000.0));
    }
}
class Program
{
    static void Main(string[] args)
    {
        int reps = 5000000;
        string oldString = "200 abc def abc [a18943]";

        using (new Timer("LINQ"))
        {
            for (int n = 0; n < reps; n++)
            {
                string[] a = oldString.Split(' ');
                var result = a.Skip(a.Length - 1)
                            .Select(w => w.Replace("[", "").Replace("]", ""))
                            .Concat(a.Take(a.Length - 1).Skip(1)).ToArray();

                var newString = string.Join(" ", result);
            }
        }

        using (new Timer("my Split + StringBuilder way"))
        {
            for (int n = 0; n < reps; n++)
            {
                string[] words = oldString.Split(' ');
                StringBuilder sb = new StringBuilder(words[words.Length - 1].Trim('[', ']'));
                for (int i = 1; i < words.Length - 1; i++)
                {
                    sb.Append(' ');
                    sb.Append(words[i]);
                }
                string newString = sb.ToString();
            }
        }

        using (new Timer("wipeck's Split-and-Join way!"))
        {
            for (int n = 0; n < reps; n++)
            {
                string valueString = "200 abc def abc [a18943]";
                string[] values = valueString.Split(' ');
                string lastWord = values[values.Length - 1];
                lastWord = lastWord.Trim('[', ']');
                values[0] = lastWord;
                string movedValueString = string.Join(" ", values, 0, values.Length - 1);
            }
        }

        using (new Timer("(uncompiled) regex"))
        {
            for (int n = 0; n < reps; n++)
            {
                string newString = Regex.Replace(@"^(\w+)(.+) \[(\w+)\]$", oldString, "$3$2");
            }
        }

        Regex regex = new Regex(@"^(\w+)(.+) \[(\w+)\]$", RegexOptions.Compiled);
        string newStringPreload = regex.Replace(oldString, "$3$2");
        using (new Timer("(compiled) regex"))
        {
            for (int n = 0; n < reps; n++)
            {
                string newString = regex.Replace(oldString, "$3$2");
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Text.RegularExpressions；
类计时器：IDisposable
{
私人日期时间(u start);；
私有字符串\u名称；
公共计时器（字符串名称）
{
_名称=名称；
_start=DateTime.Now；
}
公共空间处置（）
{
TimeSpan take=DateTime.Now-\u start；
WriteLine（string.Format（“{0}:{1}秒”，_name，take.totalmillizes/1000.0））；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
int代表=5000000；
string oldString=“200 abc def abc[a18943]”；
使用（新定时器（“LINQ”））
{
对于（int n=0；nw.Replace（“[”，”）。Replace（“]”，”））
.Concat（a.Take（a.Length-1）.Skip（1））.ToArray（）；
var newString=string.Join（“，result”）；
}
}
使用（新计时器（“我的拆分+StringBuilder方式”））
{
对于（int n=0；n

还可以使用.Trim（“[”，“]]”）来去除括号，如果最后一个单词总是以括号开头和结尾，那么括号可能会更干净一些。好主意--Trim也要快得多--将运行此操作所需的时间几乎减少一半。现在更新。另外，结果不是一个字符串，它是一个System.Linq.Enumerable.ConcatIteratorI，自从编辑它之后——newString当然会包含扁平字符串。明白了。顺便说一句，它的性能比获胜的（正则表达式）解决方案差3倍以上。可能不会有太大的区别，因为即使是最慢的解决方案在我（速度较慢）的PC上也能达到每秒400k，但值得思考的是，regex解决方案比LINQ解决方案有很大的优势，至少在这种情况下是这样。非常干净。我喜欢。我只是想知道正则表达式在这里是否有些过分？@NetQuestion:RegEx模式在括号内定义了3个组。它将匹配包含一个单词（\w+）后跟任何字符（.+），并以一个单词结尾并由[and]（\[（\w）\]$。替换是对第三组和第二组的反向引用的串联。而且速度也很快——我在这个线程上编写了一个解决方案的快速基准测试，正则表达式与获胜者的差距在15%以内，但它是迄今为止最干净的代码。这让我感到惊讶……我原以为正则表达式是sl

 Regex       : ^\w+(.*\s)\[(\w+)]$
 Replacement : $2$1

        string oldString = "200 abc def abc [a18943]";
        string[] values = oldString.Split(' ');
        string lastWord = values[values.Length - 1].Trim('[', ']');
        values[0] = lastWord;
        string newString = string.Join(" ", values, 0, values.Length - 1);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

class Timer : IDisposable
{
    private DateTime _start;
    private string _name;

    public Timer(string name)
    {
        _name = name;
        _start = DateTime.Now;
    }
    public void Dispose()
    {
        TimeSpan taken = DateTime.Now - _start;
        Console.WriteLine(string.Format ("{0} : {1} seconds", _name, taken.TotalMilliseconds / 1000.0));
    }
}
class Program
{
    static void Main(string[] args)
    {
        int reps = 5000000;
        string oldString = "200 abc def abc [a18943]";

        using (new Timer("LINQ"))
        {
            for (int n = 0; n < reps; n++)
            {
                string[] a = oldString.Split(' ');
                var result = a.Skip(a.Length - 1)
                            .Select(w => w.Replace("[", "").Replace("]", ""))
                            .Concat(a.Take(a.Length - 1).Skip(1)).ToArray();

                var newString = string.Join(" ", result);
            }
        }

        using (new Timer("my Split + StringBuilder way"))
        {
            for (int n = 0; n < reps; n++)
            {
                string[] words = oldString.Split(' ');
                StringBuilder sb = new StringBuilder(words[words.Length - 1].Trim('[', ']'));
                for (int i = 1; i < words.Length - 1; i++)
                {
                    sb.Append(' ');
                    sb.Append(words[i]);
                }
                string newString = sb.ToString();
            }
        }

        using (new Timer("wipeck's Split-and-Join way!"))
        {
            for (int n = 0; n < reps; n++)
            {
                string valueString = "200 abc def abc [a18943]";
                string[] values = valueString.Split(' ');
                string lastWord = values[values.Length - 1];
                lastWord = lastWord.Trim('[', ']');
                values[0] = lastWord;
                string movedValueString = string.Join(" ", values, 0, values.Length - 1);
            }
        }

        using (new Timer("(uncompiled) regex"))
        {
            for (int n = 0; n < reps; n++)
            {
                string newString = Regex.Replace(@"^(\w+)(.+) \[(\w+)\]$", oldString, "$3$2");
            }
        }

        Regex regex = new Regex(@"^(\w+)(.+) \[(\w+)\]$", RegexOptions.Compiled);
        string newStringPreload = regex.Replace(oldString, "$3$2");
        using (new Timer("(compiled) regex"))
        {
            for (int n = 0; n < reps; n++)
            {
                string newString = regex.Replace(oldString, "$3$2");
            }
        }
    }
}