给一个字符串数组，输出不同的部分

豆包给出代码

/// <summary>
/// 字符串差异提取工具类（仅使用原字符串字符）
/// </summary>
public static class StringDiffExtractor
{
    /// <summary>
    /// 从字符串列表中提取差异部分，差异部分仅包含原字符串已有字符，且长度不小于指定最小值（若原字符串长度允许）
    /// </summary>
    /// <param name="inputStrings">输入的字符串列表</param>
    /// <param name="minLength">差异部分的最小长度（必须大于0）</param>
    /// <returns>各字符串对应的差异部分（完全来自原字符串）</returns>
    /// <exception cref="ArgumentOutOfRangeException">当minLength小于或等于0时抛出</exception>
    public static List<string> ExtractDiffParts(List<string> inputStrings, int minLength)
    {
        List<string> diffResults = new List<string>();

        if (inputStrings == null || inputStrings.Count == 0)
            return diffResults;

        // 单元素场景：差异部分就是字符串本身（长度不足时返回全部，不补位）
        if (inputStrings.Count == 1)
        {
            string singleStr = inputStrings[0];
            diffResults.Add(singleStr); // 直接返回原字符串，不添加任何外部字符
            return diffResults;
        }

        int commonPrefixLength = CalculateCommonPrefixLength(inputStrings);
        int commonSuffixLength = CalculateCommonSuffixLength(inputStrings);

        foreach (string str in inputStrings)
        {
            // 1. 原始差异区域（前缀后、后缀前）
            int originalDiffStart = commonPrefixLength;
            int originalDiffLength = str.Length - commonPrefixLength - commonSuffixLength;

            // 2. 计算需要扩展的长度（但不能超出字符串范围）
            int needExtendLength = Math.Max(0, minLength - originalDiffLength);
            int maxPossibleExtend = originalDiffStart; // 最多能向前扩展的长度（不能超过前缀起始位置）
            int actualExtendLength = Math.Min(needExtendLength, maxPossibleExtend);

            // 3. 调整提取范围（确保所有字符都来自原字符串）
            int adjustedStartIndex = originalDiffStart - actualExtendLength;
            int adjustedDiffLength = originalDiffLength + actualExtendLength;

            // 4. 最终提取（若总长度仍不足minLength，返回能提取的最大长度）
            if (adjustedStartIndex + adjustedDiffLength > str.Length)
            {
                adjustedDiffLength = str.Length - adjustedStartIndex;
            }

            string diffPart = adjustedDiffLength > 0
                ? str.Substring(adjustedStartIndex, adjustedDiffLength)
                : string.Empty;

            diffResults.Add(diffPart);
        }

        return diffResults;
    }

    /// <summary>计算共同前缀长度</summary>
    private static int CalculateCommonPrefixLength(List<string> strings)
    {
        int minStrLength = strings.Min(s => s.Length);
        for (int i = 0; i < minStrLength; i++)
        {
            char currentChar = strings[0][i];
            if (strings.Any(s => s[i] != currentChar))
                return i;
        }
        return minStrLength;
    }

    /// <summary>计算共同后缀长度</summary>
    private static int CalculateCommonSuffixLength(List<string> strings)
    {
        int minStrLength = strings.Min(s => s.Length);
        for (int i = 1; i <= minStrLength; i++)
        {
            char currentChar = strings[0][strings[0].Length - i];
            if (strings.Any(s => s.Length < i || s[s.Length - i] != currentChar))
                return i - 1;
        }
        return minStrLength;
    }

    public static void Test1()
    {
        // 测试数据
        var testData = new List<string>
        {
            "2T1283223072900029D1ZZZ",
            "2T1283223072900028D2ZZZ",
            "2T1283223072900027D3ZZZ",
            "2T1283223072900026D4ZZZ",
            "2T1283223072900025D5ZZZ",
            "2T1283223072900024D6ZZZ"
        };
        var results1 = StringDiffExtractor.ExtractDiffParts(testData, 0);

        testData = new List<string>
        {
            "NL5285A24071300005DEDF",
            "NL5285A24071300004DEDF",
            "NL5285A24071300003DEDF",
            "NL5285A24071300002DEDF"
        };
        var results2 = StringDiffExtractor.ExtractDiffParts(testData, 0);

        testData = new List<string>
        {
            "NL5285A24071300005",
            "NL5285A24071300004",
            "NL5285A24071300003",
            "NL5285A24071300002"
        };
        var results3 = StringDiffExtractor.ExtractDiffParts(testData, 0);

        testData = new List<string>
        {
            "E26U00089",
            "E26U00090",
            "E26U00091"
        };
        var results4 = StringDiffExtractor.ExtractDiffParts(testData, 0);
    }
    public static void Test2()
    {
        // 测试数据
        var testData = new List<string>
        {
            "2T1283223072900029D1ZZZ",
            "2T1283223072900028D2ZZZ",
            "2T1283223072900027D3ZZZ",
            "2T1283223072900026D4ZZZ",
            "2T1283223072900025D5ZZZ",
            "2T1283223072900024D6ZZZ"
        };
        var results1 = StringDiffExtractor.ExtractDiffParts(testData, 4);

        testData = new List<string>
        {
            "NL5285A24071300005DEDF",
            "NL5285A24071300004DEDF",
            "NL5285A24071300003DEDF",
            "NL5285A24071300002DEDF"
        };
        var results2 = StringDiffExtractor.ExtractDiffParts(testData, 4);

        testData = new List<string>
        {
            "NL5285A24071300005",
            "NL5285A24071300004",
            "NL5285A24071300003",
            "NL5285A24071300002"
        };
        var results3 = StringDiffExtractor.ExtractDiffParts(testData, 4);

        testData = new List<string>
        {
            "E26U00089",
            "E26U00090",
            "E26U00091"
        };
        var results4 = StringDiffExtractor.ExtractDiffParts(testData, 4);
    }
}