C# 从字符串数组中创建较大的字符串

我有一个字符串数组，如下所示

var input = new [] { "AB-PQ", "PQ-EF", "EF=CD", "CD-IJ", "IJ=XY", "XY-JK" };

我想要一个字符串输出，应该是这样的

var output = "AB-PQ-EF=CD-IJ=XY-JK"

我想知道是否有更好的方法来实现这一点，而不是对循环使用蛮力，然后使用字符串生成器进行拆分和组合

我的业务用例： 我的业务用例是这样的：给定的字符串表示包含多个城市的路线中两个城市之间的链接序列。“-”表示道路连接，“=”表示铁路连接。城市代码可以是任意长度。

这适用于：

var input = new [] { "AB-PQ", "PQ-EF", "EF=CD", "CD-IJ", "IJ=XY", "XY-JK" };

var output = String.Join("",
    input.Take(1).Concat(new [] { String.Join("", input.Skip(1).Select(x => x.Substring(2))) }));

我不喜欢，但它很管用。它产生“AB-PQ-EF=CD-IJ=XY-JK”

---

尝试将此作为一个更可靠的替代方案：

void Main()
{
    var input = new[] { "AB-PQ", "PQ-XYZ", "XYZ=CD", "CD-A", "A=XY", "XY-JK" };

    var output =
        input
            .Select(i => new Segment(i))
            .Aggregate(
                "",
                (a, x) => a + x.ToString().Substring(a == "" ? 0 : x.Origin.Length));
}

public enum Mode
{
    Road, Rail
}

public sealed class Segment : IEquatable<Segment>
{
    private readonly string _origin;
    private readonly Mode _mode;
    private readonly string _destination;

    public string Origin { get { return _origin; } }
    public Mode Mode { get { return _mode; } }
    public string Destination { get { return _destination; } }

    public Segment(string descriptor)
    {
        var parts = descriptor.Split('-', '=');
        if (parts.Length != 2)
        {
            throw new System.ArgumentException("Segment descriptor must contain '=' or '-'.");
        }
        _origin = parts[0];
        _mode = descriptor.Contains("=") ? Mode.Rail : Mode.Road;
        _destination = parts[1];
    }

    public Segment(string origin, Mode mode, string destination)
    {
        _origin = origin;
        _mode = mode;
        _destination = destination;
    }

    public override bool Equals(object obj)
    {
        if (obj is Segment)
            return Equals((Segment)obj);
        return false;
    }

    public bool Equals(Segment obj)
    {
        if (obj == null) return false;
        if (!EqualityComparer<string>.Default.Equals(_origin, obj._origin)) return false;
        if (!EqualityComparer<Mode>.Default.Equals(_mode, obj._mode)) return false;
        if (!EqualityComparer<string>.Default.Equals(_destination, obj._destination)) return false;
        return true;
    }

    public override int GetHashCode()
    {
        int hash = 0;
        hash ^= EqualityComparer<string>.Default.GetHashCode(_origin);
        hash ^= EqualityComparer<Mode>.Default.GetHashCode(_mode);
        hash ^= EqualityComparer<string>.Default.GetHashCode(_destination);
        return hash;
    }

    public override string ToString()
    {
        return $"{_origin}{(_mode == Mode.Rail ? "=" : "-")}{_destination}";
    }

    public static bool operator ==(Segment left, Segment right)
    {
        if (object.ReferenceEquals(left, null))
        {
            return object.ReferenceEquals(right, null);
        }

        return left.Equals(right);
    }

    public static bool operator !=(Segment left, Segment right)
    {
        return !(left == right);
    }
}

void Main（）
{
var输入=新[]{“AB-PQ”、“PQ-XYZ”、“XYZ=CD”、“CD-A”、“A=XY”、“XY-JK”}；
无功输出=
输入
.选择（i=>新段（i））
.合计(
"",
（a，x）=>a+x.ToString（）子字符串（a==“0:x.Origin.Length”）；
}
公共枚举模式
{
公路、铁路
}
公共密封类段：IEquatable
{
私有只读字符串\u来源；
私有只读模式_模式；
专用只读字符串\u目的地；
公共字符串源代码{get{return}\u Origin；}
公共模式模式{get{return\u Mode；}}
公共字符串目的地{get{return}
公共段（字符串描述符）
{
var parts=descriptor.Split（'-'，'='）；
如果（parts.Length！=2）
{
抛出新的System.ArgumentException（“段描述符必须包含“=”或“-.”）；
}
_原点=零件[0]；
_mode=descriptor.Contains（“=”）mode.Rail:mode.Road；
_目的地=零件[1]；
}
公共段（字符串源、模式、字符串目标）
{
_原点=原点；
_模式=模式；
_目的地=目的地；
}
公共覆盖布尔等于（对象对象对象）
{
如果（obj是段）
返回等于（（段）obj）；
返回false；
}
公共布尔等于（段obj）
{
if（obj==null）返回false；
如果（！EqualityComparer.Default.Equals（_origin，obj._origin））返回false；
如果（！EqualityComparer.Default.Equals（_模式，对象模式））返回false；
如果（！EqualityComparer.Default.Equals（_destination，obj._destination））返回false；
返回true；
}
公共覆盖int GetHashCode（）
{
int hash=0；
hash^=EqualityComparer.Default.GetHashCode（_origin）；
hash^=EqualityComparer.Default.GetHashCode（_模式）；
hash^=EqualityComparer.Default.GetHashCode（_destination）；
返回散列；
}
公共重写字符串ToString（）
{
返回$“{u origin}{（{u mode==mode.Rail？”=”：“-”）}{u destination}”；
}
公共静态布尔运算符==（左段、右段）
{
if（object.ReferenceEquals（左，空））
{
return object.ReferenceEquals（右，null）；
}
返回左。等于（右）；
}
公共静态布尔运算符！=（左段、右段）
{
返回！（左==右）；
}
}

您可以使用和

字符串。按如下方式加入：

var input = new[]{"AB-PQ", "PQ-EF", "EF=CD", "CD-IJ", "IJ=XY", "XY-JK"};
var result = input[0] + string.Join("", input.Skip(1)
                          .Select(c => string.Join("", c.Skip(2))));

只是别忘了先使用

指令将其添加到您的

：

using System.Linq;

另一个版本：

var input = new [] {"AB-PQ", "PQ-EF", "EF=CD", "CD-IJ", "IJ=XY", "XY-JK"};
var output = string.Join("=", string.Join("-", input).Split('=').Select(x => string.Join("-", x.Split('-').Distinct())))

您可以定义
OverlappingCharCount
方法始终返回2（在您的示例中，字符串总是正好重叠2个字符），或者使用一些更智能的逻辑来处理更一般的情况。
使用Regex实现同样的目的：

string str = string.Join("-", input);
Regex oRegex = new Regex(@"\b(?<Captured>\w+)-\1\b",RegexOptions.IgnoreCase);
oRegex.Matches(str).Cast<Match>().ToList().ForEach(items=>str = str.Replace(items.ToString(), items.Groups["Captured"].ToString()));
Console.WriteLine(str);

string str=string.Join（“-”，输入）；
Regex-oRegex=new Regex（@“\b（？\w+）-\1\b”，RegexOptions.IgnoreCase）；
oRegex.Matches（str.Cast（）.ToList（）.ForEach（items=>str=str.Replace（items.ToString（），items.Groups[“Captured”].ToString（））；
控制台写入线（str）；
以下是完整的答案

using System;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = new string[] { "AB-PQ", "PQ-EF", "EF=CD", "CD-IJ", "IJ=XY", "XY-JK" };
            var output = input[0] + string.Join("", input.Skip(1).Select(c => string.Join("", c.Skip(2))));
            Console.WriteLine(output);
            Console.ReadLine();
        }
    }
}

这就是我正在使用的，它似乎在工作。这很容易理解

public static string Get(string[] array)
{
    var sb = new StringBuilder();
    for (var i = 0; i < array.Length - 1; i++)
    {
        var link = array[i];
        var words = link.Split('-', '=');
        sb.Append(words.First());

        // Link will contain either of the separators
        if (link.Contains('-'))
        {
            sb.Append('-');
        }

        if (link.Contains('='))
        {
            sb.Append('=');
        }
    }

    sb.Append(array.Last());
    return sb.ToString();
}

公共静态字符串Get（字符串[]数组）
{
var sb=新的StringBuilder（）；
对于（var i=0；i
这里的主要问题是，您已经描述了最终结果，这意味着您将得到的答案集中于获得特定的最终结果，而不是如何实现。那么
new[]{“AB-BC”、“CD-DE”、“BC-CD”}
呢？（注意顺序）从第一条到第二条，你需要描述你所遵循的规则，否则每次你提供更多信息时都会说“是的，但是…”对于这里的每一个答案，这只会浪费每个人的时间。我认为，是否有任何答案实际上比你的“暴力循环”更好，这是值得怀疑的。Linq仍在迭代数组中的每一项，但在循环中逻辑可以更清晰。将其简化为一行代码很好，但当它需要6或7个步骤时，可读性不强。@Enigmativity对此我很抱歉。我会更新我的问题。感谢指导初学者：）它不需要像这里写的那样是两个字母的东西。它可以是任何长度。e、 g.AB，XYZ，A，123etc@pango89-那这应该是你的问题了。请更新它。还请提供真实数据。
public static string Get(string[] array)
{
    var sb = new StringBuilder();
    for (var i = 0; i < array.Length - 1; i++)
    {
        var link = array[i];
        var words = link.Split('-', '=');
        sb.Append(words.First());

        // Link will contain either of the separators
        if (link.Contains('-'))
        {
            sb.Append('-');
        }

        if (link.Contains('='))
        {
            sb.Append('=');
        }
    }

    sb.Append(array.Last());
    return sb.ToString();
}