Kont 2018

/**
 * Represents a set of die values.
 */
public class Dice implements Iterable<Integer> {
    /**
     * Counters for each possible die value.
     * The counter at index i (0-5) is the counter for the die value i+1 (1-6).
     * I.e. the value at index 2 is the counter for die value 3.
     */
    private final int[] valueCounters;
 
    /**
     * Initializes this Dice with the values in dieValues.
     * @param dieValues sequence of die values, not counter values
     */
    public Dice(Iterator<Integer> dieValues) {
        ???
    }

    /**
     * Initializes this Dice with the values in dieValues.
     * @param dieValues sequence of die values, not counter values
     */
    public Dice(Iterable<Integer> dieValues) {
        ???
    }
 
    @Override
    public Iterator<Integer> iterator() {
        return new DiceIterator(this);
    }
 
    /**
     * @return the number of die values
     */
    public int getDieCount() {
        ???
    }
 
    /**
     * Die values are considered ordered, with the smallest die values
     * at the lowest index. The value at a specific index
     * must be computed from the counters in valueCounters.
     * @param dieNum
     * @return the value of die number dieNum
     * @throws an appropriate exception, if dieNum is out of range
     */
    public int getDieValue(int dieNum) {
        ???
    }
 
    /**
     * @param value
     * @return the number of dice with the provided value
     */
    public int getValueCount(int value) {
        ???
    }

    /**
     * @param dice
     * @return true if all die values in the Dice argument appear in this Dice
     */
    public boolean contains(Dice dice) {
        ???
    }
 
    /**
     * @param dice
     * @return true if this Dice and the one provided have exactly the same die values
     */
    public boolean isSame(Dice dice) {
        ???
    }
 
    /**
     * @param dice a Dice object
     * @return a new Dice instance with the all the die values in
     * this Dice and the Dice argument combined
     */
    public Dice add(Dice dice) {
        ???
    }
 
    /**
     * @param dice
     * @return a new Dice instance with the die values from this Dice, but
     * without those from the Dice argument
     */
    public Dice remove(Dice dice) {
        ???
    }
}

public Dice(Iterator<Integer> dieValues) {
	this.valueCounters = new int[6];
	while (dieValues.hasNext()) {
		int dieValue = dieValues.next();
		if (! (dieValue >= 1 && dieValue <= 6)) {
			throw new IllegalArgumentException("A die value must be in the range 1-6");
		}
		// add one to the corresponding counter
		this.valueCounters[dieValue - 1]++;
	}
}

public Dice(Iterable<Integer> dieValues) {
	this(dieValues.iterator());
}

public int getDieCount() {
	int count = 0;
	for (int counter : valueCounters) {
		count += counter;
	}
	return count;
}

public int getDieValue(int dieNum) {
	if (dieNum < 0 || dieNum >= getDieCount()) {
		throw new IllegalArgumentException(dieNum + " is out of range");
	}
	for (int dieValue = 1; dieValue <= 6; dieValue++) {
		int counter = valueCounters[dieValue - 1];
		if (dieNum < counter) {
			return dieValue;
		}
		dieNum -= counter;
	}
	// should never come here
	throw new IllegalArgumentException();
}

public int getValueCount(final int value) {
	return valueCounters[value - 1];
}

// Et Dice-objekt inneholder et annet hvis det er minst like mange av hver terning-verdi
public boolean contains(final Dice dice) {
	for (int dieValue = 1; dieValue <= 6; dieValue++) {
		if (this.valueCounters[dieValue - 1] < dice.getValueCount(dieValue)) {
			return false;
		}
	}
	return true;
}

// To Dice-objekter er like hvis det ene inneholder det andre og omvendt!
// Evt. kan kan sjekke at alle valueCounters-verdiene er like
public boolean isSame(final Dice dice) {
	return contains(dice) && dice.contains(this);
}

// To Dice-objekter kan slås sammen ved å legge sammen tellerne
public Dice add(final Dice dice) {
	// Lager et tomt Dice-objekt og justerer tellerne i løkka
	Dice result = new Dice(Arrays.asList());
	for (int dieValue = 1; dieValue <= 6; dieValue++) {
		result.valueCounters[dieValue - 1] = this.valueCounters[dieValue - 1] + dice.valueCounters[dieValue - 1];
	}
	return result;
}

// En kan trekke et Dice-objekt fra et annet ved å trekke den enes tellere fra den andres.
// En må huske å unngå negative tellere.
public Dice remove(final Dice dice) {
	// Lager et tomt Dice-objekt og justerer tellerne i løkka
	Dice result = new Dice(Arrays.asList());
	for (int dieValue = 1; dieValue <= 6; dieValue++) {
		result.valueCounters[dieValue - 1] = Math.max(0, this.valueCounters[dieValue - 1] - dice.getValueCount(dieValue));
	}
	return result;
}

public class DiceIterator implements Iterator<Integer> {
	private final Dice dice;
	private int dieNum = 0;

	public DiceIterator(final Dice dice) {
		this.dice = dice;
	}

	@Override
	public boolean hasNext() {
		return dieNum < dice.getDieCount();
	}

	@Override
	public Integer next() {
		final int value = dice.getDieValue(dieNum);
		dieNum++;
		return value;
	}
}

/**
* Represents the score given to a set of die values
*/
public class DiceScore {
 
    ??? fields
 
    /**
    * Initialises a DiceScore object with the provided data
    * @param scoringDice the Dice object containing
    * only the die values contibuting to the score
    * @param score the score itself
    */
    public DiceScore(Dice scoringDice, int score) {
        ???
    }
 
    ??? methods
}

/**
* Interface for scoring rules, i.e.
* logic for computing a score for a subset of dice in a Dice
*/
public interface DiceScorer {
 
    /**
    * Computes a score for (a subset of) the dice in the Dice argument.
    * The returned DiceScore object stores a Dice object
    * with those die values that contributed to the score and
    * of course the score itself.
    * @param dice
    * @return The result of applying the rule to the provided Dice, or
    * null of the rule doesn't apply.
    */
    DiceScore getScore(Dice dice);
}

public class DiceScore {

	private final Dice dice;
	private final int score;

	public DiceScore(Dice dice, int score) {
		this.dice = dice;
		this.score = score;
	}

	public Dice getDice() {
		return dice;
	}

	public int getScore() {
		return score;
	}
}

public class SingleValue implements DiceScorer {


	private final int score;
	private final int value;

	public SingleValue(final int value, final int score) {
		this.score = score;
		this.value = value;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		if (dice.getValueCount(value) > 0) {
			return new DiceScore(new Dice(Arrays.asList(value)), score);
		}
		return null;
	}
}

 public class Straight implements DiceScorer {

	private final int score;
	public Straight(int score) {
		this.score = score;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		int dieCount = dice.getDieCount();
		int start = 1;
		// find start of series
		while (start <= 6) {
			int count = dice.getValueCount(start);
			if (count > 1) {
				return null;
			} else if (count == 1) {
				break;
			}
			start = start + 1;
		}

		// find end of series
		int end = start + 1;
		while (end <= 6) {
			int count = dice.getValueCount(end);
			if (count > 1) {
				return null;
			} else if (count == 0) {
				break;
			}
			end = end + 1;
		}
        // check if the number of ones is wrong
		if (end - start != dieCount) {
			return null;
		}
		return new DiceScore(dice, score);
	}
}

public class Nothing implements DiceScorer {

	private final int score;
	private final int numDice;
	private final DiceScorer[] scorers;

	public NothingScorer(final int numDice, final int score, final DiceScorer... diceScorers) {
		this.score = score;
		this.numDice = numDice;
		this.scorers = diceScorers;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		if (dice.getDieCount() >= numDice) {
			for (DiceScorer diceScorer : scorers) {
				if (diceScorer.getScore(dice) != null) {
					return null;
				}
			}
		}
		return new DiceScore(dice, this.score);
	}
}

public abstract class AbstractScorer implements DiceScorer {

	private final int score;

	protected AbstractScorer(int score) {
		this.score = score;
	}

	protected int getScore() {
		return score;
	}
}
 
public class SingleValue extends AbstractScorer {

	private final int value;

	public SingleValue(int value, int score) {
		super(score);
		this.value = value;
	}
}

Dice dice = new Dice(...);
for (int dieValue : dice) {
	System.out.println(dieValue + " ");
}

Dice dice = new Dice(...);
dice.forEach(dieValue -> { System.out.println(dieValue + " "); });

@Test
public void testContains() {
	assertFalse(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1, 2, 3))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1, 2))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList())));
 
	assertFalse(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList(1, 2))));
	assertTrue(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList(1))));
	assertTrue(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList())));
	assertTrue(new Dice(Arrays.asList()).contains(new Dice(Arrays.asList())));

	assertFalse(new Dice(Arrays.asList()).contains(new Dice(Arrays.asList(1))));
}

public class DiceScorerController {

	private DiceScorer singleValue, straight, nothing;

	@FXML
	public void initialize() {
		singleValue = new SingleValue(1, 100);
		straight = new Straight(500);
		nothing = new Nothing(5, 1000, singleValue, straight);
	}

	@FXML
	private TextField dieValuesInput;

	@FXML
	private Label scoreOutput;

	@FXML
	private Label diceOutput;

	private Dice getDiceInput() {
		Collection<Integer> dieValues = new ArrayList<>();
		for (String dieValue : dieValuesInput.getText().split(" ")) {
			dieValues.add(Integer.valueOf(dieValue));
		}
		return new Dice(dieValues);
	}

	private void runDiceScorer(final DiceScorer scorer) {
		DiceScore score = scorer.getScore(getDiceInput());
		if (score != null) {
			scoreOutput.setText(String.valueOf(score.getScore()));
			String dieValues = "";
			for (final int dieValue : score.getDice()) {
				dieValues += dieValue + " ";
			}
			diceOutput.setText(dieValues);
		} else {
			scoreOutput.setText("");
			diceOutput.setText("");
		}
	}

	@FXML
	public void testSingleValue() {
		runDiceScorer(singleValue);
	}

	@FXML
	public void testStraight() {
		runDiceScorer(straight);
	}

	@FXML
	public void testNothing() {
		runDiceScorer(nothing);
	}
}