小直 - 方法

Question

我已经坚持使用这种方法几天了。此方法检查5骰子的滚动==小直。它适用于某些数字。如果我滚动

  

1,2,4,3,6

它会起作用。但是，如果我滚动

  

1,2,4,3,3

它不起作用。我认为这是因为那里有重复的3。我需要以某种方式将它移到最后。

小直线是指有四个连续的模面值，例如1,2,3,4或3,4,5,6。它可以是任何顺序，例如2,3,1,4 < / p>

      int counter = 0;
      int score = 0;
      boolean found = false;
      Arrays.sort(die);

      for (int i = 0; i < die.length - 1; i++)
      {
          if (counter == 3)
              found = true;

          if (die[i + 1] == die[i] + 1)
          {
              counter++;
          }
          else if (die[i + 1] == die[i])
          {
              continue;
          }
          else
          {
              counter = 0;
          }
      }

      if (found)
      {
         score = 30; 
      }
      else
      {
          score = 0;
      }
      return score;
    }

Answer 1

副本3不是抛弃算法的东西。问题是您在迭代发生后检查直线。因此，如果最后一个骰子是直线的一部分，则无法识别。

要解决此问题，请移动

if (counter == 3) found = true;

到循环的END。应该工作。

编辑：所以看起来像这样。

for (/*...*/) {
  /* Everything else */

  if (counter == 3) {
      found = true;
      break;
  }
}

Answer 2

编辑：首先，如果一个小直线连续三次，那么你想看看计数器是否达到2，而不是3. 3.要求连续四次。

编辑for循环的开头，如下所示：

  for (int i = 0; i < die.length ; i++)
  {
      if (counter == 2)
          found = true;
      if (i == die.length - 1) break;
      //method continues here

推理：我想当你开始对这个方法进行编码时，当它到达阵列中的最后一个骰子时它会抛出IndexOutOfBoundsException，试图将它与不存在的第六个骰子进行比较而死亡。所以，你做了一个简短的循环停止。但是如果它停止了一个短路而小直线在最后一个骰子上完成，那么你再也没有进入循环以确认计数器是3并且发生了一个小直线。通过这种方式编辑循环的开始，它一直到最后一个元素，检查然后中断。

或者，在循环结束后进行最后一次检查：

  for (int i = 0; i < die.length - 1; i++)
  {
      if (counter == 2)
          found = true;
      if (die[i + 1] == die[i] + 1)
      {
          counter++;
      }
      else if (die[i + 1] == die[i])
      {
          continue;
      }
      else
      {
          counter = 0;
      }
  }

  found = (counter == 2); // or counter >= 2 if you want larger straights to be found too

  //continue method here

Answer 3

这应该计算最长的序列：

int longestSequence(int[] a) {
  Arrays.sort(a);
  int longest = 0;
  int sequence = 0;
  for (int i = 1; i < a.length; i++) {
    int d = a[i] - a[i - 1];
    switch (d) {
      case 0:
           // Ignore duplicates.
           break;
      case 1:
           sequence += 1;
           break;
      default:
           if (sequence > longest) {
             longest = sequence;
           }
           break;
    }
  }
  return Math.max(longest, sequence);
}