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

var s1 = "Mark";
var s2 = "Zukerberg";
var common = string.Concat(s1.Zip(s2, (a, b) => new[]{a, b}).SelectMany(c => c));
var shortestLength = Math.Min(s1.Length, s2.Length);
var result = 
     common + s1.Substring(shortestLength) + s2.Substring(shortestLength);

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();

在JavaScript中，当处理字符串时，您也在处理数组，因此会更容易。此外，+将为您连接。如果需要IE7支持，请将字符串索引替换为charAt。

这是小提琴：

http://jsfiddle.net/z6XLh/1

var s1 = "Mark";
var s2 = "ZuckerFace";
var out ='';
var l = s1.length > s2.length ? s1.length : s2.length
for(var i = 0; i < l; i++) {
    if(s1[i]) {
        out += s1[i];
    }
    if(s2[i]){
        out += s2[i];
    }
}
console.log(out);

static string Join(string a, string b)
{
   string returnVal = "";
   int length = Math.Min(a.Length, b.Length);
   for (int i = 0; i < length; i++)
      returnVal += "" + a[i] + b[i];
   if (a.Length > length)
      returnVal += a.Substring(length);
   else if(b.Length > length)
      returnVal += b.Substring(length);
   return returnVal;
}

可以通过字符串生成器进行改进

为了好奇，这里有一个不可读的单行（尽管如此，我还是将其拆分为多行；）

这使用了这样一个事实，即如果字符串已经达到一定长度，则将字符串填充到一定长度不会有任何作用。这意味着将每个字符串填充到另一个字符串的长度，结果是用空格将较短的字符串填充到较长的字符串的长度。

然后，我们使用.Zip()将每对字符连接成一个字符串。

然后我们调用string.Concat(IEnumerable<string>)将压缩后的字符串连接成一个字符串。

最后，我们使用string.Replace()去除了前面介绍的额外填充空间。

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 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++;
        }

这是另一个线性：

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，得到<0，M>，<2，a>，<4，r>，<6，k>，并将s2乘以2，然后加1，得到<1，Z>，<3，u>，<5、k>等

一旦我们有了这些字典，我们就将它们与.Concat组合，并使用.OrderBy对它们进行排序，这将使我们<0，M>，<1，Z>，<2，a>，<3，u>，。。。然后，我们将它们转储到最后一个字符串中，并在开头添加字符串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 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(" ","");
}

一个没有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);
}