Question

我试图为扑克提供解决方案。我已经掌握了确定最佳5张牌的所有逻辑。我遇到了比较多个阵列的问题，这些阵列在发生关系时具有更高的元素（关于手型）。

假设我们有一些潜在的冲刺赢家。

var low_flush = [2, 3, 4, 5, 7]
var medium_flush = [3, 4, 5, 6, 8]
var high_flush = [2, 3, 4, 5, 9]

我想构建一个函数，我将任意数量的数组传递给它，并返回＆＃34;最高的扑克牌＆＃34;或者在实际领带的情况下一系列的手：

function bestHand(hands){
  // 
  return high_hand
}

到目前为止，我所阅读的所有内容都是如何只比较两个数组，通常只有这两个数组才会看到它们是否相等。如果它有助于我的source code

我的第一个想法是迭代双手。并且对于每次迭代，再次迭代手以进行比较。只是考虑一下这个伪代码会让我头疼，并且认为他们可能是这个和/或图书馆更优雅的解决方案（不过是扑克图书馆）

我在代码库的其他部分使用下划线，所以随时也可以在回答中使用它！

Answer 1

您可以先使用reduce()来计算每个数组的总和

var total3 = high_flush.reduce(function(previousValue, currentValue) {
  return previousValue + currentValue;
}, 0);

之后将每个人推送到一个数组为total且名称为winner

的数组中

allhands.push({total: total1 , name: "low_flush"});

然后将它们与compare函数进行比较并对数组进行排序

function compare(a,b) {
  if (a.total < b.total)
    return -1;
  else if (a.total > b.total)
    return 1;
  else 
    return 0;
}
allhands.sort(compare);

工作示例：

var low_flush = [2, 3, 4, 5, 7];
var medium_flush = [2, 3, 4, 5, 8];
var high_flush = [2, 3, 4, 5, 9];
var allhands = [];

var total3 = high_flush.reduce(function(previousValue, currentValue) {
  return previousValue + currentValue;
}, 0);
allhands.push({total: total3 , name: "high_flush"});

var total1 = low_flush.reduce(function(previousValue, currentValue) {
  return previousValue + currentValue;
}, 0);
allhands.push({total: total1 , name: "low_flush"});

var total2 = medium_flush.reduce(function(previousValue, currentValue) {
  return previousValue + currentValue;
}, 0);
allhands.push({total: total2 , name: "medium_flush"});


function compare(a,b) {
  if (a.total < b.total)
    return -1;
  else if (a.total > b.total)
    return 1;
  else 
    return 0;
}
allhands.sort(compare);

console.log("The winner is "+allhands[allhands.length - 1].name +"With total:"+ allhands[allhands.length - 1].total );

<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

Answer 2

这看起来很愚蠢。但这似乎对我有用。

class Interface
{
    protected:
        virtual void virt(void) = 0;
};

static void bar(Interface *b);

template<class T>
class Foo : public Interface
{
    // How to properly say the local function bar is friend ?
    friend void bar(Interface *b);

        T val;

    public:
        void virt(void)
        {
        }

        void func(void)
        {
            bar(this);
        }
};

static void bar(Interface *b)
{
    b->virt(); // Error: virt() is protected.
}

int     main(void)
{
    Foo<int>    foo;

    foo.func();
    return 0;
}

Answer 3

显然你需要将一组手对象传递给这样的东西。

function getBest(...hands){
    return hands.sort((p,c) => p.weight() <= c.weight() ? -1:1)[hands.length-1]
}

当在领带条件下找出手掌物体的重量时，首先可以通过手的颜色（黑桃击败所有）来确定，然后通过2,3,4,5等俱乐部的卡值总和来确定，6,7,8,9,10,11（J），12（q），13（K），图14（a）。它们的总和都是104，所以对于钻石卡值可以是（104 + 2），（104 + 3），（104 + 4）等。对于心脏，你将值偏移208，而对于黑桃则偏移312。

hand.prototype.weight = function(){
                          return this.reduce((p,c) => p.value + c.value)
                        }

当然这只会处理平局条件。它不能告诉同花顺的冲洗。

Answer 4

看一下数组的reduce函数here。

示例：

var result = hands.reduce(function(prevHand, currentHand) {
    return compareHands(prevHand,currentHand) ? prevHand : currentHand;
});

这回答了有关比较多个数组的问题，但请记住它会将它减少到一个值，这可能不是完美的解决方案，因为你必须考虑绘制。在这种情况下，您的结果应该是一个数组，并在比较中推入数组或重新初始化并将其添加到数组中。

Answer 5

function bestHands(DescOrderedHands){
  bestHand = DescOrderedHands[0]
  bestHandScore = parseInt(_.map(bestHand, function(num){return num.toString}).join(""))
  _.each(DescOrderedHands, function(hand){
    stringHand = _.map(hand, function(num){return num.toString}).join("")
    if (parseInt(stringHand) > bestHandScore){
      bestHand = hand
    } 

  }
  return bestHand
}

Answer 6

首先，您必须确保函数中的所有数组具有相同的长度，然后必须对每个数组进行排序，最后必须比较每个数组的每个值。

你应该有这样的东西

function bestHand(hands){
  var best_hand = null;
  for(var i = 0; i < hands.length; ++i){
    hands[i] = hands[i].sort();
    if(i > 0){
      for(var j = 0; j < hands[i].length; ++j){
        if(best_hand[j] < hands[i][j]){
          best_hand = hands[i];
          break;
        }
        else if(best_hand[j] > hands[i][j]){
          break;
        }
      }
    }
    else{
      best_hand = hands[i];
    }
  }

  return best_hand;
}

确保在参数

中传递长度相同的数组

比较2个或更多排序的数组javascript

6 个答案: