yahtzee.js

/**
 * Først noen biblioteksfunksjoner som er innebygget i de fleste funksjonelle språk
 */

/**
 * Øk et tall med 1. Behandler null/undefined som 0, så inc(null) => 1
 */
function inc(v) {
  return (v === null || v === undefined ? 0 : v) + 1;
}

/**
 * Oppdater propertyen `prop` i `object` ved å kalle funksjonen `fn` på den eksisterende verdien.
 * Simuler immutable objekter - sett en property ved å kopiere alle properties
 * over i et nytt objekt, og skriv over en angitt property.
 */
function update(object, prop, fn) {
  return Object.assign({}, object, {[prop]: fn(object[prop])});
}

/**
 * Beregn frekvensene av verdiene i listen `xs`.
 *
 *     frequencies([1, 1, 2, 3, 1]); //=> {1: 3, 2: 1, 3: 1}
 *
 * Returnerer et objekt med hver unike verdi som property, og antall forekomster som verdi.
 */
function frequencies(xs, freqs) {
  if (!freqs) {
    return frequencies(xs, {});
  }

  if (xs.length > 0) {
    return frequencies(xs.slice(1), update(freqs, xs[0], inc));
  }

  return freqs;
}

/**
 * Returner alle verdiene i et objekt
 */
function values(object) {
  return Object.keys(object).reduce((vals, prop) => vals.concat(object[prop]), []);
}

/**
 * Returner det største tallet i en array
 */
function max(array) {
  return array.reduce((max, item) => Math.max(max, item), -Infinity);
}

/**
 * Returnerer `true` dersom to arrays er like lange og inneholder de samme elementene i samme rekkefølge.
 */
function eq(a, b) {
  if (a.length !== b.length) {
    return false;
  }

  return a.filter((val, idx) => val !== b[idx]).length === 0;
}

//
// Yatzy time!
// Denne implementasjonen jobber mot en særdeles enkel datastruktur:
// en array med fem tall som representerer terningene.
//

function hasPair(dice) {
  return max(values(frequencies(dice))) >= 2;
}

function hasThreeAlike(dice) {
  return max(values(frequencies(dice))) >= 3;
}

function hasFourAlike(dice) {
  return max(values(frequencies(dice))) >= 4;
}

function hasHouse(dice) {
  return eq(values(frequencies(dice)).sort(), [2, 3]);
}

function hasSmallStraight(dice) {
  return eq(dice.sort(), [1, 2, 3, 4, 5]);
}

function hasBigStraight(dice) {
  return eq(dice.sort(), [2, 3, 4, 5, 6]);
}

function hasYahtzee(dice) {
  return max(values(frequencies(dice))) === 5;
}