Eksamen 2018

public static Collection<Integer> randomDieValues(int dieCount) {
   Collection<Integer> dieValues = new ArrayList<>(dieCount);
   while (dieValues.size() < dieCount) {
      dieValues.add((int) (Math.random() * 6 + 1));
   }
   return dieValues;
}
 
private final List<Integer> dieValues = new ArrayList<>(); // Kunne også brukt int[]-typen og lage den i konstruktøren
private int score = -1;

public Dice(Collection<Integer> dieValues, int score) {
   // Kunne brukt this.dieValues.addAll(dieValues), en da får en ikke validert enkeltverdiene
   for (int dieValue : dieValues) {
      if (! (dieValue >= 1 && dieValue <= 6)) {
         throw new IllegalArgumentException("A die value must be in the range 1-6");
      }
      this.dieValues.add(dieValue);
   }
   this.score = score;
}

public Dice(int dieCount) {
   this(Dice.randomDieValues(dieCount), -1);
}

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

@Override
public String toString() {
   String result = "[";
   for (int dieValue : dieValues) {
      if (result.length() > 1) {
         result = result + ", ";
      }
      result = result + dieValue;
   }
   result = result + "]";
   if (getScore() >= 0) {
      result = result + " = " + getScore();
   }
   return result;
}
 
public static Dice valueOf(String s) {
   int score = -1;
   int scorePos = s.indexOf("=");
   if (scorePos >= 0) {
      score = Integer.valueOf(s.substring(scorePos + 1).trim());
      s = s.substring(0, scorePos).trim();
   }
   if (s.startsWith("[") && s.endsWith("]")) {
      s = s.substring(1, s.length() - 1);
   } else {
      throw new IllegalArgumentException("Illegal format");
   }
   String[] dieValueStrings = s.split(",");
   Collection<Integer> dieValues = new ArrayList<>();
   for (int i = 0; i < dieValueStrings.length; i++) {
      dieValues.add(Integer.valueOf(dieValueStrings[i].trim()));
   }
   return new Dice(dieValues, score);
}

public int getDieCount() {
   return this.dieValues.size();
}


public int getDieValue(int dieNum) {
   return this.dieValues.get(dieNum);
}

public int getValueCount(int value) {
   int count = 0;
   for (int dieValue : this.dieValues) {
      if (dieValue == value) {
         count++;
      }
   }
   return count;
   // Alternativ med streams: return (int) this.dieValues.stream().filter(dieValue -> value == dieValue).count();
 }

public int getScore() {
   return score;
}

public void setScore(final int score) {
   if (this.score >= 0) {
      throw new IllegalStateException("Cannot set score more than once");
   }
   this.score = score;
}

@Override
public Iterator<Integer> iterator() {
   return this.dieValues.iterator();
}
 

Dice dice = ...
for (int dieValue : dice) {
   ... her er dieValue neste verdi i dice sin dieValues-liste
}

public Dice add(Dice dice) {
   Collection<Integer> dieValues = new ArrayList<>(this.dieValues);
   for (int dieValue : dice.dieValues) {
      dieValues.add(dieValue);
   }
   return new Dice(dieValues, -1);
}
 
public Dice remove(final Dice dice) {
   List<Integer> dieValues = new ArrayList<>(this.dieValues);
   for (int dieValue : dice.dieValues) {
      int pos = dieValues.indexOf(dieValue);
      if (pos >= 0) {
         dieValues.remove(pos);
      }
   }
   return new Dice(dieValues, -1);
}

/**
* 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 return value includes those dice that gives the score, and
   * of course the score itself.
   * @param dice
   * @return The dice for which the rule computes a score, and the score itself, or
   * null, if this rule isn't applicable
   */
   Dice getScore(Dice dice);
}

public class ThreeOrMoreOfAKind implements DiceScorer {


   // hjelpemetode som beregner poengsum for count antall av value
   private int getScore(final int value, int count) {
      int score = value * 100;
      while (count > 3) {
         score = score * 2;
         count--;
      }
      return score;
      // Samme som: return value * 100 * (int) Math.pow(count - 3, 2);
   }

   // går gjennom hver mulige verdi 1-6 og finner den med nok like som gir flest poeng
   protected int getBestValue(final Dice dice) {
      int value = 0, max = 0;
      for (int i = 1; i <= 6; i++) {
         int count = dice.getValueCount(i);
         int score = getScore(i, count);
         if (count >= 3 && score > max) {
            value = i;
            max = score;
         }
      }
      return value;
   }

   @Override
   // finner den beste og lager et nytt Dice-objekt med riktig antall terningverdier og poengsum
   public Dice getScore(final Dice dice) {
      int best = getBestValue(dice);
      if (best == 0) {
         return null;
      }
      int count = dice.getValueCount(best);
      Collection<Integer> dieValues = new ArrayList<Integer>(count);
      for (int i = 0; i < count; i++) {
         dieValues.add(best);
      }
      return new Dice(dieValues, getScore(best, count));
   }
}

private Collection<DiceScorer> diceScorers;

public Collection<Dice> computeDiceScores(Dice dice) {
   Collection<Dice> result = new ArrayList<>();
   // Vi følger algoritmen gitt over:
   // Så lenge det er terninger igjen, så
   //   finner vi regelen som gir flest poeng og sparer på de terningene den "brukte" og
   //   fjerner dem fra gjenværende terninger
   while (dice.getDieCount() > 0) {
      Dice best = null;
      for (DiceScorer diceScorer : diceScorers) {
         Dice score = diceScorer.getScore(dice);
         if (score != null && (best == null || score.getScore() > best.getScore())) {
            best = score;
         }
      }
      if (best == null) {
         break;
      } else {
         result.add(best);
         dice = dice.remove(best);
      }
   }
   return result;
}

// Med reduce
diceCol.stream().map(Dice::getScore).reduce(0, (n1, n2) -> n1 + n2)
 
// Med sum (må bruke mapToInt i stedet for map for å få en IntStream, men det er vi ikke så nøye på ved sensur)
diceCol.stream().mapToInt(Dice::getScore).sum()

public abstract class AbstractDice implements Dice {

   private int score = -1;
 
   protected AbstractDiceImpl(int score) {
     this.score = score;
   }
 
   @Override
   public String toString() {
      ... kan implementeres fordi getDieCount og getDieValue er deklarert (selv om de er abstrakte) ...
   }
 
   // implementasjon som bare er avhengig av at Dice utvider Iterable
   public int getValueCount(int value) {
      int count = 0;
      // Iterable er implementert!
      for (int dieValue : this) {
         if (dieValue == value) {
            count++;
         }
      }
      return count;
   }
 
   @Override
   public int getScore() {
      return score;
   }
 
   @Override
   public void setScore(int score) {
      if (this.score >= 0) {
         throw new IllegalStateException("Cannot set score more than once");
      }
      this.score = score;
    }
}

public class DiceAdder implements Dice {
 
   private final Dice dice1, dice2;
 
   public DiceAdder(Dice dice1, final Dice dice2) {
      super(score);
      this.dice1 = dice1;
      this.dice2 = dice2;
   }
 
   @Override
   public int getDieCount() {
      // Rett frem bruk av delegering, som vist i oppgaveteksten
      return dice1.getDieCount() + dice2.getDieCount();
   }
 
   @Override
   public int getDieValue(final int dieNum) {
      int dieCount1 = dice1.getDieCount();
      // Vi henter de første verdiene fra dice1,
      // så sjekker om indeksen er lav nok
      if (dieNum < dieCount1) {
         return dice1.getDieValue(dieNum);
      }
      // De neste verdiene hentes fra dice2, med (ned)justert indeks 
      return dice2.getDieValue(dieNum - dieCount1);
   }
 
   @Override
   public int getValueCount(final int value) {
      // Rett frem bruk av delegering, som vist i oppgaveteksten
      return dice1.getValueCount(value) + dice2.getValueCount(value);
   }
 
   @Override
   public Dice add(final Dice dice) {
      // Vi lager en instans av denne klassen,
      // den representerer jo nettopp to Dice slått sammen
      return new DiceAdder(this, dice);
   }
 
   @Override
   public boolean contains(final Dice dice) {
      // Dette er ikke så rett frem, men
      // algoritmen bruker delegering til getValueCount
      for (int dieValue = 1; dieValue <= 6; dieValue++) {
         if (dice.getValueCount(dieValue) > getValueCount(dieValue)) {
            return false;
         }
      }
      return true;
   }
 
   @Override
   public Dice remove(final Dice dice) {
      // Denne er ikke rett frem i det hele tatt, så den utelater vi...
   }
}