Claude Opus 5.5 vs Gemini 3.1 Pro (preview)

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

• Claude Opus 5.5

  Passed: All 15 tests passed.

  ```javascript
  function evaluate(expression) {
    if (typeof expression !== "string") {
      throw new Error("Expression must be a string");
    }
  
    // Tokenizer
    const tokens = [];
    const numberRe = /\d+(?:\.\d+)?|\.\d+/y;
    let i = 0;
    while (i < expression.length) {
      const ch = expression[i];
      if (/\s/.test(ch)) {
        i++;
        continue;
      }
      if ("+-*/^()".includes(ch)) {
        tokens.push({ type: ch });
        i++;
        continue;
      }
      numberRe.lastIndex = i;
      const m = numberRe.exec(expression);
      if (m) {
        tokens.push({ type: "num", value: parseFloat(m[0]) });
        i += m[0].length;
        continue;
      }
      throw new Error(`Unexpected character '${ch}' at position ${i}`);
    }
  
    // Recursive descent parser
    let pos = 0;
    const peek = () => tokens[pos];
    const accept = (type) => {
      if (tokens[pos] && tokens[pos].type === type) {
        pos++;
        return true;
      }
      return false;
    };
  
    // expr := term (('+' | '-') term)*
    function parseExpr() {
      let value = parseTerm();
      for (;;) {
        if (accept("+")) value += parseTerm();
        else if (accept("-")) value -= parseTerm();
        else return value;
      }
    }
  
    // term := unary (('*' | '/') unary)*
    function parseTerm() {
      let value = parseUnary();
      for (;;) {
        if (accept("*")) value *= parseUnary();
        else if (accept("/")) value /= parseUnary();
        else return value;
      }
    }
  
    // unary := '-' unary | power
    function parseUnary() {
      if (accept("-")) return -parseUnary();
      return parsePower();
    }
  
    // power := primary ('^' unary)?   (right-associative; exponent may be negated)
    function parsePower() {
      const base = parsePrimary();
      if (accept("^")) {
        const exponent = parseUnary();
        return Math.pow(base, exponent);
      }
      return base;
    }
  
    // primary := number | '(' expr ')'
    function parsePrimary() {
      const tok = peek();
      if (!tok) throw new Error("Unexpected end of expression");
      if (tok.type === "num") {
        pos++;
        return tok.value;
      }
      if (accept("(")) {
        const value = parseExpr();
        if (!accept(")")) throw new Error("Expected ')'");
        return value;
      }
      throw new Error(`Unexpected token '${tok.type}'`);
    }
  
    if (tokens.length === 0) throw new Error("Empty expression");
    const result = parseExpr();
    if (pos !== tokens.length) {
      const tok = tokens[pos];
      throw new Error(
        `Unexpected token '${tok.type === "num" ? tok.value : tok.type}'`
      );
    }
    return result;
  }
  ```

  762 tokens in, 1,491 out (435 of them reasoning) · 15.8 s · $0.0336 · 1 message on Pro · answered by anthropic/claude-opus-5.5 via Claude Platform on AWS · September 27, 2026

• Gemini 3.1 Pro

  Passed: All 15 tests passed.

  ```javascript
  function evaluate(expression) {
      let pos = 0;
  
      function peek() {
          while (pos < expression.length && expression[pos] === ' ') {
              pos++;
          }
          return pos < expression.length ? expression[pos] : null;
      }
  
      function parseExpr() {
          let left = parseTerm();
          while (true) {
              let char = peek();
              if (char === '+' || char === '-') {
                  pos++;
                  let right = parseTerm();
                  if (char === '+') left += right;
                  else left -= right;
              } else {
                  break;
              }
          }
          return left;
      }
  
      function parseTerm() {
          let left = parseFactor();
          while (true) {
              let char = peek();
              if (char === '*' || char === '/') {
                  pos++;
                  let right = parseFactor();
                  if (char === '*') left *= right;
                  else left /= right;
              } else {
                  break;
              }
          }
          return left;
      }
  
      function parseFactor() {
          let char = peek();
          if (char === '-') {
              pos++;
              return -parseFactor();
          }
          return parsePower();
      }
  
      function parsePower() {
          let left = parsePrimary();
          let char = peek();
          if (char === '^') {
              pos++;
              let right = parseFactor();
              return Math.pow(left, right);
          }
          return left;
      }
  
      function parsePrimary() {
          let char = peek();
          if (char === null) {
              throw new Error("Unexpected end of expression");
          }
  
          if (char === '(') {
              pos++;
              let val = parseExpr();
              if (peek() !== ')') {
                  throw new Error("Missing closing parenthesis");
              }
              pos++;
              return val;
          }
  
          let match = expression.slice(pos).match(/^\d+(\.\d+)?/);
          if (!match) {
              throw new Error(`Invalid character at position ${pos}`);
          }
          pos += match[0].length;
          return parseFloat(match[0]);
      }
  
      let result = parseExpr();
      if (peek() !== null) {
          throw new Error(`Unexpected character at position ${pos}`);
      }
      
      return result;
  }
  ```

  587 tokens in, 2,831 out (2,262 of them reasoning) · 20.6 s · $0.0351 · 1 message on Pro · answered by google/gemini-3.1-pro-preview via Google · September 27, 2026