当其中任何一个变量可以是通配符时，检查 3 个变量是否相等的优雅方法是什么？

Question

假设我有 3 个 char 变量：a、b 和 c。
每个都可以是'0'，这是一种特殊情况，意味着它匹配每个字符。

因此，如果 a 是 '0'，我只需要检查是否 b == c。
我想检查是否 a == b == c，但发现 C# 中的实现变得混乱且冗长。

您可以提供任何有创意或漂亮的解决方案吗？

更新

性能驱动的 ，采用 Erik A. Brandstadmoen 的方法。 为了简单起见，使用M4N的apprach，我也做了一些修改： !(query.Any() && query.Distinct().Skip(1).Any())

Answer 1

像这样的事情：

var a = '1';
var b = '0';
var c = '1';

var chars = new List<char> { a, b, c };
var filtered = chars.Where(ch => ch != '0');
var allEqual = filtered.Count() == 0 || filtered.Distinct().Count() == 1;

解释解决方案：

• 首先将所有字符放入列表中，
• 排除所有为“0”的字符： .Where(ch => ch != '0')
• 所有剩余的字符都是相等，如果：
  • 剩余集合不包含任何元素：chars.Count() == 0
  • 或者唯一剩余元素的数量为 1：chars.Distinct().Count() == 1

---

更新：这是一个不同的版本，它不使用 LINQ，但仍然可读（IMO）。它作为一种方法实现，可以使用任意数量的待测试字符进行调用：

public bool AllEqualOrZero(params char[] chars)
{
    if (chars.Length <= 1) return true;
    char? firstNonZero = null;
    foreach (var c in chars)
    {
        if (c != '0')
        {
            firstNonZero = firstNonZero ?? c;
            if (c != firstNonZero) return false;
        }
    }
}

// Usage:
AllEqualOrZero('0', '0', '0'); // -> true
AllEqualOrZero('0', '1', '1'); // -> true
AllEqualOrZero('2', '1', '0'); // -> false
AllEqualOrZero();              // -> true
AllEqualOrZero('1');           // -> true

Answer 2

优雅的解决方案

这需要对 LINQ 有基本的了解，并且基于 M4N 的解决方案：

static bool IsMatch(params char[] chars)
{
    return chars.Where(c => c != '0')
                .Distinct().Count() <= 1;    
}

编辑

最初我的解决方案与 M4N 的解决方案不同，但经过一些简化后，我得到了（几乎）完全相同的解决方案。虽然功劳完全归他所有，但我仅供参考。

当集合中最多有一个个不同的非通配符时，它返回true。
我让它接受可变数量的参数，因此您可以调用 2、3 个或更多字符：

bool match = IsMatch('3', '3', '4', '0');

简单的解决方案

这是代码中逻辑的纯粹翻译，没有花哨的东西。

static bool IsMatch(char x, char y)
{
    return x == y || x == '0' || y == '0';
}

static bool IsMatch(char a, char b, char c)
{
    return IsMatch(a, b) && IsMatch(b, c) && IsMatch(a, c);
}

当参数相等或其中一个为 '0' 时，第一个 IsMatch 重载返回 true。
第二个重载只是调用每对的第一个重载。

（请注意，由于通配符，我们无法使用传递属性并仅比较两对。）

Answer 3

像这样的东西应该适用于任意数量的 char 值：

public class Comparer
{
    public static bool AreEqualOrZero(params char[] values)
    {
        var firstNonZero = values.FirstOrDefault(x => x != '0');
        return values.All(x => x == firstNonZero || x == '0');
    }
}

通过以下单元测试：

[TestClass()]
public class ComparerTest
{

    [TestMethod()]
    public void Matches_With_Wildcard()
    {
        char[] values = {'0', '1', '1', '1'};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Matches_With_No_Wildcard()
    {
        char[] values = {'1', '1', '1', '1'};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Matches_With_Only_Wildcards()
    {
        char[] values = {'0', '0', '0'};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Matches_With_Zero_Length()
    {
        char[] values = {};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Matches_With_One_Element()
    {
        char[] values = {'9'};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Matches_With_One_Wildcard_And_Nothing_Else()
    {
        char[] values = {'0'};
        Assert.IsTrue(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Does_Not_Match_On_NonEqual_Sequence_No_Wildcard()
    {
        char[] values = {'1', '2', '1', '1'};
        Assert.IsFalse(Comparer.AreEqualOrZero(values));
    }

    [TestMethod()]
    public void Does_Not_Match_On_NonEqual_Sequence_With_Wildcard()
    {
        char[] values = {'1', '2', '1', '0'};
        Assert.IsFalse(Comparer.AreEqualOrZero(values));
    }
}

Answer 4

bool MatchTwo(char a, char b)
{
    return a == '0' || b == '0' || a == b;
}

bool MatchThree(char a, char b, char c)
{
    return MatchTwo(a, b) && MatchTwo(a, c) && MatchTwo(b, c);
}

不确定我会称其为优雅，但它并不可怕（甚至可能是正确的......）（注意，这或多或少是对帕迪上面的答案的改进）。

Answer 5

您可以编写一个结构“MYChar”，它实现 char 并覆盖 Equals、相等运算符和隐式转换，这样您就可以执行以下操作：

MyChar a = 'a';
MyChar b = '0';

bool eq = a == b; //true

编辑

事实证明您不能继承char 因为它是密封的，但我尝试了以下代码。它可以编译，但我不确定它是否有效。我从 http://compilr.com/IDE/34853 编译它，但我没有任何东西到时候去测试一下。

就这样：

public struct MyChar
{
    private static char _wild = '0';

    private char _theChar;

    public MyChar(char c)
    {
        _theChar = c;
    }

    public MyChar ()
        :this (_wild)
    {}

    private bool IsWildCard ()
    {
        return _theChar.Equals (_wild);
    }        

    public static implicit operator char (MyChar c)
    {
        return c._theChar;
    }

    public static implicit operator MyChar (char c)
    {
        return new MyChar (c);
    }


    public override bool Equals (object obj)
    {
        if (!(obj is MyChar))
        {
            return base.Equals (obj);
        }
        else
        {
            if (IsWildCard ())
            {
                return true;
            }
            else
            {
                MyChar theChar = (MyChar) obj;
                return theChar.IsWildCard () || base.Equals ((char) theChar);
            }
        }
    }

    public override int GetHashCode ()
    {
        return _theChar.GetHashCode ();
    }
}

Answer 6

这算不算混乱且冗长？

对我来说似乎没问题，前提是你只能拥有他们三个......

return ((a == "0" || b == "0" || a == b) && (b =="0" || c =="0" || b == c) && (a =="0" || c =="0" || a == c));

Answer 7

如果你将字符限制为 ASCII 而不是 unicode 那么，我喜欢：
http://ideone.com/khacx。 （编辑回应评论指出我还没有完全正确地了解规格，但我仍然喜欢基本想法。添加了额外的测试作为验证）。

using System;
class example {
    static void elegant(char a, char b, char c) {
      int  y =  ((int) a - 48) + ((int) b - 48) + ((int) c - 48);
      int  z =  ((int) a - 48) * ((int) b - 48) * ((int) c - 48);

      bool result = y == ((int) a-48)*3 || (z ==0 && (a==b || b==c || a==c));
      Console.WriteLine(result);
    }
    static void Main() {

      elegant('0', 'b', 'c'); // false
      elegant('a', '0', 'c'); // false
      elegant('a', 'b', '0'); // false
      elegant('a', 'b', 'c'); // false
      elegant('0', '0', '0'); // true
      elegant('a', 'a', 'a'); // true
      elegant('0', 'a', 'a'); // true
      elegant('a', '0', 'a'); // true
      elegant('a', 'a', '0'); // true
      elegant('0', '0', 'a'); // true
      elegant('0', 'a', '0'); // true
      elegant('a', '0', '0'); // true
     }
}

对于涵盖无限数量字符的更通用的解决方案，这就是正则表达式的用途：^(.)(\1|0)*$

Answer 8

怎么样：

if ((a==b) && (b==c) && (a==c)) 
....
....

我的逻辑错了吗？

Answer 9

这与接受的答案没有太大不同，但无论如何

var list = new List<Char> {'1', '1', '0'};

var check = list.Where(ch => ch != '0')
                .Distinct()
                .Count() < 2;