Неверный результат

Question

Итак, нам было поручено следующее:

Вы будете моделировать определенный тип пасьянса. Игра начинается с 45 карт. (Им нужно, чтобы не играли в карты. Немаркированные индексные карты работают так же хорошо.) Случайно разделите их на некоторое количество грудов случайного размера. Например, вы можете начать с груды размера 20, 5, 1, 9 и 10. В каждом раунде вы берете одну карточку из каждой сваи, образуя с этими картами новую кучу . Например, исходная конфигурация образца будет , преобразованная в груды размером 19, 4, 8, 9 и 5. Пасьянс закончился, когда сваи имеют размер 1, 2, 3, 4, 5, 6, 7, 8 , и 9, в некотором порядке. (Можно показать, что вы всегда в конечном итоге с такой конфигурацией.)

Нам дан класс SolitaireTester, который я обеспечиваю ниже:

public class SolitaireTester 
{ 
public static void main(String[] args) 
{ 
    Solitaire s = new Solitaire(); 

    System.out.println("Start: " + s.toString()); 

    int rounds = 0; 
    while (!s.over()) { 
     s.round(); 
     ++rounds; 
     System.out.println(rounds + ": " + s.toString()); 
    } 
    System.out.println("Rounds: " + rounds); 
} 
} 

Мы должны написать класс пасьянсов. Вот что у меня есть до сих пор:

import java.util.*; 
import java.math.*; 

public class Solitaire 
{ 
int size = 45; 

private ArrayList piles; 

//Constructor for the initialization of random values 
public Solitaire() 
{ 
    piles = new ArrayList<Integer>(); 

    for(int i = 0; i < size; i++) 
    { 
     int temp = (int)(Math.random()*10)+1; 
     piles.add(temp); 
    } 
} 

//toString() will return a string representation of a Solitaire object 
public String toString() 
{ 
    return piles.toString(); 
} 

/* 
* over() will return true if the solitaire is over, false otherwise. The solitaire is over when 
* the piles have size 1, 2, 3, 4, 5, 6, 7, 8, and 9, in some order 
*/ 
public boolean over() 
{ 
    int sum = 0; 

    int a[] = {1,2,3,4,5,6,7,8,9}; 

    Iterator itr = piles.iterator(); 

    while(itr.hasNext()) 
    { 
     int check = (int) itr.next(); 

     for(int i = 0; i < 9; i++) 
     { 
      if(a[i] == check) 
      { 
       a[i] = 0; 
      } 
     } 
    } 

    if(sum == 0) 
    { 
     return true; 
    } 
    else 
    { 
     return false; 
    } 
} 

//round() takes one card from each pile, forming a new pile with these cards 
public boolean round() 
{ 
    Iterator itr = piles.iterator(); 

    int count = 0; 

    while(itr.hasNext()) 
    { 
     int check = (int) itr.next(); 
     count += 1; 
    } 

    if(count == 9) 
    { 
     return true; 
    } 
    else 
    { 
     return false; 
    } 
} 
} 

Я, очевидно, что-то делаю неправильно. Выход, который я получаю:

Start: [5, 1, 2, 1, 7, 10, 5, 8, 6, 3, 8, 6, 6, 6, 10, 4, 4, 9, 7, 4, 10, 2, 8, 4, 8, 9, 10, 3, 3, 5, 9, 2, 5, 5, 3, 6, 6, 5, 3, 5, 4, 3, 1, 9, 6] 
Rounds: 0 

Фактический выход должен иметь гораздо больше раундов и фактически давать правильный выход.

Если кто-то может указать мне в правильном направлении относительно того, где я делаю свою ошибку (и). Кроме того, если есть что-то постороннее, что я включаю и не должен, тогда это также будет полезно. Пожалуйста, я не ищу ответа, просто толчок в правильном направлении. Спасибо!

Answer 1

import java.util.ArrayList; 
import java.util.Collections; 

public class Solitaire 
{ 

int maxSize = 45; 
int newPile; 

private ArrayList<Integer> piles; 

/* 
* Constructor for the initialization of random values. 
* Initialize piles to a random number of piles of random size, but exactly 45 cards total. 
*/ 
public Solitaire() 
{ 

    int totalNumberOfStartingPiles = (int) (Math.random() * 10) + 1; 

    boolean continueLoop = true; 
    int total = 0; 
    int size = 45; 

    while (continueLoop) 
    { 
     piles = new ArrayList<Integer>(); 

     for (int i = 0; i < totalNumberOfStartingPiles; i++) 
     { 
      int temp = getRandomPile(size - totalNumberOfStartingPiles + i); 

      if (i == totalNumberOfStartingPiles - 1) 
      { 
       piles.add(size); 
      } else { 
       piles.add(temp); 
       size = size - temp; 
      } 
     } 

     for (int i = 0; i < piles.size(); i++) 
     { 
      total += piles.get(i); 
     } 

     if (total == maxSize) 
     { 
      continueLoop = false; 
     } 
    } 
} 

/* 
* Randomizes and returns the total number of starting piles. 
* 
* @return Integer that is the total number of starting piles. 
*/ 
public int getRandomPile(int size) 
{ 
    int totalNumberOfStartingPiles = (int) (Math.random() * size) + 1; 
    return totalNumberOfStartingPiles; 
} 

/* 
* toString() will return a string representation of a Solitaire object. 
* 
* @return String representation of a Solitaire object. 
*/ 
public String toString() 
{ 
    return piles.toString(); 
} 

/* 
* over() will return true if the solitaire is over, false otherwise. The 
* solitaire is over when the piles have size 1, 2, 3, 4, 5, 6, 7, 8, and 
* 9, in some order. 
* 
* @return true if the solitaire is over, false otherwise. 
*/ 
public boolean over() 
{ 
    int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
    boolean flag = true; 

    for (int i = 0; i < piles.size(); i++) 
    { 
     if (a[i] != piles.get(i)) 
     { 
      flag = false; 
      break; 
     } 
    } 

    return flag; 
} 

/* 
* In each round, you take one card from each pile, forming a new pile with these cards. 
* Removes a pile that reaches a size of 0 cards. 
*/ 
public void round() 
{ 
    newPile = piles.size(); 

    for (int i = 0; i < piles.size(); i++) 
    { 
     piles.set(i, (piles.get(i)) - 1); 

     if(piles.get(i)==0) 
     { 
      piles.remove(i); 
      i--; 
     } 
    } 

    piles.add(newPile); 
    Collections.sort(piles); //sorts the pile into ascending numerical order 
} 

}