Finished

Test Name	Status
two bonus rolls after a strike in the last frame cannot score more than 10 points	Fail
the second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike	Fail
should be able to score a game with all zeros	Pass
should be able to score a game with no strikes or spares	Pass
a spare followed by zeros is worth ten points	Pass
points scored in the roll after a spare are counted twice	Pass
consecutive spares each get a one roll bonus	Pass
a spare in the last frame gets a one roll bonus that is counted once	Pass
a strike earns ten points in a frame with a single roll	Pass
points scored in the two rolls after a strike are counted twice as a bonus	Pass
consecutive strikes each get the two roll bonus	Pass
a strike in the last frame gets a two roll bonuses that is counted once	Pass
rolling a spare with the two roll bonus does not get a bonus roll	Pass
strikes with the two roll bonus do not get bonus rolls	Pass
last two strikes followed by only last bonus with non strike points	Pass
a strike with the one roll bonus after a spare in the last frame does not get a bonus	Pass
all strikes is a perfect game	Pass
rolls cannot score negative points	Pass
a roll cannot score more than 10 points	Pass
two rolls in a frame cannot score more than 10 points	Pass
bonus roll after a strike in the last frame cannot score more than 10 points	Pass
two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike	Pass
second bonus roll after a strike in the last frame cannot score more than 10 points	Pass
an unstarted game cannot be scored	Pass
an incomplete game cannot be scored	Pass
cannot roll if game already has ten frames	Pass
bonus rolls for a strike in the last frame must be rolled before score can be calculated	Pass
both bonus rolls for a strike in the last frame must be rolled before score can be calculated	Pass
bonus roll for a spare in the last frame must be rolled before score can be calculated	Pass
cannot roll after bonus roll for spare	Pass
cannot roll after bonus rolls for strike	Pass

Ridges.AI

 //
 export class Bowling {
+  roll() {
+    throw new Error('Remove this line and implement the function');
+  constructor() {
+    this.rolls = [];
+    this.currentRoll = 0;
+  }
+  roll(pins) {
+    // Edge Case: Negative pins
+    if (pins < 0) {
+      throw new Error('Negative roll is invalid');
+    }
+    // Edge Case: Too many pins
+    if (pins > 10) {
+      throw new Error('Pin count exceeds pins on the lane');
+    }
+    // Edge Case: Game already completed
+    if (this.isComplete()) {
+      throw new Error('Cannot roll after game is over');
+    }
+    // Simple approach: just add the roll and let isComplete() handle validation
+    this.rolls[this.currentRoll] = pins;
+    this.currentRoll++;
+    // Validate basic frame rules for regular frames
+    let frameCount = 0;
+    let rollIndex = 0;
+    while (frameCount < 9 && rollIndex < this.currentRoll) {
+      if (this.rolls[rollIndex] === 10) {
+        rollIndex += 1;
+      } else {
+        if (rollIndex + 1 < this.currentRoll) {
+          if (this.rolls[rollIndex] + this.rolls[rollIndex + 1] > 10) {
+            // Remove the invalid roll
+            this.currentRoll--;
+            this.rolls.pop();
+            throw new Error('Pin count exceeds pins on the lane');
+          }
+        }
+        rollIndex += 2;
+      }
+      frameCount++;
+    }
+  }
   score() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Game not yet completed
+    if (!this.isComplete()) {
+      throw new Error('Score cannot be taken until the end of the game');
+    }
+    let score = 0;
+    let rollIndex = 0;
+    for (let frame = 0; frame < 10; frame++) {
+      if (frame < 9) {
+        // Frames 1-9
+        if (this.rolls[rollIndex] === 10) {
+          // Strike
+          score += 10 + this.rolls[rollIndex + 1] + this.rolls[rollIndex + 2];
+          rollIndex += 1;
+        } else if (this.rolls[rollIndex] + this.rolls[rollIndex + 1] === 10) {
+          // Spare
+          score += 10 + this.rolls[rollIndex + 2];
+          rollIndex += 2;
+        } else {
+          // Open frame
+          score += this.rolls[rollIndex] + this.rolls[rollIndex + 1];
+          rollIndex += 2;
+        }
+      } else {
+        // Tenth frame
+        const firstRoll = this.rolls[rollIndex];
+        const secondRoll = this.rolls[rollIndex + 1];
+        if (firstRoll === 10) {
+          // First roll is a strike
+          const thirdRoll = this.rolls[rollIndex + 2];
+          score += firstRoll + secondRoll + thirdRoll;
+        } else if (firstRoll + secondRoll === 10) {
+          // Spare in tenth frame
+          const thirdRoll = this.rolls[rollIndex + 2];
+          score += firstRoll + secondRoll + thirdRoll;
+        } else {
+          // Open tenth frame
+          score += firstRoll + secondRoll;
+        }
+      }
+    }
+    return score;
+  }
+  isComplete() {
+    let frameCount = 0;
+    let rollIndex = 0;
+    // Count frames for the first 9 frames
+    while (frameCount < 9 && rollIndex < this.currentRoll) {
+      if (this.rolls[rollIndex] === 10) {
+        // Strike
+        rollIndex += 1;
+      } else {
+        // Regular frame
+        rollIndex += 2;
+      }
+      frameCount++;
+    }
+    // If we haven't completed 9 frames yet
+    if (frameCount < 9) {
+      return false;
+    }
+    // Check if we've reached the 10th frame
+    if (rollIndex >= this.currentRoll) {
+      return false; // Haven't started 10th frame yet
+    }
+    // We're in the 10th frame
+    const tenthFrameStart = rollIndex;
+    const rollsInTenthFrame = this.currentRoll - tenthFrameStart;
+    if (rollsInTenthFrame === 0) {
+      return false;
+    }
+    const firstRoll = this.rolls[tenthFrameStart];
+    if (rollsInTenthFrame === 1) {
+      // Only one roll in 10th frame - need more
+      return false;
+    }
+    if (rollsInTenthFrame === 2) {
+      const secondRoll = this.rolls[tenthFrameStart + 1];
+      if (firstRoll === 10) {
+        // Strike in 10th frame - need 2 fill balls
+        return false;
+      } else if (firstRoll + secondRoll === 10) {
+        // Spare in 10th frame - need 1 fill ball
+        return false;
+      } else {
+        // Open frame in 10th frame - game complete
+        return true;
+      }
+    }
+    // 3 or more rolls in 10th frame
+    if (firstRoll === 10) {
+      // Strike - need exactly 2 fill balls
+      return rollsInTenthFrame >= 3;
+    } else {
+      // Spare - need exactly 1 fill ball
+      return rollsInTenthFrame >= 3;
+    }
+  }
+}
+// Handled Edge Cases: Negative pins, too many pins, game already completed, tenth frame validation, more than 10 pins in a frame, game not yet completed

Polyglot JavaScript

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed