DeepSeek vs ChatGPT

A hard prompt: “Evaluate an arithmetic expression, no eval”, in full.

• DeepSeek V4.1 Flash

  Passed: All 15 tests passed.

  ```javascript
  function evaluate(expression) {
    if (typeof expression !== 'string') {
      throw new Error('Expression must be a string');
    }
  
    // ---- Tokenizer ----
    const tokens = [];
    let i = 0;
    const isDigit = (c) => c >= '0' && c <= '9';
  
    while (i < expression.length) {
      const ch = expression[i];
  
      if (ch === ' ' || ch === '\t') {
        i++;
        continue;
      }
  
      // number: digits with an optional single decimal point (at least one digit)
      if (isDigit(ch) || ch === '.') {
        let j = i;
        let digits = 0;
        while (j < expression.length && isDigit(expression[j])) {
          j++;
          digits++;
        }
        if (j < expression.length && expression[j] === '.') {
          j++;
          while (j < expression.length && isDigit(expression[j])) {
            j++;
            digits++;
          }
        }
        if (digits === 0) {
          throw new Error('Invalid number in expression');
        }
        tokens.push({ type: 'num', value: parseFloat(expression.slice(i, j)) });
        i = j;
        continue;
      }
  
      if ('+-*/^()'.indexOf(ch) !== -1) {
        tokens.push({ type: ch });
        i++;
        continue;
      }
  
      throw new Error('Unexpected character: ' + ch);
    }
  
    if (tokens.length === 0) {
      throw new Error('Empty expression');
    }
  
    // ---- Parser (recursive descent) ----
    let pos = 0;
    const peek = () => tokens[pos];
    const isOp = (tok, ch) => tok !== undefined && tok.type === ch;
  
    // expr := term (('+' | '-') term)*          left-associative
    function parseExpression() {
      let value = parseTerm();
      while (isOp(peek(), '+') || isOp(peek(), '-')) {
        const op = tokens[pos++].type;
        const rhs = parseTerm();
        value = op === '+' ? value + rhs : value - rhs;
      }
      return value;
    }
  
    // term := unary (('*' | '/') unary)*        left-associative
    function parseTerm() {
      let value = parseUnary();
      while (isOp(peek(), '*') || isOp(peek(), '/')) {
        const op = tokens[pos++].type;
        const rhs = parseUnary();
        value = op === '*' ? value * rhs : value / rhs;
      }
      return value;
    }
  
    // unary := ('-' | '+') unary | power
    // unary minus is looser than '^', so -2^2 === -(2^2) === -4
    function parseUnary() {
      if (isOp(peek(), '-')) {
        pos++;
        return -parseUnary();
      }
      if (isOp(peek(), '+')) {
        pos++;
        return parseUnary();
      }
      return parsePower();
    }
  
    // power := primary ('^' unary)?             right-associative
    // the exponent is a unary, which permits 2^-1 and 2^3^2 = 2^(3^2)
    function parsePower() {
      const base = parsePrimary();
      if (isOp(peek(), '^')) {
        pos++;
        const exponent = parseUnary();
        return Math.pow(base, exponent);
      }
      return base;
    }
  
    // primary := number | '(' expr ')'
    function parsePrimary() {
      const tok = peek();
      if (tok === undefined) {
        throw new Error('Unexpected end of expression');
      }
      if (tok.type === 'num') {
        pos++;
        return tok.value;
      }
      if (tok.type === '(') {
        pos++;
        const value = parseExpression();
        if (!isOp(peek(), ')')) {
          throw new Error('Missing closing parenthesis');
        }
        pos++;
        return value;
      }
      throw new Error('Unexpected token: ' + tok.type);
    }
  
    const result = parseExpression();
    if (pos !== tokens.length) {
      throw new Error('Unexpected token: ' + tokens[pos].type);
    }
    return result;
  }
  ```

  591 tokens in, 2,442 out (1,491 of them reasoning) · 5.8 s · $0.0030 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

• GPT-6 Luna

  Passed: All 15 tests passed.

  ```javascript
  function evaluate(expression) {
    if (typeof expression !== "string") {
      throw new Error("Expression must be a string");
    }
  
    let index = 0;
  
    function skipSpaces() {
      while (index < expression.length && /\s/.test(expression[index])) {
        index++;
      }
    }
  
    function parsePrimary() {
      skipSpaces();
  
      if (expression[index] === "(") {
        index++;
        const value = parseExpression();
        skipSpaces();
        if (expression[index] !== ")") throw new Error("Missing closing parenthesis");
        index++;
        return value;
      }
  
      const start = index;
      let digitsBefore = 0;
      while (/\d/.test(expression[index] || "")) {
        index++;
        digitsBefore++;
      }
  
      let digitsAfter = 0;
      if (expression[index] === ".") {
        index++;
        while (/\d/.test(expression[index] || "")) {
          index++;
          digitsAfter++;
        }
      }
  
      if (digitsBefore === 0 && digitsAfter === 0) {
        throw new Error("Expected a number or parenthesized expression");
      }
  
      return Number(expression.slice(start, index));
    }
  
    // Unary minus has lower precedence than exponentiation, but is allowed
    // on an exponent's right-hand side.
    function parseUnary() {
      skipSpaces();
      if (expression[index] === "-") {
        index++;
        return -parseUnary();
      }
      return parsePower();
    }
  
    function parsePower() {
      let value = parsePrimary();
      skipSpaces();
  
      if (expression[index] === "^") {
        index++;
        value **= parseUnary();
      }
  
      return value;
    }
  
    function parseProduct() {
      let value = parseUnary();
  
      while (true) {
        skipSpaces();
        const operator = expression[index];
        if (operator !== "*" && operator !== "/") break;
  
        index++;
        const right = parseUnary();
        value = operator === "*" ? value * right : value / right;
      }
  
      return value;
    }
  
    function parseExpression() {
      let value = parseProduct();
  
      while (true) {
        skipSpaces();
        const operator = expression[index];
        if (operator !== "+" && operator !== "-") break;
  
        index++;
        const right = parseProduct();
        value = operator === "+" ? value + right : value - right;
      }
  
      return value;
    }
  
    const result = parseExpression();
    skipSpaces();
    if (index !== expression.length) throw new Error("Unexpected input");
  
    return result;
  }
  ```

  549 tokens in, 1,007 out (455 of them reasoning) · 8.8 s · $0.0006 · 1 message on Pro · answered by openai/gpt-6-luna via OpenAI · September 27, 2026