DeepSeek vs ChatGPT for coding

Every limit is published. Paid plans also have a monthly fair-use limit on AI cost: Pro $7.50, Max $20, Ultra $42, Studio $85. Using every message on your plan at typical sizes stays under it; very large messages and heavy research use it faster. Every limit, explained.

Coding: DeepSeek V4.1 Flash passed 5 of 5 and GPT-6 Luna 5 of 5. DeepSeek V4.1 Flash answered 1.8× sooner at the median, 2.5 s against 4.6 s. GPT-6 Luna cost 6.4× less, $0.0092 against $0.0014 for the 5 replies. DeepSeek V4.1 Flash's replies ran 62% longer, in tokens of reply, thinking not counted.

1. 1. Turn a title into a URL slug

   Everyday. DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0004 · GPT: 4 of 4 models passed, GPT-6 Luna the cheapest at $0.0001. The prompt in full.

   DeepSeek V4.1 Flash and GPT-6 Luna both passed this one. DeepSeek V4.1 Flash answered sooner (1.3 s to 2.3 s), and GPT-6 Luna's reply cost less ($0.0001 to $0.0004); DeepSeek V4.1 Flash wrote 253 tokens of reply, GPT-6 Luna 74.

   • DeepSeek V4.1 Flash

     Passed: All 7 tests passed.

     ```javascript
     function slugify(title) {
       return title
         .normalize('NFD')            // split accented letters into base + combining mark
         .replace(/[\u0300-\u036f]/g, '') // drop the combining marks (é → e, ñ → n, ü → u)
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')  // every run of anything else becomes one hyphen
         .replace(/^-+|-+$/g, '');     // trim leading/trailing hyphens
     }
     ```
     
     Note: `normalize('NFD')` handles the accents, but a few letters don't decompose that way (`ø`, `ß`, `đ`, `æ`). If you need those, add an explicit map before the cleanup:
     
     ```javascript
     const SPECIAL = { ø: 'o', ß: 'ss', đ: 'd', æ: 'ae', œ: 'oe', þ: 'th', ł: 'l' };
     ```
     
     with `title.replace(/[øßđæœþł]/gi, c => SPECIAL[c.toLowerCase()])` inserted before `.toLowerCase()`.

     522 tokens in, 276 out (23 of them reasoning) · 1.3 s · $0.0004 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 7, 2026

   • GPT-6 Luna

     Passed: All 7 tests passed.

     ```javascript
     function slugify(title) {
       return title
         .toLowerCase()
         .normalize("NFD")
         .replace(/[\u0300-\u036f]/g, "")
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "");
     }
     ```

     483 tokens in, 74 out · 2.3 s · $0.0001 · 1 message on Pro · answered by openai/gpt-6-luna via OpenAI · September 27, 2026

2. 2. Parse a duration like “1h 30m”

   Everyday. DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0011 · GPT: 4 of 4 models passed, GPT-6 Luna the cheapest at $0.0003. The prompt in full.

   DeepSeek V4.1 Flash and GPT-6 Luna both passed this one. DeepSeek V4.1 Flash answered sooner (2.5 s to 4.6 s), and GPT-6 Luna's reply cost less ($0.0003 to $0.0011); DeepSeek V4.1 Flash wrote 144 tokens of reply, GPT-6 Luna 138.

   • DeepSeek V4.1 Flash

     Passed: All 10 tests passed.

     ```javascript
     function parseDuration(text) {
       if (typeof text !== 'string') return null;
       const match = /^\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?\s*$/.exec(text);
       if (!match) return null;
       const [, h, m, s] = match;
       if (h === undefined && m === undefined && s === undefined) return null;
       return (h ? Number(h) * 3600 : 0) + (m ? Number(m) * 60 : 0) + (s ? Number(s) : 0);
     }
     ```

     505 tokens in, 890 out (746 of them reasoning) · 2.5 s · $0.0011 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 7, 2026

   • GPT-6 Luna

     Passed: All 10 tests passed.

     ```javascript
     function parseDuration(text) {
       if (typeof text !== "string") return null;
     
       const match = text.match(/^\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?\s*$/);
       if (!match || !match[1] && !match[2] && !match[3]) return null;
     
       return Number(match[1] || 0) * 3600
         + Number(match[2] || 0) * 60
         + Number(match[3] || 0);
     }
     ```

     468 tokens in, 407 out (269 of them reasoning) · 4.6 s · $0.0003 · 1 message on Pro · answered by openai/gpt-6-luna via OpenAI · September 27, 2026

3. 3. Merge overlapping intervals

   Everyday. DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0003 · GPT: 4 of 4 models passed, GPT-6 Luna the cheapest at $0.0001. The prompt in full.

   DeepSeek V4.1 Flash and GPT-6 Luna both passed this one. DeepSeek V4.1 Flash answered sooner (0.6 s to 1.5 s), and GPT-6 Luna's reply cost less ($0.0001 to $0.0003); DeepSeek V4.1 Flash wrote 210 tokens of reply, GPT-6 Luna 130.

   • DeepSeek V4.1 Flash

     Passed: All 7 tests passed.

     ```javascript
     function mergeIntervals(intervals) {
       if (!Array.isArray(intervals) || intervals.length === 0) return [];
     
       // Copy each pair so the input array (and its pairs) are never mutated.
       const sorted = intervals
         .map(([start, end]) => [start, end])
         .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
     
       const merged = [sorted[0]];
     
       for (let i = 1; i < sorted.length; i++) {
         const [start, end] = sorted[i];
         const last = merged[merged.length - 1];
     
         if (start <= last[1]) {
           // Overlapping or touching: extend the current interval.
           if (end > last[1]) last[1] = end;
         } else {
           merged.push([start, end]);
         }
       }
     
       return merged;
     }
     ```

     489 tokens in, 216 out (6 of them reasoning) · 0.6 s · $0.0003 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

   • GPT-6 Luna

     Passed: All 7 tests passed.

     ```javascript
     function mergeIntervals(intervals) {
       const sorted = intervals
         .map(([start, end]) => [start, end])
         .sort((a, b) => a[0] - b[0]);
     
       const merged = [];
     
       for (const [start, end] of sorted) {
         const last = merged[merged.length - 1];
     
         if (!last || start > last[1]) {
           merged.push([start, end]);
         } else {
           last[1] = Math.max(last[1], end);
         }
       }
     
       return merged;
     }
     ```

     449 tokens in, 130 out · 1.5 s · $0.0001 · 1 message on Pro · answered by openai/gpt-6-luna via OpenAI · September 27, 2026

4. 4. Evaluate an arithmetic expression, no eval

   Hard. DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0030 · GPT: 4 of 4 models passed, GPT-6 Luna the cheapest at $0.0006. The prompt in full.

   DeepSeek V4.1 Flash and GPT-6 Luna both passed this one. DeepSeek V4.1 Flash answered sooner (5.8 s to 8.8 s), and GPT-6 Luna's reply cost less ($0.0006 to $0.0030); DeepSeek V4.1 Flash wrote 951 tokens of reply, GPT-6 Luna 552.

   • 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

5. 5. Parse CSV with quoted fields

   Hard. DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0042 · GPT: 4 of 4 models passed, GPT-6 Luna the cheapest at $0.0004. The prompt in full.

   DeepSeek V4.1 Flash and GPT-6 Luna both passed this one. GPT-6 Luna answered sooner (7.2 s to 9.1 s), and GPT-6 Luna's reply cost less ($0.0004 to $0.0042); DeepSeek V4.1 Flash wrote 399 tokens of reply, GPT-6 Luna 315.

   • DeepSeek V4.1 Flash

     Passed: All 8 tests passed.

     ```javascript
     function parseCsv(text) {
       const rows = [];
       let row = [];
       let field = '';
       let inQuotes = false;
       let pending = false; // true if there is an in-progress field/row
       let i = 0;
       const n = text.length;
     
       while (i < n) {
         const ch = text[i];
     
         if (inQuotes) {
           if (ch === '"') {
             if (text[i + 1] === '"') {
               field += '"';
               i += 2;
             } else {
               inQuotes = false;
               i += 1;
             }
           } else {
             field += ch;
             i += 1;
           }
           continue;
         }
     
         if (ch === '"' && field === '') {
           // A quote only opens a quoted field when it is the first char of the field.
           inQuotes = true;
           pending = true;
           i += 1;
           continue;
         }
     
         if (ch === ',') {
           row.push(field);
           field = '';
           pending = true;
           i += 1;
           continue;
         }
     
         if (ch === '\n' || ch === '\r') {
           if (ch === '\r' && text[i + 1] === '\n') i += 1; // treat CRLF as one break
           row.push(field);
           rows.push(row);
           row = [];
           field = '';
           pending = false;
           i += 1;
           continue;
         }
     
         field += ch;
         pending = true;
         i += 1;
       }
     
       // A line break at the very end leaves "pending" false, so no empty trailing row.
       if (pending) {
         row.push(field);
         rows.push(row);
       }
     
       return rows;
     }
     ```

     522 tokens in, 3,473 out (3,074 of them reasoning) · 9.1 s · $0.0042 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

   • GPT-6 Luna

     Passed: All 8 tests passed.

     ```javascript
     function parseCsv(text) {
       if (text === "") return [];
     
       const rows = [];
       let row = [];
       let field = "";
       let inQuotes = false;
       let endedWithRowBreak = false;
     
       for (let i = 0; i < text.length; i++) {
         const char = text[i];
     
         if (inQuotes) {
           if (char === '"') {
             if (text[i + 1] === '"') {
               field += '"';
               i++;
             } else {
               inQuotes = false;
             }
           } else {
             field += char;
           }
           endedWithRowBreak = false;
           continue;
         }
     
         if (char === '"' && field === "") {
           inQuotes = true;
           endedWithRowBreak = false;
         } else if (char === ",") {
           row.push(field);
           field = "";
           endedWithRowBreak = false;
         } else if (char === "\n" || (char === "\r" && text[i + 1] === "\n")) {
           row.push(field);
           rows.push(row);
           row = [];
           field = "";
           if (char === "\r") i++;
           endedWithRowBreak = true;
         } else {
           field += char;
           endedWithRowBreak = false;
         }
       }
     
       if (!endedWithRowBreak) {
         row.push(field);
         rows.push(row);
       }
     
       return rows;
     }
     ```

     481 tokens in, 762 out (447 of them reasoning) · 7.2 s · $0.0004 · 1 message on Pro · answered by openai/gpt-6-luna via OpenAI · September 27, 2026

• DeepSeek V4 Pro vs GPT-6 Astra: 5 of 5 each; GPT-6 Astra answered 14.6× sooner at the median and cost about the same.

• DeepSeek V4 Pro vs GPT-6.1 Sol: 5 of 5 each; GPT-6.1 Sol answered 25.1× sooner at the median and cost 10.4× less.

• DeepSeek V4 Pro vs GPT-6 Sol: 5 of 5 each; GPT-6 Sol answered 24.9× sooner at the median and cost 4.6× less. GPT-6 Sol vs DeepSeek V4 Pro, on every job.

• DeepSeek V4 Pro vs GPT-6 Luna: 5 of 5 each; GPT-6 Luna answered 26.2× sooner at the median and cost 83.7× less. GPT-6 Luna vs DeepSeek V4 Pro, on every job.

• DeepSeek V4.1 Flash vs GPT-6 Astra: 5 of 5 each; DeepSeek V4.1 Flash answered 3.3× sooner at the median and cost 12.2× less.

• DeepSeek V4.1 Flash vs GPT-6.1 Sol: 5 of 5 each; DeepSeek V4.1 Flash answered 1.9× sooner at the median and cost 1.3× less.

• DeepSeek V4.1 Flash vs GPT-6 Sol: 5 of 5 each; DeepSeek V4.1 Flash answered 1.9× sooner at the median and cost 2.9× less.

• DeepSeek V4.1 Flash vs GPT-6 Luna: 5 of 5 each; DeepSeek V4.1 Flash answered 1.8× sooner at the median and GPT-6 Luna cost 6.4× less. GPT-6 Luna vs DeepSeek V4.1 Flash, on every job.

Every DeepSeek and GPT reply above was checked the same way as every other model's, by the rules published with the prompts: how the coding prompts are scored, and each one in full.

• The lineups

  DeepSeek: 2 models, DeepSeek V4 Pro and DeepSeek V4.1 Flash. GPT: 4 models, GPT-6 Astra, GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna.

• Price per message

  The least expensive DeepSeek model is DeepSeek V4.1 Flash (60 messages a day on Pro); the least expensive GPT model is GPT-6 Luna (60 messages a day on Pro).

• Context window

  DeepSeek goes up to 1.05M tokens (DeepSeek V4 Pro); GPT up to 1.05M tokens (GPT-6 Astra).

• Images and PDFs

  DeepSeek V4 Pro doesn't read images. DeepSeek V4 Pro and DeepSeek V4.1 Flash get a PDF's text rather than the file itself.

• On the Free plan

  Free's one-time trial of 5 messages covers DeepSeek V4 Pro, DeepSeek V4.1 Flash, GPT-6.1 Sol, GPT-6 Sol, and GPT-6 Luna. Paid plans have every model, with messages every month.

In llmwise, a message to GPT goes to its maker, OpenAI, or through OpenRouter when llmwise can't reach the maker directly. DeepSeek models are served only through OpenRouter, by endpoints that don't store or train on prompts. The Privacy Policy has the details.