Claude Haiku 4.5 vs Gemini 3.8 Flash

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

• Claude Haiku 4.5

  Failed: 14 of 15 tests passed. First failure: evaluate("-2 ^ 2"): Expected values to be strictly deep-equal:

  ```javascript
  function evaluate(expression) {
    const tokens = tokenize(expression);
    const parser = new Parser(tokens);
    const result = parser.parseExpression();
    
    if (parser.pos !== tokens.length) {
      throw new Error("Unexpected tokens after expression");
    }
    
    return result;
  }
  
  function tokenize(expression) {
    const tokens = [];
    let i = 0;
    
    while (i < expression.length) {
      const ch = expression[i];
      
      if (/\s/.test(ch)) {
        i++;
        continue;
      }
      
      if (/\d/.test(ch)) {
        let num = '';
        while (i < expression.length && /[\d.]/.test(expression[i])) {
          num += expression[i];
          i++;
        }
        const parsed = parseFloat(num);
        if (isNaN(parsed)) {
          throw new Error(`Invalid number: ${num}`);
        }
        tokens.push({ type: 'NUMBER', value: parsed });
        continue;
      }
      
      if ('+-*/^()'.includes(ch)) {
        tokens.push({ type: ch, value: ch });
        i++;
        continue;
      }
      
      throw new Error(`Unexpected character: ${ch}`);
    }
    
    return tokens;
  }
  
  class Parser {
    constructor(tokens) {
      this.tokens = tokens;
      this.pos = 0;
    }
    
    peek() {
      return this.tokens[this.pos];
    }
    
    consume() {
      return this.tokens[this.pos++];
    }
    
    parseExpression() {
      return this.parseAddSub();
    }
    
    parseAddSub() {
      let left = this.parseMulDiv();
      
      while (this.peek() && (this.peek().type === '+' || this.peek().type === '-')) {
        const op = this.consume().type;
        const right = this.parseMulDiv();
        left = op === '+' ? left + right : left - right;
      }
      
      return left;
    }
    
    parseMulDiv() {
      let left = this.parsePower();
      
      while (this.peek() && (this.peek().type === '*' || this.peek().type === '/')) {
        const op = this.consume().type;
        const right = this.parsePower();
        left = op === '*' ? left * right : left / right;
      }
      
      return left;
    }
    
    parsePower() {
      let left = this.parseUnary();
      
      if (this.peek() && this.peek().type === '^') {
        this.consume();
        const right = this.parsePower();
        left = Math.pow(left, right);
      }
      
      return left;
    }
    
    parseUnary() {
      if (this.peek() && this.peek().type === '-') {
        this.consume();
        return -this.parseUnary();
      }
      
      if (this.peek() && this.peek().type === '+') {
        this.consume();
        return this.parseUnary();
      }
      
      return this.parsePrimary();
    }
    
    parsePrimary() {
      const token = this.peek();
      
      if (!token) {
        throw new Error("Unexpected end of expression");
      }
      
      if (token.type === 'NUMBER') {
        this.consume();
        return token.value;
      }
      
      if (token.type === '(') {
        this.consume();
        const result = this.parseExpression();
        
        if (!this.peek() || this.peek().type !== ')') {
          throw new Error("Missing closing parenthesis");
        }
        
        this.consume();
        return result;
      }
      
      throw new Error(`Unexpected token: ${token.value}`);
    }
  }
  ```

  599 tokens in, 1,007 out · 7.6 s · $0.0056 · 1 message on Pro · answered by anthropic/claude-haiku-4.5 via Amazon Bedrock · September 27, 2026

• Gemini 3.8 Flash

  Passed: All 15 tests passed.

  ```javascript
  function evaluate(expression) {
    // Tokenize the expression
    const tokens = [];
    let i = 0;
    const n = expression.length;
  
    while (i < n) {
      const ch = expression[i];
  
      if (/\s/.test(ch)) {
        i++;
        continue;
      }
  
      if (/[0-9.]/.test(ch)) {
        let start = i;
        let dotCount = 0;
        while (i < n && /[0-9.]/.test(expression[i])) {
          if (expression[i] === '.') dotCount++;
          i++;
        }
        if (dotCount > 1) {
          throw new Error(`Invalid number format at index ${start}`);
        }
        const numStr = expression.slice(start, i);
        if (numStr === '.') {
          throw new Error(`Invalid single dot at index ${start}`);
        }
        tokens.push({ type: 'NUMBER', value: parseFloat(numStr) });
        continue;
      }
  
      if ('+-*/^()'.includes(ch)) {
        tokens.push({ type: ch, value: ch });
        i++;
        continue;
      }
  
      throw new Error(`Unexpected character '${ch}' at index ${i}`);
    }
  
    let pos = 0;
  
    function peek() {
      return tokens[pos];
    }
  
    function consume(expectedType) {
      const token = tokens[pos];
      if (!token || (expectedType && token.type !== expectedType)) {
        throw new Error(`Unexpected token at position ${pos}`);
      }
      pos++;
      return token;
    }
  
    // Grammar with precedence:
    // Expr    -> AddSub
    // AddSub  -> MulDiv (('+' | '-') MulDiv)*
    // MulDiv  -> Unary (('*' | '/') Unary)*
    // Unary   -> '-' Unary | Power
    // Power   -> Primary ('^' (Unary | Power))?   -- right associative, handles 2^-1 and -2^2
    // Primary -> NUMBER | '(' Expr ')'
  
    function parseExpr() {
      return parseAddSub();
    }
  
    function parseAddSub() {
      let left = parseMulDiv();
      while (pos < tokens.length && (tokens[pos].type === '+' || tokens[pos].type === '-')) {
        const op = consume().type;
        const right = parseMulDiv();
        left = op === '+' ? left + right : left - right;
      }
      return left;
    }
  
    function parseMulDiv() {
      let left = parseUnary();
      while (pos < tokens.length && (tokens[pos].type === '*' || tokens[pos].type === '/')) {
        const op = consume().type;
        const right = parseUnary();
        if (op === '/') {
          left = left / right;
        } else {
          left = left * right;
        }
      }
      return left;
    }
  
    function parseUnary() {
      if (pos < tokens.length && tokens[pos].type === '-') {
        consume('-');
        return -parseUnary();
      }
      if (pos < tokens.length && tokens[pos].type === '+') {
        consume('+');
        return parseUnary();
      }
      return parsePower();
    }
  
    function parsePower() {
      let left = parsePrimary();
      if (pos < tokens.length && tokens[pos].type === '^') {
        consume('^');
        // Right-hand side allows unary minus (e.g. 2^-1) or another power
        const right = parseUnary();
        return Math.pow(left, right);
      }
      return left;
    }
  
    function parsePrimary() {
      const token = peek();
      if (!token) {
        throw new Error('Unexpected end of input');
      }
  
      if (token.type === 'NUMBER') {
        consume('NUMBER');
        return token.value;
      }
  
      if (token.type === '(') {
        consume('(');
        const val = parseExpr();
        consume(')');
        return val;
      }
  
      throw new Error(`Unexpected token '${token.value}' at position ${pos}`);
    }
  
    if (tokens.length === 0) {
      throw new Error('Empty expression');
    }
  
    const result = parseExpr();
  
    if (pos < tokens.length) {
      throw new Error(`Unexpected token at position ${pos}`);
    }
  
    return result;
  }
  ```

  587 tokens in, 1,070 out · 6.7 s · $0.0045 · 1 message on Pro · answered by google/gemini-3.8-flash via Google · September 27, 2026