0

Yahtzee で smallStraight を計算するメソッドを実行する必要があります (小さなストレートとは、1 ずつ増加する 4 つのダイがあることを意味します。たとえば、1,2,3,4,6小さなストレートです)。今、私は、配列を並べ替えると、重複する数値が存在する可能性があるというハードルを乗り越えようとしています。
たとえば、ロールしてから並べ替えると、1, 2, 2, 3, 4. ここで、基本的に、配列の最後にある 2 番目の 2 を削除する必要があります。これが私のコードです。これは、ネストされた 4 つのループに関しては明らかに機能しないことに注意してください。これについて最善の方法を知りたいだけです。

public int setSmallStraight(int[] die)
{
    if (!isSmallStraightUsed)
    {
      int counter = 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)
      {
         smallStraight = 30; 
      }
      else
      {
          smallStraight = 0;
      }
      return smallStraight;
    }
   else
        return 0;
   }
4

4 に答える 4

1

配列int counterの連続した増加数をカウントする はどうですか? +1そんな感じ：

public boolean hasSmallStraight(int[] sortedValues) {
    int counter = 0;
    for (int i=0; i<sortedValues.length-1; i++) {
        if (counter == 3) return true;

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

    return counter==3;
}

注：これは小さなストレートでのみ機能します

于 2013-03-26T01:42:08.473 に答える
1

これはあなたのために働くでしょう：

public static void main(String[] args) {
Integer[] items = {0, 4, 2, 2, 10, 5, 5, 5, 2};
System.out.println(customSort(Arrays.asList(items)));
}

public static Collection<Integer> customSort(List<Integer> die) {
Collections.sort(die);
Stack<Integer> numbas = new Stack<Integer>();
List<Integer> dupes = new ArrayList<Integer>();
numbas.push(die.get(0));
for (int i = 1; i < die.size(); i++) {
    if (!die.get(i).equals(numbas.peek())) {
    numbas.push(die.get(i));
    } else {
    dupes.add(die.get(i));
    }
}
numbas.addAll(dupes);
return numbas;
}

これにより、出力が得られます

[0, 2, 4, 5, 10, 2, 2, 5, 5]

必要に応じて、エラー チェックと処理を追加します。

于 2013-03-26T01:49:01.217 に答える
0

配列がソートされていると仮定すると、以下のようなアルゴリズムを使用できます。私が付けたコメントを読んでください。うまくいけば、それがどのように機能するかを明確に説明しています。また、予防策として、これは決して最も効率的な実装ではないため、配列が巨大な場合はパフォーマンスを考慮してください。

// Sequentially iterate array using 2 indices: i & j
// Initially i points to 1st element, j point to 2nd element
// The assumption is there's at least 2 element in the array.
// 'end' acts as a boundary limit to which element hasn't been checked
for(int i=0,j=1,end=array.length; j<end; ) {

    // If element pointed by i & j are equal, shift element pointed
    // by j to the end. Decrement the end index so we don't test element
    // that's already shifted to the back.
    // Also in this case we don't increment i & j because after shifting we
    // want to perform the check at the same location again (j would have pointed
    // to the next element)
    if(array[i] == array[j]) {

        // This for loop shifts element at j to the back of array
        for(int k=j; k<array.length-1; k++) {
            int tmp = array[k+1];
            array[k+1] = array[k];
            array[k] = tmp;
        }

        end--;

    // if element at i and j are not equal, check the next ones
    } else {
        i++;
        j++;
    }
}
于 2013-03-26T01:41:19.877 に答える
0

試す

    int[] a1 = { 1, 2, 2, 3, 4 };
    int[] a2 = new int[a1.length];
    int j = 0, k = 0;
    for (int i = 0; i < a1.length - 1; i++) {
        if (a1[i + 1] == a1[j]) {
            a2[k++] = a1[i + 1];
        } else {
            a1[++j] = a1[i + 1];
        }
    }
    System.arraycopy(a2, 0, a1, j + 1, k);
    System.out.println(Arrays.toString(a1));

出力

[1, 2, 3, 4, 2]
于 2013-03-26T04:01:43.570 に答える