1

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

假设我有一个骰子

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

还有一个 Result 类...

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 与否）来计算一次投注的次数（可以有一个、两个或三个 Dice）

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

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

例如

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
4

3 回答 3

1 
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));
}
于 2013-09-07T15:47:18.947 回答
1 
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];
}
于 2013-09-07T18:45:47.450 回答
0

我假设您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方法。

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

于 2013-09-07T16:15:20.877 回答