C# 如何在C中联合列表中的字符串

我有一个字符串列表，它提供了以天为单位的旅行信息，例如011110表示旅行在一周的第一天和最后一天不可用

现在有一个列表，其中包含如下信息 0111110, 1000001

因此，整个区块的运营日为1111111

我这里的问题是如何有效地合并行程以获得阻塞运行天数？

您可以使用按位或：

var x1 = Convert.ToByte("0111110", 2);
var x2 = Convert.ToByte("1000001", 2);

var foo = x1 | x2;

var bar = Convert.ToString(foo, 2);

您可以使用按位或：

var x1 = Convert.ToByte("0111110", 2);
var x2 = Convert.ToByte("1000001", 2);

var foo = x1 | x2;

var bar = Convert.ToString(foo, 2);

使用嵌套循环：

string[] strs = new string[] { "0111110", "1000001" };

char[] main = strs[0].ToCharArray();



for(int i = 0; i < 7; i++)
{
    if(main[i] == '1')
        continue;
    for(int j = 1; j < strs.Length; j++)
    {
        if(strs[j][i] == '1')
        {
            main[i] = '1';
            break;
        }
    }
}

string result = new string(main);

它比Kristofer的按位or更冗长，但如果要合并大量字符串，它应该非常快，因为一旦在特定位置生成1，它就会放弃。按位or方法有点幼稚，会导致更多不必要的转换。哪一个更有效可能取决于你的具体情况。按位方法也可能存在一些填充/长度问题，如果使用字节，则限制为8位；你只有7天，但有人可能会升级到一天做整整一个月。这种方法在这方面没有限制

按位N个字符串的方法：

byte r = 0;
for(int i = 0; i < strs.Length && r != 127; i++)
  r |= Convert.ToByte(strs[i], 2);

string res = Convert.ToString(t, 2).PadLeft(7, '0');

如果我们达到127，我们可以提前停止，因为这意味着达到1111111。前导零丢失，必须使用PadLeft和嵌套循环恢复：

string[] strs = new string[] { "0111110", "1000001" };

char[] main = strs[0].ToCharArray();



for(int i = 0; i < 7; i++)
{
    if(main[i] == '1')
        continue;
    for(int j = 1; j < strs.Length; j++)
    {
        if(strs[j][i] == '1')
        {
            main[i] = '1';
            break;
        }
    }
}

string result = new string(main);

它比Kristofer的按位or更冗长，但如果要合并大量字符串，它应该非常快，因为一旦在特定位置生成1，它就会放弃。按位or方法有点幼稚，会导致更多不必要的转换。哪一个更有效可能取决于你的具体情况。按位方法也可能存在一些填充/长度问题，如果使用字节，则限制为8位；你只有7天，但有人可能会升级到一天做整整一个月。这种方法在这方面没有限制

N个字符串按位逼近：

byte r = 0;
for(int i = 0; i < strs.Length && r != 127; i++)
  r |= Convert.ToByte(strs[i], 2);

string res = Convert.ToString(t, 2).PadLeft(7, '0');

---

如果我们达到127，我们可以提前停止，因为这意味着达到1111111。前导零丢失，必须使用PadLeft恢复。假设您不能使用与提供的字符串不同的类型，您可以将结果复制到数组中，并从中创建字符串：

var result = new char[7];
for (int i=0; i<7; i++)
    if (s1[i] == '1' || s2 == ['1'])
        result[i] = '1';

var finalResult = new string(result);

---

这是有效的，因为您只有两个分配—数组和字符串，七次迭代/比较，最多七个字符副本。

如果您不能使用与您提供的字符串不同的类型，您可以将结果复制到数组中，并从中创建字符串：

var result = new char[7];
for (int i=0; i<7; i++)
    if (s1[i] == '1' || s2 == ['1'])
        result[i] = '1';

var finalResult = new string(result);

    public static class OperationalBlockCalculator
    {
        public static string GetOperationalBlock(List<string> workingDays)
        {
            var operationalBlock = new StringBuilder("0000000");
            for (var day = 0; day < 7; day++)
            {
                if (workingDays.Any(x => x.ElementAt(day).Equals('1')))
                {
                    operationalBlock[day] = '1';
                }
            }
            return operationalBlock.ToString();
        }
    }

    [TestFixture]
    public class WhenIMergeTripWorkingDays
    {
        [Test]
        public void ThenItShouldReturnOperationalBlock()
        {
            var workingDays = new List<string> { "0110110", "1000001" };
            OperationalBlockCalculator.GetOperationalBlock(workingDays).Should().Be("1110111");
        }
    }

这是有效的，因为您只有两个分配—数组和字符串，七次迭代/比较，最多七个字符副本。

您可以使用一些简单的逻辑组合字符串

    public static class OperationalBlockCalculator
    {
        public static string GetOperationalBlock(List<string> workingDays)
        {
            var operationalBlock = new StringBuilder("0000000");
            for (var day = 0; day < 7; day++)
            {
                if (workingDays.Any(x => x.ElementAt(day).Equals('1')))
                {
                    operationalBlock[day] = '1';
                }
            }
            return operationalBlock.ToString();
        }
    }

    [TestFixture]
    public class WhenIMergeTripWorkingDays
    {
        [Test]
        public void ThenItShouldReturnOperationalBlock()
        {
            var workingDays = new List<string> { "0110110", "1000001" };
            OperationalBlockCalculator.GetOperationalBlock(workingDays).Should().Be("1110111");
        }
    }

    var combined= input1.Zip
        (
            input2, 
            (a,b) => a == '1' ? a : b
        ); 

这将为您提供一个可枚举的字符，您可以使用字符串的构造函数将其生成一个新字符串

var output = new string(combined.ToArray());

完整示例：

public static void Main()
{
    var input1 = "1110000";
    var input2 = "0001110";
    var combined = input1.Zip
        (
            input2, 
            (a,b) => a == '1' ? a : b
        ); 

    var result = new string(combined.ToArray());

    Console.WriteLine(result);
}

输出：

1111110

您可以使用一些简单的逻辑来组合字符串

    var combined= input1.Zip
        (
            input2, 
            (a,b) => a == '1' ? a : b
        ); 

这将为您提供一个可枚举的字符，您可以使用字符串的构造函数将其生成一个新字符串

var output = new string(combined.ToArray());

完整示例：

public static void Main()
{
    var input1 = "1110000";
    var input2 = "0001110";
    var combined = input1.Zip
        (
            input2, 
            (a,b) => a == '1' ? a : b
        ); 

    var result = new string(combined.ToArray());

    Console.WriteLine(result);
}

输出：

1111110

---

简单的答案是使用正确的数据结构而不是字符串。简单的答案是使用正确的数据结构而不是字符串。