是否使用 Linq 使用 C# 进行计数

本文关键字：使用 Linq 是否 | 更新日期: 2023-09-27 18:30:35

我知道这是一个新手问题，但无论如何，我感谢任何帮助......

苏泊我有一个骰子

public class Dice
{
   public int FaceValue { get; set; }
   public Dice(int faceValue)
   {
      this.FaceValue = faceValue; 
   }
}

还有一个结果类...

public class Result
{
   public Dice D1 { get; set; }
   public Dice D2 { get; set; }
   public Dice D3 { get; set; }
   // Always has three dices ...
   public Result(Dice d1,Dice d2,Dice d3)
   {
      D1 = d1;
      D2 = d2;
      D3 = d3; 
   }
}

还有一个类赌注...

public class Bet
{
   // A bet could have one , two , or three dices ....
   public List<Dice> Dices = new List<Dice>();
}

有没有非常简单的方法（LINQ与否）来计算单个赌注的次数（可以有一个，两个或三个骰子）

出现在总是有三个骰子的单个结果中？

如果我的投注列表有多个投注，请检查是否有任何投注出现在三个骰子的结果中？

例如 

Result.D1 = new Dice(1);
Result.D2 = new Dice(4);
Result.D3 = new Dice(1);
{ { new Dice(1), new Dice(4) } } appears 1 time ===> 1
{ { new Dice(1) } } appears 2 times ====> 2
{ { new Dice(4) , new Dice(1) , new Dice(1) } } appears 1 time ====> 1
{ { new Dice(5) , new Dice(2) , new Dice(3) } } doesn't appear ====> 0
{ { new Dice(1) , new Dice(6) , new Dice(6) },
{ new Dice(4) , new Dice(4) , new Dice(4) },
{ new Dice(1) , new Dice(2) , new Dice(3) },
{ new Dice(1) , new Dice(5) , new Dice(5) },
{ new Dice(1) , new Dice(1) , new Dice(4) },
{ new Dice(3) , new Dice(3) , new Dice(3) } } has one bet that is equal so ========> 1

是否使用 Linq 使用 C# 进行计数

public class Result
{
   public Dice D1 { get; set; }
   public Dice D2 { get; set; }
   public Dice D3 { get; set; }
   // Always has three dices ...
   public Result(Dice d1,Dice d2,Dice d3)
   {
      D1 = d1;
      D2 = d2;
      D3 = d3; 
   }
   public bool Match(IEnumerable<Dice> dice)
   {
        return ...; // Your comparison logic here
   }
}
var bets = new List<Bet>();
foreach(var bet in bets)
{
    var matchCount = bet.Count(x => Result.Match(x.Dices));
}

var dice = ShortForm(new[]{result.D1, result.D2, result.D3});
var betGoodCount = bets.Count(bet => BetInDice(bet, dice));

Dictionary<int, int> ShortForm(IEnumerable<Dice> dice)
{
   return dice
      .GroupBy(die => die.FaceValue)
      .ToDictionary(group => group.Key, group => group.Count);
}
bool BetInDice(Bet bet, Dictionary<int, int> dice)
{
  return ShortForm(bet.Dice)
    .All(pair => dice.ContainsKey(pair.Key) && pair.Value <= dice[pair.Key];
}

我假设你掷x骰子数量并下y注。然后，您要比较是否有任何投注或您的赌注是滚动的数字。

首先，您应该更改Bet类的结构。 

public class Bet
{
    public int FaceValue { get; set; }
}

原因是一个bet与一个face value有关。然后，您将获得一个投注列表，如下所示：

List<Bet> bets = new List<Bet>()
{
    new Bet() { FaceValue = 2 },
    new Bet() { FaceValue = 4 },
    //etc
};

将这些方法添加到Result类中：

private IEnumerable<int> CorrectBets(List<Dice> dice, List<Bet> bets)
{
    //use an linq join on their face values
    return from die in dice
           join bet in bets on die.FaceValue equals bet.FaceValue
           select die.FaceValue;
}
public int NumberOfCorrectBets(List<Bet> bets)
{
    var dice = new List<Dice>() { D1, D2, D3 };
    return CorrectBets(dice, bets).Count(); //this actually gets the count
}

现在唯一要做的就是创建一个List<Bet>对象并将其传递给 NumberOfCorrectBets 方法。

这应该考虑重复的骰子号码/投注号码。这意味着，如果您投注一个3并且一个3被掷出 2 次，您将获得 2 次答案。

相关文章：