15 Prompts for ChatGPT and GPT-4: Programming, Debugging, and Refactoring

Write a Python function that takes a list of integers and returns the longest increasing subsequence. Use dynamic programming with O(n log n) complexity. Include type hints and a docstring that explains the algorithm. Add an example usage at the bottom.

from bisect import bisect_left

def longest_increasing_subsequence(nums: list[int]) -> list[int]:
    """
    Returns the longest increasing subsequence using patience sorting.
    Complexity: O(n log n) time, O(n) space.
    """
    if not nums:
        return []
    tails = []  # tails[i] = smallest tail of all increasing subsequences of length i+1
    indices = []
    for num in nums:
        i = bisect_left(tails, num)
        if i == len(tails):
            tails.append(num)
        else:
            tails[i] = num
    # Reconstruct subsequence (simplified)
    return tails

print(longest_increasing_subsequence([10, 9, 2, 5, 3, 7, 101, 18]))  # [2, 3, 7, 101]

I have a table 'orders' with columns: id, user_id, total_amount, created_at. Write a SQL query that finds the top 5 users by total order amount in the last 30 days. Use PostgreSQL syntax. Include an index recommendation.

SELECT user_id, SUM(total_amount) as total_spent
FROM orders
WHERE created_at >= NOW() - INTERVAL '30 days'
GROUP BY user_id
ORDER BY total_spent DESC
LIMIT 5;

-- Recommended index:
-- CREATE INDEX idx_orders_created_at_user_total ON orders (created_at, user_id, total_amount);

I'm getting this error in a Node.js app: "TypeError: Cannot read properties of undefined (reading 'name')". Here's the relevant code:

const user = getUser(id);
console.log(user.name);

Explain what's happening and suggest a fix.

This code is supposed to return the sum of all even numbers in an array, but it returns 0. Find the bug:

function sumEven(arr) {
  let sum = 0;
  for (let i = 0; i <= arr.length; i++) {
    if (arr[i] % 2 === 0) {
      sum += arr[i];
    }
  }
  return sum;
}

I have a React component that re-renders infinitely. Add console.log statements at key points to help me trace the cause. Here's the component:

function MyComponent() {
  const [count, setCount] = useState(0);
  useEffect(() => {
    setCount(count + 1);
  }, [count]);
  return <div>{count}</div>;
}

Refactor this JavaScript function to use async/await instead of promises. Keep the same behavior and error handling:

function fetchData(url) {
  return fetch(url)
    .then(response => response.json())
    .catch(err => console.error(err));
}

async function fetchData(url) {
  try {
    const response = await fetch(url);
    return await response.json();
  } catch (err) {
    console.error(err);
  }
}

Refactor this Python function into smaller, single-responsibility functions. Each should have a clear purpose and be testable independently:

def process_order(order):
    # validate
    if not order.get('items'):
        raise ValueError('No items')
    # calculate total
    total = sum(item['price'] * item['qty'] for item in order['items'])
    # apply discount
    if order.get('coupon'):
        total *= 0.9
    # save to db
    db.save(order, total)
    # send email
    send_email(order['email'], f'Total: {total}')

This Python function finds duplicates in a list of 1 million integers. It's too slow. Refactor it to run in O(n) time:

def find_duplicates(arr):
    dups = []
    for i in range(len(arr)):
        for j in range(i+1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in dups:
                dups.append(arr[i])
    return dups

Compare using PostgreSQL JSONB vs. MongoDB for storing user preferences that vary per user. Consider query performance, schema flexibility, and operational complexity. Give a recommendation for a startup with a single developer.

Design a REST API endpoint for a notification service that sends email and push notifications. Describe the endpoint URL, HTTP method, request body, response format, and error codes. Include a sample curl command.

Generate pytest tests for the following function. Cover edge cases: empty list, negative numbers, all same values, and performance with 1000 elements.

def find_max(numbers):
    if not numbers:
        return None
    return max(numbers)

I'm adding a 'password reset' feature to a web app. Write a test plan covering: valid reset, invalid token, expired token, rate limiting, and SQL injection attempts. Format as a table with columns: Test Case, Input, Expected Result.

Write a README in Markdown for a Python library called 'csv2json' that converts CSV files to JSON. Include installation, usage example, API reference, and a license section (MIT).

Explain this Python decorator in plain English, as if to a junior developer:

def memoize(func):
    cache = {}
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

Review this code for a pull request. Focus on: potential bugs, security issues, performance bottlenecks, and adherence to Python best practices (PEP 8). Here's the diff:

+def get_user(user_id):
+    return db.query(f"SELECT * FROM users WHERE id = {user_id}")