API tools faq
paste
Advertisement
Double_X

Bowling Scores

Double_X
Mar 23rd, 2019
298
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
HTML 5 24.26 KB | None | 0 0
raw download clone embed print report
  1. <!DOCTYPE html>
  2. <html>
  3.     <head>
  4.         <meta charset="utf-8">
  5.         <title>Bowling Scores</title>
  6.         <script>
  7.             // Edit these configurations
  8.             const DAY_COUNT = 240, ROUNDS_PER_DAY = 20;
  9.             const FRAME_COUNT = 10, PIN_COUNT = 10;
  10.             const ABOVE_OLD_SCORE = 0, BELOW_OLD_SCORE = 301;
  11.             const MAX_SPLITS = 11, MAX_STRIKES = 12, MAX_STRIKE_STRING_SUM = 11;
  12.             const MAX_STRIKE_STRING_LENGTH = 11, MAX_SPLIT_SPARES = 10;
  13.             const ASC_SCORE_MILESTONES = [
  14.                 0,
  15.                 10,
  16.                 20,
  17.                 30,
  18.                 40,
  19.                 50,
  20.                 60,
  21.                 70,
  22.                 80,
  23.                 90,
  24.                 100,
  25.                 110,
  26.                 120,
  27.                 130,
  28.                 140,
  29.                 150,
  30.                 160,
  31.                 170,
  32.                 180,
  33.                 190,
  34.                 200,
  35.                 210,
  36.                 220,
  37.                 230,
  38.                 240,
  39.                 250,
  40.                 260,
  41.                 270,
  42.                 280,
  43.                 290,
  44.                 300
  45.             ], SPARE_MARK = "./", EMPTY_MARK = " .", FRAME_SEPARATOR = "|";
  46.             const STRIKE_MARK = ".X", ZERO_MARK = ".-", SPLIT_MARK = "S";
  47.             const SCORE_9_MARK = ".9", SCORE_8_MARK = ".8";
  48.             const SCORE_7_MARK = ".7", SCORE_6_MARK = ".6";
  49.             const SCORE_5_MARK = ".5", SCORE_4_MARK = ".4";
  50.             const SCORE_3_MARK = ".3", SCORE_2_MARK = ".2";
  51.             const SCORE_1_MARK = ".1", SPLIT_8_MARK = `${SPLIT_MARK}8`;
  52.             const SPLIT_7_MARK = `${SPLIT_MARK}7`;
  53.             const SPLIT_6_MARK = `${SPLIT_MARK}6`;
  54.             const SPLIT_5_MARK = `${SPLIT_MARK}5`, MARK_SCORES = {
  55.                 [STRIKE_MARK]: 10,
  56.                 [SCORE_9_MARK]: 9,
  57.                 [SCORE_8_MARK]: 8,
  58.                 [SPLIT_8_MARK]: 8,
  59.                 [SCORE_7_MARK]: 7,
  60.                 [SPLIT_7_MARK]: 7,
  61.                 [SCORE_6_MARK]: 6,
  62.                 [SPLIT_6_MARK]: 6,
  63.                 [SCORE_5_MARK]: 5,
  64.                 [SPLIT_5_MARK]: 5,
  65.                 [SCORE_4_MARK]: 4,
  66.                 [SCORE_3_MARK]: 3,
  67.                 [SCORE_2_MARK]: 2,
  68.                 [SCORE_1_MARK]: 1,
  69.                 [ZERO_MARK]: 0
  70.             };
  71.             const HEAD_SCORES = {
  72.                 [STRIKE_MARK]: 49,
  73.                 [SCORE_9_MARK]: 28,
  74.                 [SCORE_8_MARK]: 11,
  75.                 [SPLIT_8_MARK]: 4,
  76.                 [SCORE_7_MARK]: 13,
  77.                 [SPLIT_7_MARK]: 2,
  78.                 [SCORE_6_MARK]: 7
  79.             };
  80.             const TAIL_SCORES = {
  81.                 [SCORE_9_MARK]: { [SCORE_1_MARK]: 1 },
  82.                 [SCORE_8_MARK]: { [SCORE_2_MARK]: 1 },
  83.                 [SPLIT_8_MARK]: { [SCORE_2_MARK]: 1, [SCORE_1_MARK]: 1 },
  84.                 [SCORE_7_MARK]: {
  85.                     [SCORE_3_MARK]: 14,
  86.                     [SCORE_2_MARK]: 1,
  87.                     [SCORE_1_MARK]: 1
  88.                 },
  89.                 [SPLIT_7_MARK]: { [SCORE_3_MARK]: 1, [SCORE_2_MARK]: 3 },
  90.                 [SCORE_6_MARK]: {
  91.                     [SCORE_4_MARK]: 8,
  92.                     [SCORE_3_MARK]: 2,
  93.                     [SCORE_2_MARK]: 1
  94.                 }
  95.             };
  96.             //
  97.  
  98.             // Don't edit these implementations
  99.             const isStrike = headMark => {
  100.                 const headScore = MARK_SCORES[headMark];
  101.                 return headScore && headScore == PIN_COUNT;
  102.             };
  103.             const isSpare = (headMark, tailMark) => {
  104.                 if (isStrike(headMark)) return false;
  105.                 if (tailMark == SPARE_MARK) return true;
  106.                 const headScore = MARK_SCORES[headMark];
  107.                 if (!headScore) return false;
  108.                 const tailScore = MARK_SCORES[tailMark];
  109.                 return tailScore && headScore + tailScore == PIN_COUNT;
  110.             }, isLastFrame = count => count == FRAME_COUNT;
  111.             const sum = (s, no) => s + no, ballScoreMark = scores => {
  112.                 let rand = Math.floor(Math.random() * Object.values(scores).reduce(sum, 0)) + 1;
  113.                 for (const mark of Object.keys(scores)) {
  114.                     const ratio = scores[mark];
  115.                     if (rand <= ratio) return mark;
  116.                    rand -= ratio;
  117.                }
  118.                return ZERO_MARK;
  119.            };
  120.            const tailMark = headMark => {
  121.                 if (isStrike(headMark)) return EMPTY_MARK;
  122.                 const tailScore = TAIL_SCORES[headMark];
  123.                 const mark = tailScore ? ballScoreMark(tailScore) : ZERO_MARK;
  124.                 return isSpare(headMark, mark) ? SPARE_MARK : mark;
  125.             };
  126.             const oldFrameScores = round => {
  127.                 let isStrike1 = false, isStrike2 = false, isLastSpare = false;
  128.                 const scores = [];
  129.                 round.forEach(({ mark1, mark2, mark3 }, i) => {
  130.                     const score1 = MARK_SCORES[mark1];
  131.                     const score2 = MARK_SCORES[mark2];
  132.                     const score3 = MARK_SCORES[mark3];
  133.                     const isLast = isLastFrame(i + 1);
  134.                     const lastScore = () => {
  135.                         if (isStrike(mark2)) {
  136.                           return (scores[i - 1] || 0) + 20 + score3;
  137.                         } else if (isSpare(mark2, mark3)) {
  138.                           return (scores[i - 1] || 0) + 20;
  139.                         } else {
  140.                           return (scores[i - 1] || 0) + 10 + score2 + score3;
  141.                         }
  142.                     }
  143.                     if (isStrike1) {
  144.                         if (isStrike2) {
  145.                             scores[i - 2] = (scores[i - 3] || 0) + 20 + score1;
  146.                         }
  147.                         if (isStrike(mark1)) {
  148.                             if (isLast) {
  149.                                 scores[i - 1] = (scores[i - 2] || 0) + 20 + score2;
  150.                                 scores[i] = lastScore();
  151.                             } else {
  152.                                 isStrike2 = true;
  153.                             }
  154.                         } else {
  155.                             isStrike1 = isStrike2 = false;
  156.                             if (isSpare(mark1, mark2)) {
  157.                                 scores[i - 1] = (scores[i - 2] || 0) + 20;
  158.                                 isLastSpare = true;
  159.                                 if (!isLast) return;
  160.                                 scores[i] = (scores[i - 1] || 0) + 10 + score3;
  161.                             } else {
  162.                                 scores[i - 1] = (scores[i - 2] || 0) + 10 + score1 + score2;
  163.                                 scores[i] = (scores[i - 1] || 0) + score1 + score2;
  164.                             }
  165.                         }
  166.                     } else {
  167.                         if (isLastSpare) {
  168.                             isLastSpare = false;
  169.                             scores[i - 1] = (scores[i - 2] || 0) + 10 + score1;
  170.                         }
  171.                         if (isStrike(mark1)) {
  172.                             isStrike1 = true;
  173.                             if (isLast) scores[i] = lastScore();
  174.                         } else if (isSpare(mark1, mark2)) {
  175.                             isLastSpare = true;
  176.                             if (!isLast) return;
  177.                             scores[i] = (scores[i - 1] || 0) + 10 + score3;
  178.                         } else {
  179.                             scores[i] = (scores[i - 1] || 0) + score1 + score2;
  180.                         }
  181.                     }
  182.                 });
  183.                 return scores;
  184.             };
  185.             const newFrameScore = ({ mark1, mark2 }) => {
  186.                 if (isStrike(mark1)) return 30;
  187.                 const headScore = MARK_SCORES[mark1];
  188.                 return headScore + (isSpare(mark1, mark2) ? 10 : MARK_SCORES[mark2]);
  189.             };
  190.             const newFrameScores = round => {
  191.                 let total = 0;
  192.                 const scores = [];
  193.                 round.forEach(frame => {
  194.                     const score = newFrameScore(frame);
  195.                     scores.push(total + score);
  196.                     total += score;
  197.                 });
  198.                 return scores;
  199.             };
  200.             const lastFrame = headMark => {
  201.                 if (isStrike(headMark)) {
  202.                     const headMark2 = ballScoreMark(HEAD_SCORES);
  203.                     return {
  204.                         mark1: headMark,
  205.                         mark2: headMark2,
  206.                         mark3: isStrike(headMark2) ? ballScoreMark(HEAD_SCORES) : tailMark(headMark2)
  207.                     }
  208.                 }
  209.                 const tail = tailMark(headMark);
  210.                 return {
  211.                     mark1: headMark,
  212.                     mark2: tail,
  213.                     mark3: isSpare(headMark, tail) ? ballScoreMark(HEAD_SCORES) : EMPTY_MARK
  214.                 };
  215.             };
  216.             const frame = (_, i) => {
  217.                 const headMark = ballScoreMark(HEAD_SCORES);
  218.                 return isLastFrame(i + 1) ? lastFrame(headMark) : {
  219.                     mark1: headMark,
  220.                     mark2: tailMark(headMark)
  221.                 };
  222.             }, roundScore = scores => scores[9];
  223.             const roundMarkCount = (mark, round) => round.map(frame => {
  224.                 return Object.values(frame).filter(m => {
  225.                     return m.includes(mark);
  226.                 }).length;
  227.             }).reduce(sum, 0);
  228.             const roundStrikeStringSum = round => {
  229.                 let sum = 0, isLastStrike;
  230.                 round.forEach(frame => {
  231.                     Object.entries(frame).filter(([key, mark]) => {
  232.                         return key !== "mark3" && mark !== EMPTY_MARK;
  233.                     }).map(([key, mark]) => mark).forEach(mark => {
  234.                         if (!isStrike(mark)) return isLastStrike = false;
  235.                         if (isLastStrike) sum++;
  236.                         isLastStrike = true;
  237.                     });
  238.                 });
  239.                 return sum;
  240.             };
  241.             const roundStrikeStringLength = round => {
  242.                 let length = 0, tempLength = 0, isLastStrike;
  243.                 round.forEach(frame => {
  244.                     Object.entries(frame).filter(([key, mark]) => {
  245.                         return key !== "mark3" && mark !== EMPTY_MARK;
  246.                     }).map(([key, mark]) => mark).forEach(mark => {
  247.                         if (!isStrike(mark)) {
  248.                             length = Math.max(length, tempLength);
  249.                             tempLength = 0;
  250.                             return isLastStrike = false;
  251.                         }
  252.                         if (isLastStrike) tempLength++;
  253.                         isLastStrike = true;
  254.                     });
  255.                 });
  256.                 return Math.max(length, tempLength);
  257.             };
  258.             const roundSplitSpareCount = round => round.filter(frame => {
  259.                 const marks = Object.values(frame);
  260.                 if (!marks.includes(SPARE_MARK)) return false;
  261.                 if (frame.mark1.includes(SPLIT_MARK)) return true;
  262.                 return frame.mark2.includes(SPLIT_MARK);
  263.             }).length;
  264.             const isValid = round => {
  265.                 if (roundStrikeStringLength(round) > MAX_STRIKE_STRING_LENGTH) {
  266.                     return false;
  267.                 } else if (roundStrikeStringSum(round) > MAX_STRIKE_STRING_SUM) {
  268.                     return false;
  269.                 } else if (roundMarkCount(STRIKE_MARK, round) > MAX_STRIKES) {
  270.                     return false;
  271.                 } else if (roundSplitSpareCount(round) > MAX_SPLIT_SPARES) {
  272.                     return false;
  273.                 } else if (roundMarkCount(SPLIT_MARK, round) > MAX_SPLITS) {
  274.                     return false;
  275.                 }
  276.                 const score = roundScore(oldFrameScores(round));
  277.                 return score > ABOVE_OLD_SCORE && score < BELOW_OLD_SCORE;
  278.             }
  279.             const round = () => {
  280.                 const rawRound = Array(10).fill(0);
  281.                 let round;
  282.                 do { round = rawRound.map(frame); } while (!isValid(round));
  283.                 return round;
  284.             };
  285.             const roundScores = (system, rounds) => {
  286.                 return rounds.map(system).map(roundScore);
  287.             };
  288.             const roundScoreRanges = rounds => {
  289.                 const oldScores = roundScores(oldFrameScores, rounds);
  290.                 return roundScores(newFrameScores, rounds).map((score, i) => {
  291.                     return score - oldScores[i];
  292.                 });
  293.             };
  294.             const roundMarks = (mark, rounds) => {
  295.                 return rounds.map(roundMarkCount.bind(null, mark));
  296.             };
  297.             const roundStrikeStringSums = rounds => {
  298.                 return rounds.map(roundStrikeStringSum);
  299.             };
  300.             const roundStrikeStringLengths = rounds => {
  301.                 return rounds.map(roundStrikeStringLength);
  302.             }, roundSplitSpares = rounds => rounds.map(roundSplitSpareCount);
  303.             const isOpen = ({ mark2, mark3 }) => {
  304.                 if (mark2 === EMPTY_MARK || mark2 === SPARE_MARK) return false;
  305.                 return !isStrike(mark2) && mark3 !== SPARE_MARK;
  306.             }, roundOpenCount = round => round.filter(isOpen).length;
  307.             const roundOpens = rounds => rounds.map(roundOpenCount);
  308.             const isSplitOpen = frame => {
  309.                 const marks = Object.values(frame);
  310.                 if (marks.some(mark => mark === SPARE_MARK)) return false;
  311.                 if (frame.mark1.includes(SPLIT_MARK)) return true;
  312.                 return frame.mark2.includes(SPLIT_MARK);
  313.             };
  314.             const roundSplitOpenCount = round => {
  315.                 return round.filter(isSplitOpen).length;
  316.             }, roundSplitOpens = rounds => rounds.map(roundSplitOpenCount);
  317.             const roundNonSplitOpenCount = round => {
  318.                 return roundOpenCount(round) - roundSplitOpenCount(round);
  319.             };
  320.             const roundNonSplitOpens = rounds => {
  321.                 return rounds.map(roundNonSplitOpenCount);
  322.             }, avgNo = nos => nos.reduce(sum, 0) / nos.length;
  323.             const ascSort = (a, b) => a - b, medianNo = nos => {
  324.                 const ascNos = nos.sort(ascSort);
  325.                 const l = ascNos.length;
  326.                 return (ascNos[Math.floor((l + 1) / 2) - 1] + ascNos[Math.ceil((l + 1) / 2) - 1]) / 2;
  327.             };
  328.             const sdNo = nos => {
  329.                 const l = nos.length;
  330.                 if (l <= 1) return 0;
  331.                const avg = avgNo(nos);
  332.                return Math.sqrt(nos.reduce((sd, no) => {
  333.                     return sd + Math.pow(no - avg, 2);
  334.                 }, 0) / (l - 1));
  335.             };
  336.             const summary = (data, name) => {
  337.                 const ascData = data.sort(ascSort);
  338.                 return [
  339.                     `Min ${name}: ${ascData[0]}`,
  340.                     `Avg ${name}: ${avgNo(ascData)}`,
  341.                     `Max ${name}: ${ascData[ascData.length - 1]}`,
  342.                     `Median ${name}: ${medianNo(ascData)}`,
  343.                     `SD ${name}: ${sdNo(ascData)}`
  344.                 ].join(" ");
  345.             }, isClearGame = round => !round.some(isOpen);
  346.             const clearGameCount = rounds => rounds.filter(isClearGame).length;
  347.             const clearGames = rounds => {
  348.                 return `Clear games: ${clearGameCount(rounds)}`;
  349.             };
  350.             const isSplitOnlyNonClearGame = round => {
  351.                 if (roundSplitOpenCount(round) === 0) return false;
  352.                 return roundNonSplitOpenCount(round) === 0;
  353.             };
  354.             const splitOnlyNonClearGameCount = rounds => {
  355.                 return rounds.filter(isSplitOnlyNonClearGame).length;
  356.             };
  357.             const splitOnlyNonClearGames = rounds => {
  358.                 return `Split only non-clear games: ${splitOnlyNonClearGameCount(rounds)}`;
  359.             };
  360.             const scoreMilestones = scores => {
  361.                 const milestone1 = ASC_SCORE_MILESTONES[0];
  362.                 return [
  363.                     `[0, ${milestone1}): ${scores.filter(score => {
  364.                         return score < milestone1;
  365.                    }).length}`
  366.                ].concat(ASC_SCORE_MILESTONES.map((milestone, i) => {
  367.                     const nextMilestone = ASC_SCORE_MILESTONES[i + 1];
  368.                     if (!isNaN(nextMilestone)) {
  369.                         return `[${milestone}, ${nextMilestone}): ${scores.filter(score => {
  370.                             return score >= milestone && score < nextMilestone;
  371.                         }).length}`;
  372.                     }
  373.                     return `[${milestone}, 300]: ${scores.filter(score => {
  374.                         return score >= milestone;
  375.                     }).length}`;
  376.                 })).join(" ");
  377.             };
  378.             const markResults = (rounds, resultMark) => {
  379.                 return Object.keys(MARK_SCORES).concat([
  380.                     SPARE_MARK
  381.                 ]).map(mark => {
  382.                     return `${mark}: ${rounds.reduce((sum, round) => {
  383.                         return sum + round.filter(frame => {
  384.                             return frame[resultMark] === mark;
  385.                         }).length;
  386.                     }, 0)}`;
  387.                 }).join(" | ");
  388.             };
  389.             const gameBlockScore = (system, rounds, l) => {
  390.                 return new Array(rounds.length - l).fill("").map((e, i) => {
  391.                     return rounds.slice(i, i + l).reduce((sum, round) => {
  392.                         return sum + system(round)[9];
  393.                     }, 0);
  394.                 });
  395.             };
  396.             const summaries = rounds => [
  397.                 summary(roundScores(oldFrameScores, rounds), "old score"),
  398.                 summary(roundScores(newFrameScores, rounds), "new score"),
  399.                 summary(roundScoreRanges(rounds), "new - old score difference"),
  400.                 summary(roundMarks(STRIKE_MARK, rounds), "strikes"),
  401.                 summary(roundStrikeStringSums(rounds), "strike string sum"),
  402.                 summary(roundStrikeStringLengths(rounds), "strike string length"),
  403.                 summary(roundMarks(SPARE_MARK, rounds), "spares"),
  404.                 summary(roundMarks(SPLIT_MARK, rounds), "splits"),
  405.                 summary(roundMarks(ZERO_MARK, rounds), "zeroes"),
  406.                 summary(roundSplitSpares(rounds), "split spares"),
  407.                 summary(roundOpens(rounds), "opens"),
  408.                 summary(roundSplitOpens(rounds), "split opens"),
  409.                 summary(roundNonSplitOpens(rounds), "non-split opens"),
  410.                 summary(gameBlockScore(oldFrameScores, rounds, 2),
  411.                         "2 game block old score"),
  412.                 summary(gameBlockScore(newFrameScores, rounds, 2),
  413.                         "2 game block new score"),
  414.                 summary(gameBlockScore(oldFrameScores, rounds, 3),
  415.                         "3 game block old score"),
  416.                 summary(gameBlockScore(newFrameScores, rounds, 3),
  417.                         "3 game block new score"),
  418.                 summary(gameBlockScore(oldFrameScores, rounds, 4),
  419.                         "4 game block old score"),
  420.                 summary(gameBlockScore(newFrameScores, rounds, 4),
  421.                         "4 game block new score"),
  422.                 summary(gameBlockScore(oldFrameScores, rounds, 5),
  423.                         "5 game block old score"),
  424.                 summary(gameBlockScore(newFrameScores, rounds, 5),
  425.                         "5 game block new score"),
  426.                 summary(gameBlockScore(oldFrameScores, rounds, 6),
  427.                         "6 game block old score"),
  428.                 summary(gameBlockScore(newFrameScores, rounds, 6),
  429.                         "6 game block new score"),
  430.                 summary(gameBlockScore(oldFrameScores, rounds, 7),
  431.                         "7 game block old score"),
  432.                 summary(gameBlockScore(newFrameScores, rounds, 7),
  433.                         "7 game block new score"),
  434.                 summary(gameBlockScore(oldFrameScores, rounds, 8),
  435.                         "8 game block old score"),
  436.                 summary(gameBlockScore(newFrameScores, rounds, 8),
  437.                         "8 game block new score"),
  438.                 summary(gameBlockScore(oldFrameScores, rounds, 9),
  439.                         "9 game block old score"),
  440.                 summary(gameBlockScore(newFrameScores, rounds, 9),
  441.                         "9 game block new score"),
  442.                 summary(gameBlockScore(oldFrameScores, rounds, 10),
  443.                         "10 game block old score"),
  444.                 summary(gameBlockScore(newFrameScores, rounds, 10),
  445.                         "10 game block new score"),
  446.                 clearGames(rounds),
  447.                 splitOnlyNonClearGames(rounds),
  448.                 "Old Score Milestones:",
  449.                 scoreMilestones(roundScores(oldFrameScores, rounds)),
  450.                 "New Score Milestones:",
  451.                 scoreMilestones(roundScores(newFrameScores, rounds)),
  452.                 "1st Frame Mark",
  453.                 markResults(rounds, "mark1"),
  454.                 "2nd Frame Mark",
  455.                 markResults(rounds, "mark2"),
  456.                 "3rd Frame Mark",
  457.                 markResults(rounds, "mark3")
  458.             ].join("<br>");
  459.             const recordedFrames = round => round.map(({ mark1, mark2, mark3 }) => {
  460.                 return `${mark1}${mark2}${mark3 || ""}`
  461.             }).join(FRAME_SEPARATOR);
  462.             const recordedScore = score => {
  463.                 return `${Array(4 - `${score}`.length).fill(".").join("")}${score}`;
  464.             };
  465.             const recordedScores = scores => {
  466.                 return scores.map(recordedScore).join(FRAME_SEPARATOR);
  467.             };
  468.             const recordedRound = round => [
  469.                 recordedFrames(round),
  470.                 recordedScores(oldFrameScores(round)),
  471.                 recordedScores(newFrameScores(round))
  472.             ].join("<br>");
  473.             const recordedDay = rounds => [
  474.                 `<code>${rounds.map(recordedRound).join("<br>")}</code>`,
  475.                 `<div>${summaries(rounds)}</div>`
  476.             ].join("<br>");
  477.             const setHTML = (id, html) => {
  478.                 document.getElementById(id).innerHTML = html;
  479.             };
  480.             const ROUNDS = Array(DAY_COUNT * ROUNDS_PER_DAY).fill(0).map(round);
  481.             const DAYS = (() => {
  482.                 const days = [], rounds = ROUNDS.slice();
  483.                 while (rounds.length > 0) {
  484.                     days.push(rounds.splice(0, ROUNDS_PER_DAY));
  485.                 }
  486.                 return days;
  487.             })(), ASC_DAY_CLEAR_GAMES = DAYS.map(clearGameCount).sort(ascSort);
  488.             const ASC_DAY_SPLIT_ONLY_NON_CLEAR_GAMES = DAYS.map(splitOnlyNonClearGameCount).sort(ascSort);
  489.             const OLD_DAY_SCORES = DAYS.map(roundScores.bind(null, oldFrameScores));
  490.             const NEW_DAY_SCORES = DAYS.map(roundScores.bind(null, newFrameScores));
  491.             const ASC_AVG_OLD_DAY_SCORES = OLD_DAY_SCORES.map(avgNo).sort(ascSort);
  492.             const ASC_AVG_NEW_DAY_SCORES = NEW_DAY_SCORES.map(avgNo).sort(ascSort);
  493.             const ASC_MEDIAN_OLD_DAY_SCORES = OLD_DAY_SCORES.map(medianNo).sort(ascSort);
  494.             const ASC_MEDIAN_NEW_DAY_SCORES = NEW_DAY_SCORES.map(medianNo).sort(ascSort);
  495.             const ASC_SD_OLD_DAY_SCORES = OLD_DAY_SCORES.map(sdNo).sort(ascSort);
  496.             const ASC_SD_NEW_DAY_SCORES = NEW_DAY_SCORES.map(sdNo).sort(ascSort);
  497.             const ASC_MIN_OLD_DAY_SCORES = OLD_DAY_SCORES.map(nos => nos.sort(ascSort)[0]).sort(ascSort);
  498.             const ASC_MAX_OLD_DAY_SCORES = OLD_DAY_SCORES.map(nos => nos.sort(ascSort)[nos.length - 1]).sort(ascSort);
  499.             const ASC_MIN_NEW_DAY_SCORES = NEW_DAY_SCORES.map(nos => nos.sort(ascSort)[0]).sort(ascSort);
  500.             const ASC_MAX_NEW_DAY_SCORES = NEW_DAY_SCORES.map(nos => nos.sort(ascSort)[nos.length - 1]).sort(ascSort);
  501.             window.onload = () => {
  502.                 setHTML("summary", summaries(DAYS.reduce((rounds, days) => {
  503.                     return rounds.concat(days);
  504.                 }, [])));
  505.                 setHTML("minDayClear", ASC_DAY_CLEAR_GAMES[0]);
  506.                 setHTML("maxDayClear", ASC_DAY_CLEAR_GAMES[ASC_DAY_CLEAR_GAMES.length - 1]);
  507.                 setHTML("minDaySplitNonClear", ASC_DAY_SPLIT_ONLY_NON_CLEAR_GAMES[0]);
  508.                 setHTML("maxDaySplitNonClear", ASC_DAY_SPLIT_ONLY_NON_CLEAR_GAMES[ASC_DAY_SPLIT_ONLY_NON_CLEAR_GAMES.length - 1]);
  509.                 setHTML("minAvgOldDay", ASC_AVG_OLD_DAY_SCORES[0]);
  510.                 setHTML("maxAvgOldDay", ASC_AVG_OLD_DAY_SCORES[ASC_AVG_OLD_DAY_SCORES.length - 1]);
  511.                 setHTML("minAvgNewDay", ASC_AVG_NEW_DAY_SCORES[0]);
  512.                 setHTML("maxAvgNewDay", ASC_AVG_NEW_DAY_SCORES[ASC_AVG_NEW_DAY_SCORES.length - 1]);
  513.                 setHTML("minMedianOldDay", ASC_MEDIAN_OLD_DAY_SCORES[0]);
  514.                 setHTML("maxMedianOldDay", ASC_MEDIAN_OLD_DAY_SCORES[ASC_MEDIAN_OLD_DAY_SCORES.length - 1]);
  515.                 setHTML("minMedianNewDay", ASC_MEDIAN_NEW_DAY_SCORES[0]);
  516.                 setHTML("maxMedianNewDay", ASC_MEDIAN_NEW_DAY_SCORES[ASC_MEDIAN_NEW_DAY_SCORES.length - 1]);
  517.                 setHTML("minSDOldDay", ASC_SD_OLD_DAY_SCORES[0]);
  518.                 setHTML("maxSDOldDay", ASC_SD_OLD_DAY_SCORES[ASC_SD_OLD_DAY_SCORES.length - 1]);
  519.                 setHTML("minSDNewDay", ASC_SD_NEW_DAY_SCORES[0]);
  520.                 setHTML("maxSDNewDay", ASC_SD_NEW_DAY_SCORES[ASC_SD_NEW_DAY_SCORES.length - 1]);
  521.                 setHTML("maxOldDayMin", ASC_MIN_OLD_DAY_SCORES[ASC_MIN_OLD_DAY_SCORES.length - 1]);
  522.                 setHTML("minOldDayMax", ASC_MAX_OLD_DAY_SCORES[0]);
  523.                 setHTML("maxNewDayMin", ASC_MIN_NEW_DAY_SCORES[ASC_MIN_NEW_DAY_SCORES.length - 1]);
  524.                 setHTML("minNewDayMax", ASC_MAX_NEW_DAY_SCORES[0]);
  525.                 setHTML("dayOldScoreMilestones", scoreMilestones(ASC_AVG_OLD_DAY_SCORES));
  526.                 setHTML("dayNewScoreMilestones", scoreMilestones(ASC_AVG_NEW_DAY_SCORES));
  527.                 setHTML("days", DAYS.map(recordedDay).join("<hr>"));
  528.             };
  529.             //
  530.         </script>
  531.     </head>
  532.     <body>
  533.         <div id="summary"></div>
  534.         <br>
  535.         Min day clear games: <span id="minDayClear"></span>
  536.         Max day clear games: <span id="maxDayClear"></span>
  537.         <br>
  538.         Min day split only non-clear games: <span id="minDaySplitNonClear"></span>
  539.         Max day split only non-clear games: <span id="maxDaySplitNonClear"></span>
  540.         <br>
  541.         Min old day avg score: <span id="minAvgOldDay"></span>
  542.         Max old day avg score: <span id="maxAvgOldDay"></span>
  543.         <br>
  544.         Min new day avg score: <span id="minAvgNewDay"></span>
  545.         Max new day avg score: <span id="maxAvgNewDay"></span>
  546.         <br>
  547.         Min old day median score: <span id="minMedianOldDay"></span>
  548.         Max old day median score: <span id="maxMedianOldDay"></span>
  549.         <br>
  550.         Min new day median score: <span id="minMedianNewDay"></span>
  551.         Max new day median score: <span id="maxMedianNewDay"></span>
  552.         <br>
  553.         Min old day sd score: <span id="minSDOldDay"></span>
  554.         Max old day sd score: <span id="maxSDOldDay"></span>
  555.         <br>
  556.         Min new day sd score: <span id="minSDNewDay"></span>
  557.         Max new day sd score: <span id="maxSDNewDay"></span>
  558.         <br>
  559.         Max old day min score: <span id="maxOldDayMin"></span>
  560.         Min old day max score: <span id="minOldDayMax"></span>
  561.         <br>
  562.         Max new day min score: <span id="maxNewDayMin"></span>
  563.         Min new day max score: <span id="minNewDayMax"></span>
  564.         <br>
  565.         Old score milestones:
  566.         <br>
  567.         <div id="dayOldScoreMilestones"></div>
  568.         New score milestones:
  569.         <br>
  570.         <div id="dayNewScoreMilestones"></div>
  571.         <br>
  572.         <hr>
  573.         <br>
  574.         <div id="days"></div>
  575.     </body>
  576. </html>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!