Best prompts for ChatGPT for coding using optimizing code performance

I have the following Python function that is a performance hotspot. Analyze it for algorithmic complexity and micro-optimizations, produce a faster alternative (keeping behavior identical), explain each change and trade-off, and provide benchmark code (timeit) comparing original vs optimized version. Code: def compute_scores(records): out = [] for r in records: s = 0 for i in range(len(r['values'])): s += r['values'][i] * (i+1) out.append(s) return out Constraints: preserve floating-point accuracy within 1e-9, support very large lists (millions of values).

A Node.js Express endpoint processes uploaded JSON arrays and crashes with OOM on large payloads. Provide a step-by-step memory profiling plan (tools and commands), identify common memory leak and retention patterns, propose code-level fixes and streaming alternatives, and give a minimal patched example. Code snippet: app.post('/summarize', async (req, res) => { const data = await req.json(); // large array of objects const summary = data.map(d => ({id: d.id, sum: d.values.reduce((a,b)=>a+b,0)})); res.json(summary); }); Constraints: must work with 1+ GB JSON streams, no breaking API contract.

I have a function that loops elementwise over arrays and is slow. Convert it to a fully vectorized NumPy solution, explain memory vs speed trade-offs, and provide a memory-safe chunked approach for very large arrays. Code: def normalize_pairs(a,b): out = [] for i in range(len(a)): s = a[i]+b[i] if s != 0: out.append((a[i]/s, b[i]/s)) else: out.append((0.0,0.0)) return out Constraints: arrays are float64, length up to 100 million.

I have a CPU-bound task in Java that processes millions of records and runs on a multi-core machine but only uses one core. Provide a version using Java concurrency (ExecutorService, parallel streams, or ForkJoin) that maximizes throughput, avoids contention, explains thread-safety considerations, and compares approaches with microbenchmarks. Code: public void processAll(List<Record> items) { for (Record r : items) { r.process(); // CPU heavy, pure compute } } Constraints: records are independent, must preserve result ordering optionally via flag.

Given this slow SQL query and table schema, analyze the query plan, recommend indexes and schema changes, rewrite the query for efficiency, and provide migration SQL and before/after EXPLAIN ANALYZE results (or simulated expected improvements). Schema: CREATE TABLE orders(id BIGINT PRIMARY KEY, user_id BIGINT, status VARCHAR, created_at TIMESTAMP, total_cents BIGINT); CREATE INDEX ON orders (user_id); Query: SELECT o.user_id, SUM(o.total_cents) FROM orders o WHERE o.status='completed' AND o.created_at >= '2024-01-01' GROUP BY o.user_id HAVING SUM(o.total_cents) > 1000000; Constraints: orders table has hundreds of millions of rows, low-latency required for reporting job.

A pure-Python numeric loop is the bottleneck. Provide two alternative pathways: a Cython implementation (with typed memoryviews) and a PyPy-friendly pure-Python refactor. Include build instructions, microbenchmarks, and the exact patched code for both approaches. Code: def integrate(y, dx): acc = 0.0 out = [] for v in y: acc += v*dx out.append(acc) return out Constraints: minimal API change, must run on Linux CI with GCC and be easily added to Dockerfile.