Make your reasoning
runnable.

function solve({nums, target}) {
  const first = new Map();
  for (let j = 0; j < nums.length; j++) {
    const needed = target - nums[j];
    if (first.has(needed)) return [first.get(needed), j];
    if (!first.has(nums[j])) first.set(nums[j], j);
  }
  return [];
}

def solve(input):
    first = {}
    for j, value in enumerate(input['nums']):
        needed = input['target'] - value
        if needed in first:
            return [first[needed], j]
        if value not in first:
            first[value] = j
    return []

function solve(input) {
  const stack = [], pairs = {')':'(', ']':'[', '}':'{'};
  for (const ch of input) {
    if ('([{'.includes(ch)) stack.push(ch);
    else if (Object.hasOwn(pairs, ch) && stack.pop() !== pairs[ch]) return false;
  }
  return stack.length === 0;
}

def solve(input):
    stack = []
    pairs = {')':'(', ']':'[', '}':'{'}
    for ch in input:
        if ch in '([{':
            stack.append(ch)
        elif ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
    return not stack

function solve({intervals}) {
  const ordered = intervals.map(pair => [...pair]).sort((a,b) => a[0]-b[0] || a[1]-b[1]);
  const merged = [];
  for (const pair of ordered) {
    const last = merged[merged.length-1];
    if (last && pair[0] <= last[1]) last[1] = Math.max(last[1], pair[1]);
    else merged.push(pair);
  }
  return merged;
}

def solve(input):
    merged = []
    for start, end in sorted(input['intervals']):
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

function solve(input) {
  const last = new Map();
  let left = 0, best = 0;
  for (let right = 0; right < input.length; right++) {
    if (last.has(input[right])) left = Math.max(left, last.get(input[right])+1);
    last.set(input[right], right);
    best = Math.max(best, right-left+1);
  }
  return best;
}

def solve(input):
    last, left, best = {}, 0, 0
    for right, ch in enumerate(input):
        if ch in last:
            left = max(left, last[ch] + 1)
        last[ch] = right
        best = max(best, right - left + 1)
    return best

function solve({nums, target}) {
  let low = 0, high = nums.length;
  while (low < high) {
    const mid = low + Math.floor((high-low)/2);
    if (nums[mid] < target) low = mid+1;
    else high = mid;
  }
  return low < nums.length && nums[low] === target ? low : -1;
}

def solve(input):
    nums, target = input['nums'], input['target']
    low, high = 0, len(nums)
    while low < high:
        mid = low + (high - low) // 2
        if nums[mid] < target:
            low = mid + 1
        else:
            high = mid
    return low if low < len(nums) and nums[low] == target else -1

function solve({grid}) {
  const rows = grid.length, cols = rows ? grid[0].length : 0;
  if (!rows || !cols || grid[0][0] || grid[rows-1][cols-1]) return -1;
  const queue = [[0,0,0]], seen = new Set(['0,0']);
  for (let head = 0; head < queue.length; head++) {
    const [r,c,d] = queue[head];
    if (r === rows-1 && c === cols-1) return d;
    for (const [dr,dc] of [[1,0],[-1,0],[0,1],[0,-1]]) {
      const nr = r+dr, nc = c+dc, key = nr+','+nc;
      if (nr>=0 && nr<rows && nc>=0 && nc<cols && grid[nr][nc]===0 && !seen.has(key)) {
        seen.add(key); queue.push([nr,nc,d+1]);
      }
    }
  }
  return -1;
}

def solve(input):
    from collections import deque
    grid = input['grid']
    rows, cols = len(grid), len(grid[0]) if grid else 0
    if not rows or not cols or grid[0][0] or grid[-1][-1]:
        return -1
    queue, seen = deque([(0, 0, 0)]), {(0, 0)}
    while queue:
        r, c, distance = queue.popleft()
        if (r, c) == (rows - 1, cols - 1):
            return distance
        for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 0 and (nr, nc) not in seen:
                seen.add((nr, nc))
                queue.append((nr, nc, distance + 1))
    return -1

function solve({tasks, edges}) {
  const outgoing = new Map(tasks.map(t => [t,new Set()]));
  const degree = new Map(tasks.map(t => [t,0]));
  for (const [a,b] of edges) if (!outgoing.get(a).has(b)) {
    outgoing.get(a).add(b); degree.set(b,degree.get(b)+1);
  }
  const ready = tasks.filter(t => degree.get(t)===0).sort(), answer = [];
  while (ready.length) {
    const task = ready.shift(); answer.push(task);
    for (const next of outgoing.get(task)) {
      degree.set(next,degree.get(next)-1);
      if (degree.get(next)===0) {ready.push(next); ready.sort();}
    }
  }
  return answer.length===tasks.length ? answer : [];
}

def solve(input):
    import heapq
    outgoing = {task: set() for task in input['tasks']}
    degree = {task: 0 for task in input['tasks']}
    for before, after in input['edges']:
        if after not in outgoing[before]:
            outgoing[before].add(after)
            degree[after] += 1
    ready = [task for task in input['tasks'] if degree[task] == 0]
    heapq.heapify(ready)
    answer = []
    while ready:
        task = heapq.heappop(ready)
        answer.append(task)
        for next_task in outgoing[task]:
            degree[next_task] -= 1
            if degree[next_task] == 0:
                heapq.heappush(ready, next_task)
    return answer if len(answer) == len(input['tasks']) else []

function solve({nums, k}) {
  if (!nums.length || k > nums.length) return [];
  const deque = [], result = []; let head = 0;
  for (let i=0; i<nums.length; i++) {
    while (head < deque.length && deque[head] <= i-k) head++;
    while (head < deque.length && nums[deque[deque.length-1]] <= nums[i]) deque.pop();
    deque.push(i);
    if (i >= k-1) result.push(nums[deque[head]]);
  }
  return result;
}

def solve(input):
    from collections import deque
    nums, k = input['nums'], input['k']
    if not nums or k > len(nums):
        return []
    candidates, result = deque(), []
    for i, value in enumerate(nums):
        while candidates and candidates[0] <= i - k:
            candidates.popleft()
        while candidates and nums[candidates[-1]] <= value:
            candidates.pop()
        candidates.append(i)
        if i >= k - 1:
            result.append(nums[candidates[0]])
    return result

function solve({values}) {
  if (!values.length) return [];
  let low=values[0], high=values[0];
  for (const value of values) {low=Math.min(low,value); high=Math.max(high,value);}
  return high===low ? values.map(()=>0) : values.map(value=>Number(((value-low)/(high-low)).toFixed(6)));
}

def solve(input):
    values = input['values']
    if not values:
        return []
    low, high = min(values), max(values)
    return [0 for _ in values] if high == low else [round((value - low) / (high - low), 6) for value in values]

function solve({labels,scores,threshold}) {
  let tp=0,tn=0,fp=0,fn=0;
  labels.forEach((label,i)=>{const positive=scores[i]>=threshold; if(label===1){if(positive)tp++;else fn++;}else{if(positive)fp++;else tn++;}});
  const ratio=(n,d)=>d ? Number((n/d).toFixed(6)) : 0;
  return {tp,tn,fp,fn,precision:ratio(tp,tp+fp),recall:ratio(tp,tp+fn),f1:ratio(2*tp,2*tp+fp+fn)};
}

def solve(input):
    tp = tn = fp = fn = 0
    for label, score in zip(input['labels'], input['scores']):
        positive = score >= input['threshold']
        if label == 1:
            if positive: tp += 1
            else: fn += 1
        else:
            if positive: fp += 1
            else: tn += 1
    def ratio(n, d):
        return round(n / d, 6) if d else 0
    return dict(tp=tp, tn=tn, fp=fp, fn=fn, precision=ratio(tp, tp+fp), recall=ratio(tp, tp+fn), f1=ratio(2*tp, 2*tp+fp+fn))

function solve({ranked,relevant,k}) {
  const truth=new Set(relevant),seen=new Set(),hits=[];
  for (const id of ranked.slice(0,k)) if(truth.has(id)&&!seen.has(id)){seen.add(id);hits.push(id);}
  const ratio=(n,d)=>d?Number((n/d).toFixed(6)):0;
  return {hits,precision:ratio(hits.length,k),recall:ratio(hits.length,truth.size)};
}

def solve(input):
    truth, seen, hits = set(input['relevant']), set(), []
    for doc in input['ranked'][:input['k']]:
        if doc in truth and doc not in seen:
            seen.add(doc)
            hits.append(doc)
    def ratio(n, d):
        return round(n / d, 6) if d else 0
    return dict(hits=hits, precision=ratio(len(hits), input['k']), recall=ratio(len(hits), len(truth)))

function solve({a,b}) {
  let dot=0,aa=0,bb=0;
  for(let i=0;i<a.length;i++){dot+=a[i]*b[i];aa+=a[i]*a[i];bb+=b[i]*b[i];}
  return aa===0||bb===0 ? 0 : Number((dot/Math.sqrt(aa*bb)).toFixed(6));
}

def solve(input):
    import math
    a, b = input['a'], input['b']
    dot = sum(x*y for x,y in zip(a,b))
    aa, bb = sum(x*x for x in a), sum(y*y for y in b)
    return round(dot / math.sqrt(aa*bb), 6) if aa and bb else 0

function solve({rows}) {
  const groups=new Map();
  for(const {group,value} of rows){const state=groups.get(group)||{count:0,sum:0};state.count++;state.sum+=value;groups.set(group,state);}
  return [...groups.keys()].sort().map(group=>{const {count,sum}=groups.get(group);return {group,count,mean:Number((sum/count).toFixed(6))};});
}

def solve(input):
    groups = {}
    for row in input['rows']:
        count, total = groups.get(row['group'], (0, 0))
        groups[row['group']] = (count+1, total+row['value'])
    return [dict(group=group, count=groups[group][0], mean=round(groups[group][1]/groups[group][0], 6)) for group in sorted(groups)]

function solve({rows}) {
  const latest=new Map();
  for(const row of rows) if(!latest.has(row.id)||row.at>=latest.get(row.id).at) latest.set(row.id,row);
  return [...latest.keys()].sort().map(id=>latest.get(id));
}

def solve(input):
    latest = {}
    for row in input['rows']:
        if row['id'] not in latest or row['at'] >= latest[row['id']]['at']:
            latest[row['id']] = row
    return [latest[key] for key in sorted(latest)]

function solve({labels,pairs}) {
  const index=new Map(labels.map((label,i)=>[label,i]));
  const matrix=labels.map(()=>labels.map(()=>0));let ignored=0;
  for(const pair of pairs){if(!index.has(pair.actual)||!index.has(pair.predicted)){ignored++;continue;}matrix[index.get(pair.actual)][index.get(pair.predicted)]++;}
  return {matrix,ignored};
}

def solve(input):
    index = {label: i for i, label in enumerate(input['labels'])}
    matrix = [[0 for _ in index] for _ in index]
    ignored = 0
    for pair in input['pairs']:
        if pair['actual'] not in index or pair['predicted'] not in index:
            ignored += 1
        else:
            matrix[index[pair['actual']]][index[pair['predicted']]] += 1
    return dict(matrix=matrix, ignored=ignored)

function solve({rows,testPercent}) {
  const result={train:[],test:[]},buckets=new Map();
  for(const row of rows){if(!buckets.has(row.group)){let sum=0;for(const ch of row.group)sum=(sum+ch.charCodeAt(0))%100;buckets.set(row.group,sum);}result[buckets.get(row.group)<testPercent?'test':'train'].push(row.id);}
  return result;
}

def solve(input):
    result, buckets = dict(train=[], test=[]), {}
    for row in input['rows']:
        if row['group'] not in buckets:
            buckets[row['group']] = sum(map(ord, row['group'])) % 100
        split = 'test' if buckets[row['group']] < input['testPercent'] else 'train'
        result[split].append(row['id'])
    return result

SELECT c.id AS customer_id,
       COUNT(o.id) AS order_count,
       COALESCE(SUM(o.amount_cents), 0) AS total_cents
FROM customers AS c
LEFT JOIN orders AS o ON o.customer_id = c.id
GROUP BY c.id
ORDER BY c.id;

WITH ranked AS (
  SELECT user_id, id, type,
         ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY at DESC, id DESC) AS position
  FROM events
)
SELECT user_id, id AS event_id, type
FROM ranked
WHERE position = 1
ORDER BY user_id;

SELECT day, SUM(amount_cents) AS revenue_cents
FROM orders
WHERE status = 'paid'
GROUP BY day
ORDER BY day;

SELECT t.id
FROM tickets AS t
WHERE NOT EXISTS (SELECT 1 FROM replies AS r WHERE r.ticket_id = t.id)
ORDER BY t.id;

SELECT account, id,
       SUM(delta_cents) OVER (
         PARTITION BY account ORDER BY id
         ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
       ) AS balance_cents
FROM transactions
ORDER BY account, id;

WITH ranked AS (
  SELECT id, team, name, salary_cents,
         DENSE_RANK() OVER (PARTITION BY team ORDER BY salary_cents DESC) AS salary_rank
  FROM employees
)
SELECT team, name, salary_cents, salary_rank
FROM ranked
WHERE salary_rank <= 2
ORDER BY team, salary_rank, name, id;

WITH cohorts AS (
  SELECT user_id, substr(MIN(day), 1, 7) AS cohort
  FROM activity
  GROUP BY user_id
), user_retention AS (
  SELECT c.user_id, c.cohort,
         CASE WHEN EXISTS (
           SELECT 1 FROM activity AS a
           WHERE a.user_id = c.user_id
             AND substr(a.day, 1, 7) = strftime('%Y-%m', c.cohort || '-01', '+1 month')
         ) THEN 1 ELSE 0 END AS retained
  FROM cohorts AS c
)
SELECT cohort, COUNT(*) AS users, SUM(retained) AS retained_m1
FROM user_retention
GROUP BY cohort
ORDER BY cohort;

WITH tag_counts AS (
  SELECT ticket_id, COUNT(DISTINCT tag) AS tag_count
  FROM tags GROUP BY ticket_id
), comment_counts AS (
  SELECT ticket_id, COUNT(*) AS comment_count
  FROM comments GROUP BY ticket_id
)
SELECT t.id, COALESCE(g.tag_count,0) AS tag_count,
       COALESCE(c.comment_count,0) AS comment_count
FROM tickets AS t
LEFT JOIN tag_counts AS g ON g.ticket_id=t.id
LEFT JOIN comment_counts AS c ON c.ticket_id=t.id
ORDER BY t.id;