3

这是我的场景！

List<String> list = new List<String>();
list.Add("E9215001");
list.Add("E9215045");
list.Add("E1115001");
list.Add("E1115022");
list.Add("E1115003");
list.Add("E2115041");
list.Add("E2115042");
list.Add("E4115021");
list.Add("E5115062");

我需要使用 C# & LINQ 从上面的列表中提取以下常用部分

E92150 -> 从 {* E92150 *01, * E92150 *45}中提取

E11150 -> 从 {* E11150 *01, * E11150 *22, * E11150 *03}中提取

E21150 -> 从 {* E21150 *41, * E21150 *42}中提取

E41150 -> 从 {* E41150 *21}中提取

E51150 -> 从 {* E51150 *62}中提取

更新：谢谢！每个人！在@mlorbetske 和@shelleybutterfly 的帮助下，我想通了！

解决方案：

list.Select((item, index) => new {
Index=index, 
Length=Enumerable.Range(1, (item.Length-2)) //I'm ignoring the last 2 characters
                 .Reverse()
                 .First(proposedLength => list.Count(innerItem =>  
                   innerItem.StartsWith(item.Substring(0, proposedLength))) > 
                   1)}).Select(n => list[n.Index].Substring(0, n.Length)).Distinct()
4

4 回答 4

5

我怀疑这就是你要找的东西，但是

var result = list.Select(s => s.Substring(0, 6))
                 .Distinct();
于 2012-12-22T10:38:43.427 回答
1

是否需要内联查询语法？如果是这样，如何：

var result =
    from item in list
    select item.Substring(0,6);

或具有不同要求：

var result =
    (
        from item in list
        select item.Substring(0,6);
    )
    .Distinct();
于 2012-12-22T10:45:14.550 回答
1

我不确定确定匹配的标准是什么，所以我写了这个——它完全是新奇的，99.9999% 确定它实际上不是你想要的。

本质上，外部选择获取确定长度的所有子字符串。

第一个内部选择确定在列表中至少一个其他字符串中找到的此字符串的最大长度。

group by（在第一个内部选择之后）将找到的长度自己分组。

然后将此分组转换为长度与找到次数的字典。

Value然后，我们按找到长度（升序）的频率（）对这组分组进行排序。

接下来，我们取实际长度（最不频繁出现的长度 - from Key）并将其返回到的第二个参数中，Substring因此我们将子字符串从 0 变为该长度。当然，我们现在又回到了外部选择中，所以我们实际上正在获取值（万岁！）。

现在，我们从该结果中获取不同的值集，瞧！

list.Select(
    item => item.Substring(0, 
        list.Select(
            innerItem => Enumerable.Range(1, innerItem.Length)
                           .Reverse()
                           .First(proposedlength => list.Count(innerInnerItem => innerInnerItem.StartsWith(innerItem.Substring(0, proposedlength))) > 1)
                   )
            .GroupBy(length => length)
            .ToDictionary(grouping => grouping.Key, grouping => grouping.Count())
            .OrderBy(pair => pair.Value)
            .Select(pair => pair.Key)
            .First())
        ).Distinct()

在阅读了上面的评论之后，我发现人们也有兴趣找到每个术语中其他任何一个中存在的不同的最长子串。这是更新颖的代码：

list.Select((item, index) => new {
    Index=index, 
    Length=Enumerable.Range(1, item.Length)
                     .Reverse()
                     .First(proposedLength => list.Count(innerItem => innerItem.StartsWith(item.Substring(0, proposedLength))) > 1)
}).Select(n => list[n.Index].Substring(0, n.Length))
  .Distinct()

简而言之，遍历列表中的每个项目并收集条目的索引和从该元素的开头开始的最长子字符串，该元素可能在列表中的至少一个其他条目中找到。然后通过从每个索引/长度对中收集所有子字符串并仅获取不同的字符串集。

于 2012-12-22T11:23:54.833 回答
0

解决了！感谢@mlorbetske和@shelleybutterfly

list.Select((item, index) => new { Index=index, 
            Length=Enumerable.Range(1, (item.Length-2)) //I don't need the last 2 Char so I'm ignoring it
            .Reverse()
            .First(proposedLength => list.Count(innerItem =>  
             innerItem.StartsWith(item.Substring(0, proposedLength))) > 
             1)}).Select(n => list[n.Index].Substring(0, n.Length)).Distinct()
于 2012-12-22T14:01:05.250 回答