Finished

Test Name	Status
deletes only the first occurrence	Fail
pop gets last element from the list	Pass
push/pop respectively add/remove at the end of the list	Pass
shift gets element from the list	Pass
shift gets first element from the list	Pass
unshift adds element at the start of the list	Pass
pop, push, shift, and unshift can be used in any order	Pass
count an empty list	Pass
count a list with items	Pass
count is correct after mutation	Pass
popping to empty doesn't break the list	Pass
shifting to empty doesn't break the list	Pass
deletes the only element	Pass
deletes the element with the specified value from the list	Pass
deletes the element with the specified value from the list, re-assigns tail	Pass
deletes the element with the specified value from the list, re-assigns head	Pass
deletes the first of two elements	Pass
deletes the second of two elements	Pass
delete does not modify the list if the element is not found	Pass

Ridges.AI

 // convenience to get you started writing code faster.
 //
+class Node {
+  constructor(value) {
+    this.value = value;
+    this.next = null;
+    this.prev = null;
+  }
+}
 export class LinkedList {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+  }
   /**
    * @param {*} value
    * @returns {void}
    */
   push(value) {
+    throw new Error('Remove this line and implement the function');
+    const newNode = new Node(value);
+    // Edge Case: Empty list
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+      return;
+    }
+    // Add to the end of the list
+    newNode.prev = this.tail;
+    this.tail.next = newNode;
+    this.tail = newNode;
+  }
   /**
    * @returns {*}
    */
   pop() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Empty list
+    if (!this.tail) {
+      return undefined;
+    }
+    const value = this.tail.value;
+    // Edge Case: Single node list
+    if (this.head === this.tail) {
+      this.head = null;
+      this.tail = null;
+      return value;
+    }
+    // Remove from the end
+    this.tail = this.tail.prev;
+    this.tail.next = null;
+    return value;
+  }
   /**
    * @returns {*}
    */
   shift() {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Empty list
+    if (!this.head) {
+      return undefined;
+    }
+    const value = this.head.value;
+    // Edge Case: Single node list
+    if (this.head === this.tail) {
+      this.head = null;
+      this.tail = null;
+      return value;
+    }
+    // Remove from the beginning
+    this.head = this.head.next;
+    this.head.prev = null;
+    return value;
+  }
   /**
    * @returns {void}
    */
   unshift(value) {
+    throw new Error('Remove this line and implement the function');
+    const newNode = new Node(value);
+    // Edge Case: Empty list
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+      return;
+    }
+    // Add to the beginning
+    newNode.next = this.head;
+    this.head.prev = newNode;
+    this.head = newNode;
+  }
   /**
    * @returns {void}
    */
   delete(value) {
+    throw new Error('Remove this line and implement the function');
+    // Edge Case: Empty list
+    if (!this.head) {
+      return;
+    }
+    // Delete all occurrences from the head
+    while (this.head && this.head.value === value) {
+      this.shift();
+    }
+    // Delete all occurrences from the middle and tail
+    let current = this.head;
+    while (current) {
+      if (current.value === value) {
+        // If it's the tail, use pop
+        if (current === this.tail) {
+          this.pop();
+          break; // pop() updates tail, so we need to break
+        } else {
+          // Remove from middle
+          current.prev.next = current.next;
+          current.next.prev = current.prev;
+          let nextNode = current.next;
+          current = nextNode;
+        }
+      } else {
+        current = current.next;
+      }
+    }
+  }
   /**
    * @returns {number}
    */
   count() {
+    throw new Error('Remove this line and implement the function');
+    let count = 0;
+    let current = this.head;
+    // Edge Case: Empty list
+    if (!current) {
+      return count;
+    }
+    // Count all nodes
+    while (current) {
+      count++;
+      current = current.next;
+    }
+    return count;
+  }
+  // Handled Edge Cases: Empty list, single node list
+  // Handled Edge Cases: Empty list
+  // Handled Edge Cases: Empty list, single node list
+  // Handled Edge Cases: Empty list, single node list
+  // Handled Edge Cases: Empty list, delete head node, delete tail node, value not found
+  // Handled Edge Cases: Empty list
+}

Polyglot JavaScript - without test patch

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed