〔プログラムの説明〕

トランプを用いた一人遊びのゲームを実行するプログラムである。 ゲームのルールは，次のとおりである。

(1)　トランプは，スペード，ハート，ダイヤ及びクラブの 4 種類のスートがあり， 各スートは A（エース），2 〜 10，J（ジャック），Q（クイーン）及び K（キング）の 1 〜 13 の位（ランク）を表す 13 枚のカードからなる。 このゲームでは合計 52 枚 のカードを使用し，スートは区別しない。

(2)　52 枚のカードを，1 枚ずつ表を向けて横に並べていく。 4 枚並べたら，その下の列に移り，再び左端から横に並べる。 カードを並べていくところを場と呼び，横の並びを列と呼ぶ。

(3)　図に示すとおり，(2) で 1 枚並べるごとに，縦，横， 斜めに隣り合ったカードが同じ位であるかどうかを調べ， 同じ位のカードの組み（ペア）ができた場合は， そのペア（図中の ）を取り除き，空いたスペースを詰める。 列の最後のカードと次の列の最初のカードは隣り合ったカードとはみなさない。 ペアが複数できた場合 （ と の各 2 枚）は， 最も長く場にあるカードを含むペア（ ）を取り除く。 最も長く場にあるカードを含むペアが複数ある場合は， 最も長く場にあるカードとペアを作るカードのうちで， 最も長く場にあるカードとのペア（ ）を取り除く。

(4)　(3) の操作を隣り合うカードの位が全部異なるようになるまで繰り返す。

(5)　(2) 〜 (4) の操作を手持ちのカードがなくなるまで繰り返す。

(6)　手持ちのカードがなくなったときに，すべてのカードが場から取り除かれると上がりである。

クラス Card は，トランプのカードを表す。 クラスの初期化のとき，A（エース）〜 K（キング）の位に相当する Card のインスタンスを 4 種類のスート分生成して。

Card の配列 cards に格納する。 Card のインスタンスは不変であり，1 枚のカードに必ず同一のインスタンスが対応する。 例えば，ハートのエースを表す Card のインスタンスは一つしか存在しない。 クラスメソッド newDeck は，cards をランダムな順番に並べ替えた Card の配列を トランプの一山として返す。

クラス Game は，ゲームを実行するプログラムである。List のインスタンス list がトランプを並べていく場を表し，トランプの山を表す deck から 1 枚ずつ list に追加し，その都度メソッド checkAndRemove を呼び出して同じ位の 隣り合うカードのペアを取り除く。

クラス java.util.Random は，乱数を生成するためのクラスである。メソッド nextInt(int n) は，範囲 0 〜 n−1 の乱数を int 型で返す。

インタフェース java.util.List は，リスト構造を表し，各要素はインデックス で指定される。リストの最初の要素は，インデックスの値 0 で指定される。メソッド add(Object obj) は，リストの最後にオブジェクト obj を追加する。メソッド get(int index) は，index で指定された要素のオブジェクトを返す。メソッド remove(int index) は，index で指定された要素のオブジェクトを削除し， index + 1 以降にオブジェクトがあれば，それらをシフトして空きを詰める。 メソッド size() は，リストにあるオブジェクトの個数を int 型で返す。

クラス java.util.ArrayList は，配列を用いてインタフェース List を実装する。

〔プログラム１〕

import java.util.Random;
public class Card {
   public static final int SPADES = 0;
   public static final int HEARTS = 1;
   public static final int DIAMONDS = 2;
   public static final int CLUBS = 3;
   private static final Random rand = new Random();
   private static final Card[] cards = new Card[13 * 4];
   private final int suit;
   private final int rank;
   
      for (int i = SPADES; i <= CLUBS; i++) {
         for (int j = 1; j <= 13; j++) {
            cards[] = new Card(i, j);
         }
      }
   }
   private Card(int suit, int rank) {
      this.suit = suit;
      this.rank = rank;
   }
   public int getSuit() { return suit; }
   public int getRank() { return rank; }
   public static Card[] newDeck() {
      Card[] deck = new Card[cards.length];
      System.arraycopy(cards, 0, deck, 0, cards.length);
      for (int i = cards.length - 1; i > 0; i--) {
         int index = rand.nextInt(i + 1);
         Card tmp = deck[i];
         deck[i] = deck[index];
         deck[index] = tmp;
      }
      return deck;
   }
}

〔プログラム２〕
import java.util.ArrayList;
import java.util.List;
public class Game {
   // 現在注目しているカードからの相対インデックス
   private static final int[][] indexDiff = {
      { 1, 4, 5 },
      { 1, 3, 4, 5 },
      { 1, 3, 4, 5 },
      { 3, 4 }
   };
   private static void checkAndRemove(List list) {
      // list の最初からその隣り合うカードを調べる。
      // currentIndex は現在注目しているカードのインデックス値
      for (int currentIndex = 0; currentIndex < list.size();
           currentIndex++) {
         // currentRank は現在注目しているカードの位
         int currentRank =
                   ((Card) list.get(currentIndex)).getRank();
         // 現在注目しているカードと隣り合うカードへの
         // インデックスを求める。
         int[] diffList = indexDiff[currentIndex % 4];
         for (int i = 0; i < diffList.length; i++) {
            // adjacentIndex は隣り合うカードへのインデックス値
            int adjacentIndex = ;
            if (
                && ((Card) list.get(adjacentIndex)).getRank()
                    == currentRank) {
               list.remove(adjacentIndex);
               list.remove();
               checkAndRemove(list);
               return;
            }
         }
      }
   }
   public static void main(String[] args) {
      Card[] deck = Card.newDeck();
      List list = new ArrayList();
      for (int i = 0; i < deck.length; i++) {
         list.add(deck[i]);
         checkAndRemove(list);
      }
      if (list.size() == 0) {
         System.out.println("上がり！");
      } else {
         System.out.println("残り" + list.size() + "枚");
      }
   }
}

ア　private Card() {　　　　　　　　イ　private static void init() {

ウ　private void init() {　　　　　　エ　static {

オ　synchronized {　　　　　　　　　カ　{

ア　i * 13 + j　　　　　　　　イ　i * 13 + j - 1

ウ　i * 4 + j - 1　　　　　　　エ　j * 13 + i

オ　j * 13 + i - 1　　　　　　カ　j * 4 + i - 1

ア　currentIndex * diffList[i]　　　　　　イ　currentIndex + diffList[i]

ウ　currentIndex - diffList[i]　　　　　　エ　i * diffList[currentIndex]

オ　i + diffList[currentIndex]　　　　　　カ　i - diffList[currentIndex]

ア　adjacentIndex != list.size()

イ　adjacentIndex < list.size()

ウ　adjacentIndex <= list.size()

エ　adjacentIndex == list.size()

オ　adjacentIndex > list.size()

カ　adjacentIndex >= list.size()

ア　0　　　　　　　　　　　　　　　イ　adjacentIndex

ウ　adjacentIndex - 1　　　　　　エ　currentIndex

オ　currentIndex - 1　　　　　　　カ　list.size() - 1