SomeButNotAll() 是否有优雅的 LINQ 解决方案？

Question

这是我总体上想做的事情。需要明确的是，这不是家庭作业，也不是比赛或任何事情。希望我的措辞足够清楚：

问题

给定一组相同格式的字符串，但其中一些以小写字母结尾，而另一些不以小写字母结尾，则返回一组不以小写字母结尾但至少有一个相同的字符串以小写字母结尾的字符串。

示例

为简单起见，假设字符串格式为\d+[a-z]?，其中公共部分是数字。给定{1, 4, 3a, 1b, 3, 6c}，我应该收到{1, 3} 的排列，因为 1 和 3 都有一个元素，末尾有和没有小写字母。

替代解决方案

你可以view this solution here。

我想到的一种方法是将集合划分为带和不带小写字母后缀的元素（{1, 4, 3} 和{3a, 1b, 6c}），然后返回withoutSuffix.Where(x => withSuffix.Any(y => y.StartsWith(x)))。

我有两个问题：

1. 我看不出用谓词Regex.IsMatch(input, "[a-z]$") 划分成两组的好方法。我想到的两个是两个定义相似的变量，每个变量都使用Where 子句并对每个元素进行两次正则表达式匹配，或者转换集合以存储正则表达式匹配结果，然后从中形成两个变量。 group...by 当你需要像这样访问这两个集合时似乎玩得不好，但我可能错了。

2. 虽然尺寸小到不关心性能，但每个withoutSuffix 元素通过withSuffix 一次似乎不优雅。

相关解决方案

你可以view this solution here。

想到的另一种方法是获取公共前缀和可选后缀：{1 => {"", b}, 3 => {a, ""}, 4 => {""}, 6 => {c}}。这可以通过使用正则表达式 ((\d+)([a-z])?) 捕获前缀和后缀并将前缀按前缀分组到 grouped 中轻松实现。

从这里开始就好了：

where grouped.SomeButNotAll(x => x == string.Empty)
select grouped.Key

甚至：

where grouped.ContainsSomeButNotAll(string.Empty)
select grouped.Key

我当然可以创建其中任何一个，但不幸的是，我在 LINQ 中看到的最好的是：

where grouped.Contains(string.Empty) && grouped.Any(x => x != string.Empty)
select grouped.Key

感觉超级多余。在 LINQ 中还有什么比这更好的吗？

附：我愿意接受更好的方法来解决整体问题，而不是把它变成一个 XY 问题。优雅比性能更重要，但是（也许只是我）纯粹的浪费似乎仍然不优雅。

Answer 1

我不认为你真的需要正则表达式。以下是我的做法：

var withEndings = new HashSet<string>();
var withoutEndings = new HashSet<string>();

foreach (var s in input)
    if(char.IsLower(s[s.Length - 1])) 
        withEndings.Add(s.Substring(0, s.Length - 1));
    else
        withoutEndings.Add(s);

var result = withEndings.Intersect(withoutEndings);

Answer 2

您可以通过 string.IsNullOrEmpty 添加另一个分组并验证它有 2 个组（一个用于 false，一个用于 true）：

return
    from str in strs
    let match = Regex.Match(str, STR_FORMAT)
    group match.Groups[2].Value by match.Groups[1].Value into parts
    where (parts.GroupBy(string.IsNullOrEmpty).Count() == 2)
    select parts.Key;

Answer 3

在这种情况下，我认为在 LINQ 中性能最高的解决方案不一定非常优雅。我认为这应该做你想做的，并在 O(N) 运行时间内完成。

values
.Aggregate(
new { HashSet1 = new HashSet<string>(), HashSet2 = new HashSet<string>() },
(a, x) =>
{
    // If the last character is a lowercase letter then put the string
    // (minus the last character) in HashSet1, otherwise, put the string
    // in HashSet2
    if(Char.IsLower(x, x.Length - 1))
    {
        a.HashSet1.Add(x.Substring(0, x.Length - 1));
    }
    else
    {
        a.HashSet2.Add(x);
    }
    return a;
},
a => 
{
    // Return all the strings that are present in both hash sets.
    return 
    a
    .HashSet1
    .Where(x => a.HashSet2.Contains(x));
});

Answer 4

.Where() 在每个元素上，对于每个元素，.Where() 在每个元素上再次，确保至少有一个符合原始元素的正则表达式模式加上任何一个小写字母。 p>

var input = new List<string>() { "1", "4", "3a", "1b", "3", "6c" };
var output = input.Where(
    x => input.Where(
        y => Regex.Match(y, "^" + Regex.Escape(x) + "[a-z]$").Success
    ).Any()
);

output 包含{ "1", "3" }。

Answer 5

您可以将.Any() 更改为!All()。

我更喜欢将 Count 重载与谓词一起使用并与总计数进行比较。这可能是最干净的，您不必担心由空集合引起的异常。