C# 如何根据特定条件从另一个列表中创建新的字符串列表？

这是我能想到的最好的提问方式，细节如下。我花了一个小时才想出怎么问这个问题

假设我有5种（或更多）类型的文本文件——它们是由科学仪器生成的，每种都有一定的结果。让我们将这些“类型”称为A、B、C、D、E。文本文件的实际名称不会泄露这些信息，因此用户无法通过名称轻松看到它们是什么。如果它更容易，我们可以考虑一个“字符串”列表。{我不知道如何处理replace类型，但稍后我会担心这一点）

我想让用户选择将文本文件合并到一个联合文件中，但挑战是，合并某些类型没有意义（因为我觉得不值得讨论的原因）

我已经构建了兼容性的示例矩阵

        A   B   C   D   E
   A    1   1   1   1   0
   B    1   1   1   0   0
   C    1   1   1   1   0
   D    1   0   1   1   1
   E    0   0   0   1   1

这意味着我可以把A和B，C，D结合起来，但不能把E（等等）结合起来

现在，如果用户从文件列表中选择类型为“a、B和C”的文件（这些文件没有明显的类型），我想检查选择并说“是的，ABC是合法合并”，然后执行合并

如果用户选择A、B、C、D，我想说，不，你不能这样做，因为D与B不兼容-但是，你可以做A、B、C或A、C、D（因为D不应该是B的位置）

还和我在一起吗

我在代码中创建了上面的矩阵，并进入了一个循环结构，在这个结构中，我开始有点糊涂，我想在我发现自己失去家和家人之前，我可能会寻求一些帮助。我有一个相当大的评论部分，介绍我如何尝试做出选择。记住，“a”可以是“狗”，而“B”可以是“猫”等等

内部类兼容性检查
{
私有列表文件类型；
公共兼容性检查（）
{
//字符串是文本文件的唯一类型
FileTypes=新列表{“A”、“B”、“C”、“D”、“E”}；
int[，]相容性矩阵=
{
{1, 1, 1, 1, 0},
{1, 1, 1, 0, 0},
{1, 1, 1, 1, 0},
{1, 0, 1, 1, 1},
{0, 0, 0, 1, 1}
};
/*情景1*/
//user=所有合法用户的文件名列表
var userSelection=新列表{“A”、“B”、“C”}；
/*检查userSelection中的每个项目，并创建“合法”文件组合的数组？
*从A开始，找到兼容的匹配项B和C。检查B和C是否正常。
*答案应该是这样的，因为A、B和C可以组合在一起*/
/*情景2*/
//user=NOT ALL LEGAL=>D和B中的文件名列表不兼容
var userSelection2=新列表{“A”、“B”、“C”、“D”}；
/*在我的脑海中，我浏览了UserSelect2中的每一项
*以A为例，构建“A、B、C、D”，因为它是兼容的
*用C（是）和D（否）检查B-拆下D。
*完[甲,乙,丙]
*          
*从B开始，构建B、A、C
*检查A和C（是）
*完[乙,甲,丙]
*          
*从C开始，构建C、A、B
*检查A和B（是）
*完[C，A，B]
*      
*从D开始，构建D、A、C
*检查A和C（是）
*完[丁、甲、丙]
*      
*取第n个字符串并与n+1、n+2…n+（长度-n）进行比较
*  
*唯一的字符串集应该是A，B，C和A，C，D
*/
}
}

我希望这是清楚的。那么，实现这一任务的最佳方式是什么呢？递归、LINQ“魔术”、矩阵数学

[编辑：]我刚才的一个想法可能更容易实现，可能是显示一个文件列表，当用户选择它们时，我可以“停用”其他不兼容的选项。想象一下，在一个列表框或类似的地方选择“a”类型，如果上面的矩阵正在使用，请键入“E”文件将变灰。我想知道这是否会减少我的压力…？

你在看一个-特别是最大集团问题

有很多方法可以解决这个问题，但没有一种比指数时间更好

---

你的编辑听起来是一个更好的主意-随着你的进行，限制选择应该会更容易。

我没有太多时间来研究这个或重构我的代码，所以这更像是一个大脑垃圾场，但可能是一个开始并重构成更整洁的东西的好地方

public class StrongFileType
{
    private string _friendlyName = string.Empty;

    public StrongFileType(string friendlyName)
    {
        _friendlyName = friendlyName;
    }

    public IEnumerable<StrongFileType> CompatibleTypes { get; set; }

    public override string ToString()
    {
        return _friendlyName;
    }
}

private void SampleTest()
{
    // The possible types
    var typeA = new StrongFileType("A");
    var typeB = new StrongFileType("B");
    var typeC = new StrongFileType("C");
    var typeD = new StrongFileType("D");
    var typeE = new StrongFileType("E");

    // Setup possible compatible types
    typeA.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeB.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC };
    typeC.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeD.CompatibleTypes = new List<StrongFileType> { typeA, typeC, typeD, typeE };
    typeE.CompatibleTypes = new List<StrongFileType> { typeD, typeE };

    // Now do a check...
    var userSubmittedFilesValid = new List<StrongFileType> { typeA, typeB, typeC };
    CheckCompatible(userSubmittedFilesValid);
    var userSubmittedFilesInvalid = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    CheckCompatible(userSubmittedFilesInvalid);
}

private bool CheckCompatible(IEnumerable<StrongFileType> requestedFiles)
{
    // Useful for debugging
    var validList = new List<string>();
    var invalidList = new List<string>();

    foreach (StrongFileType fileType in requestedFiles)
    {
        string invalid = string.Empty;
        string validCombination = string.Empty;

        foreach (StrongFileType fileTypeToCheck in requestedFiles)
        {
            if (!fileType.CompatibleTypes.Contains(fileTypeToCheck))
            {
                // Show as not compatible and remove any previously valid combinations that match
                invalid += string.Format("{0} not compatible with {1}", fileType, fileTypeToCheck);
                validList.RemoveAll(x => x.Contains(fileType.ToString()) && x.Contains(fileTypeToCheck.ToString()));
            }
            else
            {
                validCombination += string.Format("{0}", fileTypeToCheck);
            }
        }

        // Add to respective lists
        if (!string.IsNullOrEmpty(validCombination) && !validList.Contains(validCombination))
        {
            validList.Add(validCombination);
        }
        if (!string.IsNullOrEmpty(invalid))
        {
            invalidList.Add(invalid);
        }
    }

    // Was valid?
    return invalidList.Count == 0;
}

公共类strong文件类型
{
私有字符串_friendlyName=string.Empty；
公共strong文件类型（字符串friendlyName）
{
_friendlyName=friendlyName；
}
公共IEnumerable兼容类型{get；set；}
公共重写字符串ToString（）
{
返回_friendlyName；
}
}
私有无效样本测试（）
{
//可能的类型
var typeA=新的StrongFileType（“A”）；
var typeB=新的strong文件类型（“B”）；
var typeC=新的StrongFileType（“C”）；
var typeD=新的StrongFileType（“D”）；
var typeE=新的strong文件类型（“E”）；
//设置可能的兼容类型
typeA.CompatibleTypes=新列表{typeA，typeB，typeC，typeD}；
typeB.CompatibleTypes=新列表{typeA，typeB，typeC}；
typeC.CompatibleTypes=新列表{typeA，typeB，typeC，typeD}；
typeD.CompatibleTypes=新列表{typeA，typeC，typeD，typeE}；
typeE.CompatibleTypes=新列表{typeD，typeE}；
//现在检查一下。。。
var userSubmittedFilesValid=新列表{typeA，typeB，typeC}；
CheckCompatible（UserSubmittedFileValid）；
var usersubmittedfileinvalid=新列表{typeA，typeB，typeC，typeD}；
CheckCompatible（UserSubmittedFileInvalid）；
}
private bool CheckCompatible（IEnumerable requestedFiles）
{
//用于调试
var validList=新列表（）；
var invalidList=新列表（）；
foreach（请求文件中的StrongFileType文件类型）
{
字符串无效=string.Empty；
字符串vali
public class StrongFileType
{
    private string _friendlyName = string.Empty;

    public StrongFileType(string friendlyName)
    {
        _friendlyName = friendlyName;
    }

    public IEnumerable<StrongFileType> CompatibleTypes { get; set; }

    public override string ToString()
    {
        return _friendlyName;
    }
}

private void SampleTest()
{
    // The possible types
    var typeA = new StrongFileType("A");
    var typeB = new StrongFileType("B");
    var typeC = new StrongFileType("C");
    var typeD = new StrongFileType("D");
    var typeE = new StrongFileType("E");

    // Setup possible compatible types
    typeA.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeB.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC };
    typeC.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeD.CompatibleTypes = new List<StrongFileType> { typeA, typeC, typeD, typeE };
    typeE.CompatibleTypes = new List<StrongFileType> { typeD, typeE };

    // Now do a check...
    var userSubmittedFilesValid = new List<StrongFileType> { typeA, typeB, typeC };
    CheckCompatible(userSubmittedFilesValid);
    var userSubmittedFilesInvalid = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    CheckCompatible(userSubmittedFilesInvalid);
}

private bool CheckCompatible(IEnumerable<StrongFileType> requestedFiles)
{
    // Useful for debugging
    var validList = new List<string>();
    var invalidList = new List<string>();

    foreach (StrongFileType fileType in requestedFiles)
    {
        string invalid = string.Empty;
        string validCombination = string.Empty;

        foreach (StrongFileType fileTypeToCheck in requestedFiles)
        {
            if (!fileType.CompatibleTypes.Contains(fileTypeToCheck))
            {
                // Show as not compatible and remove any previously valid combinations that match
                invalid += string.Format("{0} not compatible with {1}", fileType, fileTypeToCheck);
                validList.RemoveAll(x => x.Contains(fileType.ToString()) && x.Contains(fileTypeToCheck.ToString()));
            }
            else
            {
                validCombination += string.Format("{0}", fileTypeToCheck);
            }
        }

        // Add to respective lists
        if (!string.IsNullOrEmpty(validCombination) && !validList.Contains(validCombination))
        {
            validList.Add(validCombination);
        }
        if (!string.IsNullOrEmpty(invalid))
        {
            invalidList.Add(invalid);
        }
    }

    // Was valid?
    return invalidList.Count == 0;
}