DeepSeek Prompt Templates for Reasoning, Math & Code

Solve the following problem. Please reason step by step, and put your final answer within \boxed{}.

<problem>
[Paste the math, physics, or statistics problem here]
</problem>

Requirements:
1. Restate what is given and what is asked in one or two lines.
2. Name the method or theorem you will use before applying it.
3. Show each algebraic or numeric step on its own line, keeping units throughout.
4. After reaching an answer, verify it by substitution, a sanity check on magnitude, or an alternative method.
5. If the problem is ambiguous, state your interpretation explicitly before solving.

End with exactly one \boxed{} expression containing the simplified final answer.

I need to make a decision and want you to reason through it carefully.

Decision: [e.g. "build our own auth service or buy a managed provider"]
Context: [team size, budget, deadline, constraints]
Options I am considering: [Option A], [Option B], [Option C]

Work through it in this order:
1. List the assumptions each option depends on, and mark which ones are uncertain.
2. Define 4 to 6 decision criteria and give each a weight that sums to 100.
3. Score every option against every criterion from 1 to 5 and show the weighted totals in a table.
4. Run a sensitivity check: which single assumption, if wrong, would flip the ranking?
5. Identify the cheapest experiment I could run this week to reduce that uncertainty.

Finish with a clear recommendation, the main risk of choosing it, and the early warning sign that should make me revisit the decision.

You are debugging a problem with me. Find the root cause before suggesting any fix.

Language / framework: [e.g. Python 3.12, FastAPI]
Expected behavior: [what should happen]
Actual behavior: [what happens instead, including the full error message and stack trace]

Code:
```
[Paste the relevant code]
```

Steps:
1. Trace the execution path that leads to the failure and point to the exact line where behavior diverges.
2. List up to 3 hypotheses ranked by likelihood, each with the evidence for and against it.
3. For the top hypothesis, give a minimal reproduction or a log statement that would confirm it.
4. Propose the smallest fix that addresses the root cause, not just the symptom, and show the corrected code.
5. Add a regression test that fails before the fix and passes after it.

Do not rewrite unrelated code.

Help me design an efficient algorithm for this problem.

<problem>
[Paste the problem statement, input constraints, and examples]
</problem>

Target language: [e.g. C++17, Python, Rust]

Reason through it as follows:
1. Describe the brute-force approach and its time and space complexity.
2. Identify the key observation or structure (monotonicity, overlapping subproblems, graph shape, and so on) that enables a faster solution.
3. Present the optimized algorithm in plain language, then argue why it is correct.
4. State its exact time and space complexity and confirm it fits the given constraints.
5. List edge cases: empty input, single element, maximum sizes, duplicates, negative values.
6. Write clean, commented code and walk through one example by hand to show it produces the expected output.

Extract the information from the input below and return it as json.

Schema (follow it exactly):
{
  "title": "string",
  "summary": "string, max 40 words",
  "entities": [{"name": "string", "type": "person | organization | product | location"}],
  "sentiment": "positive | neutral | negative",
  "action_items": ["string"]
}

Rules:
- Output only a single valid JSON object. No markdown fences, no comments, no text before or after it.
- Use null for any field that is not present in the input. Never invent values.
- Use empty arrays instead of omitting array fields.
- Keep the original language of names and quotes.

Input:
[Paste the article, email, ticket, or transcript]

Write a SQL query that answers a business question. Reason about correctness before writing the final query.

Dialect: [PostgreSQL / MySQL / BigQuery / SQLite]
Schema:
[Paste CREATE TABLE statements or a table and column list with types]

Question: [e.g. "monthly active users by signup cohort for the last 6 months"]

Work through it:
1. Restate the question as precise definitions (what counts as active, which timezone, how to treat nulls).
2. Identify the tables, join keys, and join type needed, and flag any risk of row duplication from one-to-many joins.
3. Write the query using CTEs with descriptive names.
4. Explain the indexes that would make it fast and estimate which step is most expensive.
5. Provide a tiny sample dataset and the expected result so I can test it.

Return the final query in one code block.

Act as a rigorous reviewer and verify the following proof or argument.

<claim>
[State the theorem or conclusion]
</claim>

<proof>
[Paste the proof or argument]
</proof>

Instructions:
1. Number each step of the proof and label it Valid, Gap, or Error.
2. For every Gap, state the missing lemma or justification. For every Error, give a concrete counterexample or explain why the inference fails.
3. Check whether all hypotheses of the claim were actually used; an unused hypothesis often signals a mistake.
4. Check boundary and degenerate cases.
5. If the proof is fixable, write the corrected version. If the claim itself is false, say so and give a counterexample.

End with a one-line verdict: Correct, Correct with minor gaps, or Incorrect.

Analyze this problem using first-principles thinking.

Problem: [e.g. "why is our customer acquisition cost rising and how could we halve it"]
What we currently believe: [conventional wisdom or current approach]

Steps:
1. List every assumption embedded in the current approach.
2. For each assumption, ask whether it is a physical or mathematical constraint, a market fact backed by data, or simply convention. Label it accordingly.
3. Keep only the fundamental truths and state them as short, verifiable statements.
4. From those truths alone, rebuild 3 distinct solutions that ignore convention.
5. Estimate the order-of-magnitude impact and cost of each solution, showing your arithmetic.

Close with the single most promising solution and the first concrete step to test it.

Translate the following code from [source language] to [target language].

```
[Paste the source code]
```

Requirements:
1. Preserve behavior exactly, including error handling, edge cases, and numeric precision.
2. Write idiomatic [target language]: use its standard library, naming conventions, and error model rather than a line-by-line transliteration.
3. Do not add third-party dependencies unless there is no standard alternative; if you add one, explain why.
4. Point out any construct that has no direct equivalent and how you handled it.
5. Note behavior that could differ subtly between the two runtimes (integer overflow, string encoding, concurrency, floating point).

Return the translated code in one block, followed by a short table: Source construct | Target construct | Notes.

Write unit tests for the function below.

Test framework: [e.g. pytest, Jest, Go testing, JUnit 5]

```
[Paste the function or class under test]
```

Before writing tests:
1. Describe the function's contract: inputs, outputs, side effects, and errors it may raise.
2. Partition the input space into equivalence classes and list boundary values for each.
3. Identify failure modes: invalid types, empty or null input, very large input, concurrency, and external dependencies that need mocking.

Then write the tests:
- One test per behavior, each with a descriptive name.
- Use table-driven or parameterized tests where the framework supports them.
- Mock only external I/O, never the logic under test.
- Include at least one test that would catch an off-by-one error.

Finish with any bug you suspect in the function based on this analysis.

You are a professional technical translator fluent in Simplified Chinese, Traditional Chinese, and English.

Direction: [Chinese to English / English to Chinese]
Target audience: [e.g. developers reading API docs]
Tone: [formal / neutral / conversational]

Text:
[Paste the text to translate]

Instructions:
1. Translate for meaning and natural fluency, not word for word.
2. Keep code, commands, file paths, URLs, and placeholders such as {{name}} exactly as they are.
3. Use standard industry terminology; when a term has several common translations, choose the one most familiar to the target audience.
4. Preserve the original Markdown structure, lists, and headings.

Return the translation first, then a glossary table (Source term | Translation | Note) covering every technical term you made a choice about.

Help me design a rigorous experiment.

Question I want to answer: [e.g. "does a shorter onboarding flow increase 7-day retention"]
Population and traffic: [who is eligible and how many per week]
Constraints: [time, budget, ethical or technical limits]

Reason through:
1. State the null and alternative hypotheses precisely.
2. Choose one primary metric and up to 3 guardrail metrics, with exact definitions.
3. Pick the design (A/B, multi-arm, crossover, stepped rollout) and justify it.
4. Calculate the required sample size for a stated minimum detectable effect, significance level, and power, showing the formula and numbers.
5. List threats to validity (novelty effects, contamination, seasonality, peeking) and how to mitigate each.
6. Write the analysis plan you will commit to before seeing the data.

Summarize the design in a one-page brief.

Build a unit economics model for my business and show every calculation.

Business model: [e.g. B2B SaaS with monthly plans]
Inputs:
- Average revenue per account per month: [value]
- Gross margin: [value]
- Monthly churn rate: [value]
- Marketing and sales spend per month: [value]
- New customers acquired per month: [value]

Steps:
1. Compute CAC, customer lifetime, LTV, LTV:CAC ratio, and CAC payback period. Write each formula before substituting numbers.
2. Flag any input that looks unrealistic for this business model and explain why.
3. Run three scenarios (pessimistic, base, optimistic) by varying churn and CAC, and present them in a table.
4. Identify which lever (price, churn, CAC, margin) improves LTV:CAC the most per 10% change.

State all assumptions clearly. This is a planning model, not financial advice.

Estimate the following quantity using a Fermi approach: [e.g. "the number of EV charging sessions per day in Germany"].

Rules:
1. Decompose the quantity into a chain of 4 to 7 factors that multiply or add to the answer.
2. For each factor, give a low, likely, and high estimate, and the reasoning or reference point behind it.
3. Compute the result for all three cases, showing the arithmetic.
4. Cross-check the likely answer with an independent decomposition from a different angle and compare.
5. Identify the factor with the largest uncertainty and explain how I could find real data for it.

Report the final estimate as a range with the most likely value, rounded to a sensible number of significant figures.

Design a system and reason explicitly about trade-offs.

System: [e.g. "a URL shortener" or "a real-time notification service"]
Scale: [daily active users, requests per second, data growth]
Non-functional requirements: [latency target, availability, consistency, budget]

Work through:
1. Back-of-the-envelope capacity estimates: QPS at peak, storage per year, bandwidth. Show the math.
2. A high-level architecture with each component's responsibility.
3. The data model and the choice of storage engine, with the reasoning.
4. Three key design decisions, each comparing at least two alternatives on latency, cost, complexity, and failure behavior.
5. Failure scenarios: what happens when each critical component goes down, and how the system degrades.
6. What you would build first for an MVP versus at full scale.

Keep the answer structured with headings.