Most capital from at most k projects

import heapq

def ipo(k, w, profits, capital):
    projects = sorted(zip(capital, profits))      # unlock order: cheapest requirement first
    heap = []                                     # max-heap of affordable profits (negated)
    j = 0
    for _ in range(k):
        while j < len(projects) and projects[j][0] <= w:
            heapq.heappush(heap, -projects[j][1])
            j += 1
        if not heap:
            break                                 # nothing affordable; capital cannot grow
        w -= heapq.heappop(heap)                  # take the most profitable
    return w

#include <vector>
#include <queue>
#include <algorithm>
#include <utility>

long long solve(int k, long long w, const std::vector<int>& profits, const std::vector<int>& capital) {
    std::vector<std::pair<int, int>> projects;             // (capital needed, profit)
    for (size_t i = 0; i < profits.size(); ++i) projects.push_back({capital[i], profits[i]});
    std::sort(projects.begin(), projects.end());
    std::priority_queue<int> heap;                         // max-heap of affordable profits
    size_t j = 0;
    for (int round = 0; round < k; ++round) {
        while (j < projects.size() && projects[j].first <= w) heap.push(projects[j++].second);
        if (heap.empty()) break;                           // nothing affordable
        w += heap.top(); heap.pop();
    }
    return w;
}

class Solution {
    public long ipo(int k, long w, int[] profits, int[] capital) {
        int n = profits.length;
        Integer[] order = new Integer[n];
        for (int i = 0; i < n; i++) order[i] = i;
        java.util.Arrays.sort(order, (a, b) -> Integer.compare(capital[a], capital[b]));
        java.util.PriorityQueue<Integer> heap = new java.util.PriorityQueue<>(java.util.Collections.reverseOrder());
        int j = 0;
        for (int round = 0; round < k; round++) {
            while (j < n && capital[order[j]] <= w) heap.add(profits[order[j++]]);
            if (heap.isEmpty()) break;                     // nothing affordable
            w += heap.poll();                              // the most profitable affordable project
        }
        return w;
    }
}

function ipo(k, w, profits, capital) {
  const order = profits.map((_, i) => i).sort((a, b) => capital[a] - capital[b]);
  const h = [];                                  // binary max-heap of affordable profits
  const push = x => {
    h.push(x); let i = h.length - 1;
    while (i > 0) { const p = (i - 1) >> 1; if (h[p] >= h[i]) break; [h[p], h[i]] = [h[i], h[p]]; i = p; }
  };
  const pop = () => {
    const top = h[0], last = h.pop();
    if (h.length) {
      h[0] = last; let i = 0;
      for (;;) {
        const l = 2 * i + 1, r = l + 1; let m = i;
        if (l < h.length && h[l] > h[m]) m = l;
        if (r < h.length && h[r] > h[m]) m = r;
        if (m === i) break;
        [h[m], h[i]] = [h[i], h[m]]; i = m;
      }
    }
    return top;
  };
  let j = 0;
  for (let round = 0; round < k; round++) {
    while (j < order.length && capital[order[j]] <= w) push(profits[order[j++]]);
    if (!h.length) break;                        // nothing affordable
    w += pop();                                  // the most profitable affordable project
  }
  return w;
}

use std::collections::BinaryHeap;

fn solve(k: usize, w: i64, profits: &[i64], capital: &[i64]) -> i64 {
    let mut projects: Vec<(i64, i64)> = capital.iter().cloned().zip(profits.iter().cloned()).collect();
    projects.sort();                                       // by capital needed
    let mut heap = BinaryHeap::new();                      // max-heap of affordable profits
    let (mut w, mut j) = (w, 0usize);
    for _ in 0..k {
        while j < projects.len() && projects[j].0 <= w {
            heap.push(projects[j].1);
            j += 1;
        }
        match heap.pop() {
            Some(best) => w += best,
            None => break,                                 // nothing affordable
        }
    }
    w
}

import Data.List (sortOn)
import qualified Data.Map.Strict as M

-- Projects sorted by capital needed; a Map from profit to count is the max-heap.
solve :: Int -> Int -> [Int] -> [Int] -> Int
solve k w profits capital = go k w (sortOn fst (zip capital profits)) M.empty
  where
    go 0 cash _ _ = cash
    go left cash todo heap =
      let (ready, later) = span ((<= cash) . fst) todo
          heap' = foldr (\(_, p) -> M.insertWith (+) p 1) heap ready
      in if M.null heap'
           then cash                                       -- nothing affordable
           else let (best, heap'') = popMax heap'
                in go (left - 1) (cash + best) later heap''
    popMax m = case M.findMax m of
      (v, 1) -> (v, M.delete v m)
      (v, c) -> (v, M.insert v (c - 1) m)