C# 两个字符串的特殊连接的更好方法

我想以这样的方式连接两个字符串，在第一个字符串的第一个字符之后，第二个字符串的第一个字符出现，然后第一个字符串的第二个字符出现，然后第二个字符串的第二个字符出现，依此类推。最好通过一些示例案例进行解释：

    s1="Mark";
    s2="Zukerberg";  //Output=> MZaurkkerberg

如果：

如果：

我已经编写了下面的代码，它给出了预期的输出，但是它似乎有很多代码。有没有更有效的方法

public void SpecialConcat(string s1, string s2)
        {
            string[] concatArray = new string[s1.Length + s2.Length];
            int k = 0;
            string final = string.Empty;
            string superFinal = string.Empty;
            for (int i = 0; i < s1.Length; i++)
            {
                for (int j = 0; j < s2.Length; j++)
                {
                    if (i == j)
                    {
                        concatArray[k] = s1[i].ToString() + s2[j].ToString();
                        final = string.Join("", concatArray);
                    }
                }
                k++;
            }
            if (s1.Length > s2.Length)
            {
                string subOne = s1.Remove(0, s2.Length);
                superFinal = final + subOne;
            }
            else if (s2.Length > s1.Length)
            {
                string subTwo = s2.Remove(0, s1.Length);
                superFinal = final + subTwo;
            }
            else
            {
                superFinal = final;
            }
            Response.Write(superFinal);
        }
    }

public void SpecialConcat（字符串s1、字符串s2）
{
字符串[]concatArray=新字符串[s1.Length+s2.Length]；
int k=0；
字符串final=string.Empty；
string superFinal=string.Empty；
对于（int i=0；is2.长度）
{
string subOne=s1.Remove（0，s2.Length）；
超细=最终+亚微米；
}
否则如果（s2.长度>s1.长度）
{
字符串子two=s2.删除（0，s1.长度）；
表面=最终+次表面；
}
其他的
{
表面=最终；
}
响应。写入（超文本）；
}
}

---

我也用Javascript编写了同样的逻辑，虽然效果很好，但还是有很多代码。

在Javascript中，当使用字符串时，您也在使用数组，因此会更容易。另外，

+

将为您连接。如果需要IE7-支持，请将字符串索引替换为

charAt

这是小提琴：

var s1=“标记”；
var s2=“ZuckerFace”；
var out=''；
变量l=s1.length>s2.length？s1.长度：s2.长度
对于（变量i=0；i

静态字符串联接（字符串a、字符串b）
{
字符串returnVal=“”；
整数长度=数学最小值（a.长度，b.长度）；
for（int i=0；i长度）
returnVal+=a.子字符串（长度）；
否则如果（b.长度>长度）
returnVal+=b.子串（长度）；
返回值；
}

可以通过stringbuilder改进

var stringbuilder=new stringbuilder（）；
var stringBuilder = new StringBuilder();
for (int i = 0; i < Math.Max(s1.Length, s2.Length); i++)
{
    if (i < s1.Length)
        stringBuilder.Append(s1[i]);

    if (i < s2.Length)
        stringBuilder.Append(s2[i]);
}

string result = stringBuilder.ToString();

对于（int i=0；i

就在我脑海中，我可能会这样做

        var s1Length = s1.Length;
        var s2Length = s2.Length;
        var count = 0;
        var o = "";
        while (s1Length + s2Length > 0) {
            if (s1Length > 0) {
                s1Length--;
                o += s1[count];
            }
            if (s2Length > 0) {
                s2Length--;
                o += s2[count];
            }
            count++;
        }

---

出于好奇，这里有一行无法阅读的单行文字（尽管如此，我还是将其拆分为多行；）

这使用了这样一个事实，即如果字符串已经至少达到某个长度，则将其填充到某个长度不会产生任何效果。这意味着将每个字符串的长度填充到另一个字符串的长度，结果是将较短字符串的长度填充到较长字符串的长度

然后我们使用

.Zip（）

将每对字符连接成一个字符串

然后我们调用

string.Concat（IEnumerable）

将压缩后的字符串连接成单个字符串

最后，我们使用

string.Replace（）

删除前面引入的额外填充空间

在一行[在此插入编码图标]：

var result = string.Concat(s1.PadRight(s2.Length).Zip(s2.PadRight(s1.Length), (a,b)=>string.Concat(a,b))).Replace(" ", null);

---

这是另一条单行线：

var s1 = "Mark";
var s2 = "Zukerberg";
var result = string.Join("", 
  Enumerable.Range(0, s1.Length).ToDictionary(x => x * 2, x => s1[x])
  .Concat(Enumerable.Range(0, s2.Length).ToDictionary(x => x * 2+1, x => s2[x]))
  .OrderBy(d => d.Key).Select(d => d.Value));

基本上，这会将两个字符串都转换为字典，其中的键将使生成的字符串正确排序。可枚举范围用于将索引与字符串中的每个字母相关联。当我们存储字典时，它将s1上的索引乘以2，得到，，，然后将s2乘以2，再加上1，得到，，，等等

---

一旦我们有了这些字典，我们就把它们和.Concat结合起来，并用.OrderBy对它们进行排序，它给我们，，，，。。。然后我们只需将它们转储到最后一个字符串中，并在开始处使用string.join。

好的，这是我能想到的*第二个最短解决方案：

    public string zip(string s1, string s2)
    {
        return (string.IsNullOrWhiteSpace(s1+s2))
            ? (s1[0] + "" + s2[0] + zip(s1.Substring(1) + " ", s2.Substring(1) + " ")).Replace(" ", null)
            : "";
    }

    var result =  zip("mark","zukerberg");

哎呀！我原来的最短的和上面马克的一样…所以，我能想出第二个最短的！我曾希望我能真正用递归来精简它，但并没有这么多。

var sWordOne=“mark”//ABCDEF
var sWordOne = "mark";// ABCDEF
var sWordTwo = "zukerberg";// 123
var result  = (sWordOne.Length > sWordTwo.Length) ? zip(sWordOne, sWordTwo) : zip(sWordTwo, sWordOne);
//result = "zmuakrekrberg"


 static string zip(string sBiggerWord, string sSmallerWord)
{
    if (sBiggerWord.Length < sSmallerWord.Length) return string.Empty;// Invalid 
    if (sSmallerWord.Length == 0) sSmallerWord = " ";
    return string.IsNullOrEmpty(sBiggerWord) ? string.Empty : (sBiggerWord[0] + "" + sSmallerWord[0] + zip(sBiggerWord.Substring(1),sSmallerWord.Substring(1))).Replace(" ","");
}

var swordwo=“zukerberg”//123
var结果=（sWordOne.Length>swordtw.Length）？拉链（剑道，剑道）：拉链（剑道，剑道）；
//结果=“zmuakrekrberg”
静态字符串zip（字符串sBiggerWord、字符串sSmallerWord）
{
if（sBiggerWord.Length

一个没有Linq巫术的简单选择：

string Merge(string one, string two)
{
    var buffer = new char[one.Length + two.Length];
    var length = Math.Max(one.Length, two.Length);
    var index = 0;

    for (var i = 0; i < length; i ++)
    {
        if (i < one.Length) buffer[index++] = one[i];
        if (i < two.Length) buffer[index++] = two[i];
    }

    return new string(buffer);
}

字符串合并（字符串一、字符串二）
{
var buffer=new char[one.Length+two.Length]；
变量长度=数学最大值（1.length，2.length）；
var指数=0；
对于（变量i=0；i

@Jonesy没有什么只是为了好玩和练习。：）使用IEnumerable.Zip。您需要ta自己添加尾随字符。在您进行更改后，现在可以添加：-）如果有必要，旧浏览器（至少是IE 7及之前的浏览器）不支持

String[index]

-您应该使用

String.ch
var result = string.Concat
(
    s1.PadRight(s2.Length)
    .Zip
    (
        s2.PadRight(s1.Length), 
        (a,b)=>string.Concat(a,b)
    )
).Replace(" ", null);

var result = string.Concat(s1.PadRight(s2.Length).Zip(s2.PadRight(s1.Length), (a,b)=>string.Concat(a,b))).Replace(" ", null);

var s1 = "Mark";
var s2 = "Zukerberg";
var result = string.Join("", 
  Enumerable.Range(0, s1.Length).ToDictionary(x => x * 2, x => s1[x])
  .Concat(Enumerable.Range(0, s2.Length).ToDictionary(x => x * 2+1, x => s2[x]))
  .OrderBy(d => d.Key).Select(d => d.Value));

    public string zip(string s1, string s2)
    {
        return (string.IsNullOrWhiteSpace(s1+s2))
            ? (s1[0] + "" + s2[0] + zip(s1.Substring(1) + " ", s2.Substring(1) + " ")).Replace(" ", null)
            : "";
    }

    var result =  zip("mark","zukerberg");

var sWordOne = "mark";// ABCDEF
var sWordTwo = "zukerberg";// 123
var result  = (sWordOne.Length > sWordTwo.Length) ? zip(sWordOne, sWordTwo) : zip(sWordTwo, sWordOne);
//result = "zmuakrekrberg"


 static string zip(string sBiggerWord, string sSmallerWord)
{
    if (sBiggerWord.Length < sSmallerWord.Length) return string.Empty;// Invalid 
    if (sSmallerWord.Length == 0) sSmallerWord = " ";
    return string.IsNullOrEmpty(sBiggerWord) ? string.Empty : (sBiggerWord[0] + "" + sSmallerWord[0] + zip(sBiggerWord.Substring(1),sSmallerWord.Substring(1))).Replace(" ","");
}

string Merge(string one, string two)
{
    var buffer = new char[one.Length + two.Length];
    var length = Math.Max(one.Length, two.Length);
    var index = 0;

    for (var i = 0; i < length; i ++)
    {
        if (i < one.Length) buffer[index++] = one[i];
        if (i < two.Length) buffer[index++] = two[i];
    }

    return new string(buffer);
}