Binary Heap — Practice Tasks¶

All tasks must be solved in Go, Java, and Python. Each task ships with starter code in all three languages. Fill in the heap logic and validate against the evaluation criteria.

Beginner Tasks (5)¶

Task 1 — Implement push/pop for an int min-heap from scratch¶

Problem. Build a min-heap backed by a dynamic array. Implement push(x) and pop() without using any standard library heap utilities. After every operation, the array must satisfy the min-heap property: for every index i > 0, a[(i-1)/2] <= a[i].

Input / Output spec. - A sequence of operations: push x or pop. - For each pop, print the removed minimum on its own line.

Constraints. - 1 <= total operations <= 10^6. - Values fit in a signed 32-bit integer. - Time per operation: O(log n).

Hint. Sift-up on insertion, sift-down on removal. Swap with the last element before shrinking the array.

Starter — Go.

package main

import (
    "bufio"
    "fmt"
    "os"
)

type MinHeap struct {
    data []int
}

func (h *MinHeap) Push(x int) {
    // TODO: append, then sift-up from len-1
}

func (h *MinHeap) Pop() int {
    // TODO: swap root with last, shrink, sift-down from 0, return removed
    return 0
}

func (h *MinHeap) siftUp(i int)   { /* TODO */ }
func (h *MinHeap) siftDown(i int) { /* TODO */ }

func main() {
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    h := &MinHeap{}
    var op string
    for {
        if _, err := fmt.Fscan(in, &op); err != nil {
            return
        }
        switch op {
        case "push":
            var x int
            fmt.Fscan(in, &x)
            h.Push(x)
        case "pop":
            fmt.Fprintln(out, h.Pop())
        }
    }
}

Starter — Java.

import java.util.*;
import java.io.*;

public class Task1 {
    static int[] data = new int[16];
    static int size = 0;

    static void push(int x) {
        // TODO: grow if needed, place at index size, sift-up
    }

    static int pop() {
        // TODO: take root, move last to root, sift-down, return removed
        return 0;
    }

    static void siftUp(int i)   { /* TODO */ }
    static void siftDown(int i) { /* TODO */ }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = br.readLine()) != null) {
            StringTokenizer st = new StringTokenizer(line);
            String op = st.nextToken();
            if (op.equals("push")) push(Integer.parseInt(st.nextToken()));
            else sb.append(pop()).append('\n');
        }
        System.out.print(sb);
    }
}

Starter — Python.

import sys

class MinHeap:
    def __init__(self):
        self.data = []

    def push(self, x: int) -> None:
        # TODO: append, sift-up
        pass

    def pop(self) -> int:
        # TODO: swap root with last, pop last, sift-down, return removed
        return 0

    def _sift_up(self, i: int) -> None:   ...
    def _sift_down(self, i: int) -> None: ...


def main() -> None:
    h = MinHeap()
    out = []
    for line in sys.stdin:
        parts = line.split()
        if not parts:
            continue
        if parts[0] == "push":
            h.push(int(parts[1]))
        else:
            out.append(str(h.pop()))
    sys.stdout.write("\n".join(out))


if __name__ == "__main__":
    main()

Evaluation criteria. - push and pop run in O(log n). - No standard library heap used. - The heap property holds after every operation (assert it in tests). - Handles pop from empty as a defined error (panic, exception, sentinel — pick one and document it).

Task 2 — Convert a min-heap to a max-heap in place¶

Problem. You are given an array that already satisfies the min-heap property. Rebuild it in place so that it satisfies the max-heap property. You may not allocate a new array of size n.

Input / Output spec. - Input: integer n, then n integers forming a valid min-heap. - Output: the array rearranged as a valid max-heap, space-separated.

Constraints. - 1 <= n <= 10^6. - Extra memory: O(1) beyond the input array. - Total time: O(n).

Hint. Run Floyd's heapify with a max-heap sift-down from n/2 - 1 down to 0. The min-heap structure is irrelevant — heapify treats the array as raw.

Starter — Go.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func minToMax(a []int) {
    // TODO: for i := len(a)/2 - 1; i >= 0; i-- { siftDownMax(a, i, len(a)) }
}

func siftDownMax(a []int, i, n int) { /* TODO */ }

func main() {
    in := bufio.NewReader(os.Stdin)
    var n int
    fmt.Fscan(in, &n)
    a := make([]int, n)
    for i := range a {
        fmt.Fscan(in, &a[i])
    }
    minToMax(a)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    for i, v := range a {
        if i > 0 {
            out.WriteByte(' ')
        }
        fmt.Fprint(out, v)
    }
}

Starter — Java.

import java.util.*;

public class Task2 {
    static void minToMax(int[] a) {
        // TODO: heapify with max sift-down, last non-leaf to root
    }

    static void siftDownMax(int[] a, int i, int n) { /* TODO */ }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();
        minToMax(a);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            if (i > 0) sb.append(' ');
            sb.append(a[i]);
        }
        System.out.println(sb);
    }
}

Starter — Python.

import sys
from typing import List


def min_to_max(a: List[int]) -> None:
    n = len(a)
    # TODO: for i in range(n // 2 - 1, -1, -1): _sift_down_max(a, i, n)


def _sift_down_max(a: List[int], i: int, n: int) -> None:
    # TODO
    pass


def main() -> None:
    data = sys.stdin.read().split()
    n = int(data[0])
    a = list(map(int, data[1:1 + n]))
    min_to_max(a)
    sys.stdout.write(" ".join(map(str, a)))


if __name__ == "__main__":
    main()

Evaluation criteria. - Total runtime is O(n), not O(n log n). - No auxiliary array of size n. - Final array passes a max-heap validator.

Task 3 — Verify if a given array is a valid heap¶

Problem. Given an array and a flag kind ("min" or "max"), report whether it satisfies the corresponding binary-heap property under array-of-tree indexing.

Input / Output spec. - Input: kind, then n, then n integers. - Output: true or false.

Constraints. - 1 <= n <= 10^6. - Single pass, O(n) time, O(1) extra memory.

Hint. Check children of indices 0..n/2 - 1 only. Children are at 2i+1 and 2i+2 if they exist.

Starter — Go.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func isHeap(a []int, kind string) bool {
    // TODO: loop i = 0..n/2 - 1, compare with present children
    return false
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var kind string
    var n int
    fmt.Fscan(in, &kind, &n)
    a := make([]int, n)
    for i := range a {
        fmt.Fscan(in, &a[i])
    }
    fmt.Println(isHeap(a, kind))
}

Starter — Java.

import java.util.*;

public class Task3 {
    static boolean isHeap(int[] a, String kind) {
        // TODO
        return false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String kind = sc.next();
        int n = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();
        System.out.println(isHeap(a, kind));
    }
}

Starter — Python.

import sys
from typing import List


def is_heap(a: List[int], kind: str) -> bool:
    # TODO
    return False


def main() -> None:
    data = sys.stdin.read().split()
    kind = data[0]
    n = int(data[1])
    a = list(map(int, data[2:2 + n]))
    print(str(is_heap(a, kind)).lower())


if __name__ == "__main__":
    main()

Evaluation criteria. - Correctly handles n = 0 and n = 1 (trivially a heap). - Single linear pass. - Returns at the first violation — no full scan when a violation is found early.

Task 4 — Replace the root with a new value and restore heap order¶

Problem. Implement a replaceRoot(x) operation on a min-heap: overwrite the value at index 0 with x, then restore the heap property. Compare it against the naive pop + push baseline. Both should yield the same final array, but replaceRoot performs only one sift-down.

Input / Output spec. - Input: n, the heap array, then m and m replacement values. - Output: the heap state after all replacements, space-separated.

Constraints. - 1 <= n, m <= 10^5. - Each replaceRoot must run in a single O(log n) sift-down.

Hint. No sift-up is needed — the new root only ever moves downward in the tree.

Starter — Go.

package main

import (
    "bufio"
    "fmt"
    "os"
)

type MinHeap struct{ data []int }

func (h *MinHeap) ReplaceRoot(x int) {
    if len(h.data) == 0 {
        h.data = append(h.data, x)
        return
    }
    h.data[0] = x
    // TODO: sift-down from 0
}

func (h *MinHeap) siftDown(i int) { /* TODO */ }

func main() {
    in := bufio.NewReader(os.Stdin)
    var n int
    fmt.Fscan(in, &n)
    h := &MinHeap{data: make([]int, n)}
    for i := range h.data {
        fmt.Fscan(in, &h.data[i])
    }
    var m int
    fmt.Fscan(in, &m)
    for ; m > 0; m-- {
        var x int
        fmt.Fscan(in, &x)
        h.ReplaceRoot(x)
    }
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    for i, v := range h.data {
        if i > 0 {
            out.WriteByte(' ')
        }
        fmt.Fprint(out, v)
    }
}

Starter — Java.

import java.util.*;

public class Task4 {
    static int[] data;
    static int size;

    static void replaceRoot(int x) {
        if (size == 0) { data[size++] = x; return; }
        data[0] = x;
        // TODO: sift-down
    }

    static void siftDown(int i) { /* TODO */ }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        data = new int[n + 1];
        for (int i = 0; i < n; i++) data[i] = sc.nextInt();
        size = n;
        int m = sc.nextInt();
        for (int i = 0; i < m; i++) replaceRoot(sc.nextInt());
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < size; i++) {
            if (i > 0) sb.append(' ');
            sb.append(data[i]);
        }
        System.out.println(sb);
    }
}

Starter — Python.

import sys
from typing import List


class MinHeap:
    def __init__(self, data: List[int]):
        self.data = data

    def replace_root(self, x: int) -> None:
        if not self.data:
            self.data.append(x)
            return
        self.data[0] = x
        # TODO: sift-down from 0

    def _sift_down(self, i: int) -> None:
        # TODO
        pass


def main() -> None:
    tokens = sys.stdin.read().split()
    p = 0
    n = int(tokens[p]); p += 1
    data = list(map(int, tokens[p:p + n])); p += n
    m = int(tokens[p]); p += 1
    h = MinHeap(data)
    for x in map(int, tokens[p:p + m]):
        h.replace_root(x)
    sys.stdout.write(" ".join(map(str, h.data)))


if __name__ == "__main__":
    main()

Evaluation criteria. - Exactly one sift-down per replacement, no separate sift-up. - Verified against a reference pop + push implementation. - Constant extra memory.

Task 5 — k-th smallest element via a max-heap of size k¶

Problem. Given an unsorted array a and an integer k, return the k-th smallest element. You must use a bounded max-heap of size at most k.

Input / Output spec. - Input: n, k, then n integers. - Output: the k-th smallest value.

Constraints. - 1 <= k <= n <= 10^6. - Time: O(n log k). - Memory: O(k).

Hint. Push the first k elements into a max-heap. For every later element x, if x < heap.peek() then replace the root with x and sift down. The root at the end is the k-th smallest.

Starter — Go.

package main

import (
    "bufio"
    "container/heap"
    "fmt"
    "os"
)

type maxHeap []int

func (h maxHeap) Len() int            { return len(h) }
func (h maxHeap) Less(i, j int) bool  { return h[i] > h[j] }
func (h maxHeap) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *maxHeap) Push(x any)         { *h = append(*h, x.(int)) }
func (h *maxHeap) Pop() any           { n := len(*h); v := (*h)[n-1]; *h = (*h)[:n-1]; return v }

func kthSmallest(a []int, k int) int {
    // TODO: maintain bounded max-heap of size k
    return 0
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var n, k int
    fmt.Fscan(in, &n, &k)
    a := make([]int, n)
    for i := range a {
        fmt.Fscan(in, &a[i])
    }
    fmt.Println(kthSmallest(a, k))
    _ = heap.Init
}

Starter — Java.

import java.util.*;

public class Task5 {
    static int kthSmallest(int[] a, int k) {
        // TODO: PriorityQueue with Comparator.reverseOrder()
        return 0;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();
        System.out.println(kthSmallest(a, k));
    }
}

Starter — Python.

import heapq
import sys
from typing import List


def kth_smallest(a: List[int], k: int) -> int:
    # TODO: bounded max-heap using negated values
    return 0


def main() -> None:
    data = sys.stdin.read().split()
    n, k = int(data[0]), int(data[1])
    a = list(map(int, data[2:2 + n]))
    print(kth_smallest(a, k))


if __name__ == "__main__":
    main()

Evaluation criteria. - Memory usage proportional to k, not n. - Correct for k = 1 (the minimum) and k = n (the maximum). - Beats a full O(n log n) sort on benchmarks for k << n.

Intermediate Tasks (5)¶

Task 6 — Merge K sorted arrays using a min-heap of pointers¶

Problem. Given K sorted ascending arrays, merge them into one sorted array. Use a min-heap whose entries are (value, arrayIndex, indexInArray) so the heap always exposes the next global minimum.

Input / Output spec. - Input: K, then for each i the length n_i followed by the n_i sorted values. - Output: the merged sorted sequence, space-separated.

Constraints. - 1 <= K <= 10^4, total elements N <= 10^6. - Time: O(N log K). - Memory beyond input/output: O(K).

Hint. Seed the heap with the first element of each array. On every pop, push the next element from the same array (if any).

Starter — Go.

package main

import (
    "bufio"
    "container/heap"
    "fmt"
    "os"
)

type node struct{ val, arr, idx int }
type minH []node

func (h minH) Len() int            { return len(h) }
func (h minH) Less(i, j int) bool  { return h[i].val < h[j].val }
func (h minH) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *minH) Push(x any)         { *h = append(*h, x.(node)) }
func (h *minH) Pop() any           { n := len(*h); v := (*h)[n-1]; *h = (*h)[:n-1]; return v }

func mergeK(arrs [][]int) []int {
    // TODO: heap-of-pointers merge
    return nil
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var k int
    fmt.Fscan(in, &k)
    arrs := make([][]int, k)
    for i := 0; i < k; i++ {
        var n int
        fmt.Fscan(in, &n)
        arrs[i] = make([]int, n)
        for j := range arrs[i] {
            fmt.Fscan(in, &arrs[i][j])
        }
    }
    res := mergeK(arrs)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    for i, v := range res {
        if i > 0 {
            out.WriteByte(' ')
        }
        fmt.Fprint(out, v)
    }
    _ = heap.Init
}

Starter — Java.

import java.util.*;

public class Task6 {
    record Node(int val, int arr, int idx) {}

    static int[] mergeK(int[][] arrs) {
        // TODO: PriorityQueue<Node> by val
        return new int[0];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        int[][] arrs = new int[k][];
        for (int i = 0; i < k; i++) {
            int n = sc.nextInt();
            arrs[i] = new int[n];
            for (int j = 0; j < n; j++) arrs[i][j] = sc.nextInt();
        }
        int[] res = mergeK(arrs);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            if (i > 0) sb.append(' ');
            sb.append(res[i]);
        }
        System.out.println(sb);
    }
}

Starter — Python.

import heapq
import sys
from typing import List


def merge_k(arrs: List[List[int]]) -> List[int]:
    # TODO: heap entries are (value, array_idx, in_array_idx)
    return []


def main() -> None:
    data = iter(sys.stdin.read().split())
    k = int(next(data))
    arrs: List[List[int]] = []
    for _ in range(k):
        n = int(next(data))
        arrs.append([int(next(data)) for _ in range(n)])
    sys.stdout.write(" ".join(map(str, merge_k(arrs))))


if __name__ == "__main__":
    main()

Evaluation criteria. - Heap size never exceeds K. - Stable on duplicate values (use the array index as the tiebreaker). - Correct on K = 1 and on arrays of mixed lengths.

Task 7 — Sort an almost-sorted array (each element at most k away)¶

Problem. Given an array where every element is at most k index positions away from its sorted position, sort it. Use a min-heap of size k + 1.

Input / Output spec. - Input: n, k, then n integers. - Output: sorted array, space-separated.

Constraints. - 0 <= k < n <= 10^6. - Time: O(n log k). - Memory beyond input: O(k).

Hint. Push the first k + 1 elements into the heap. Then for every subsequent element, pop the minimum and push the new element.

Starter — Go.

package main

import (
    "bufio"
    "container/heap"
    "fmt"
    "os"
)

type minIntH []int

func (h minIntH) Len() int            { return len(h) }
func (h minIntH) Less(i, j int) bool  { return h[i] < h[j] }
func (h minIntH) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *minIntH) Push(x any)         { *h = append(*h, x.(int)) }
func (h *minIntH) Pop() any           { n := len(*h); v := (*h)[n-1]; *h = (*h)[:n-1]; return v }

func sortK(a []int, k int) []int {
    // TODO
    return nil
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var n, k int
    fmt.Fscan(in, &n, &k)
    a := make([]int, n)
    for i := range a {
        fmt.Fscan(in, &a[i])
    }
    res := sortK(a, k)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    for i, v := range res {
        if i > 0 {
            out.WriteByte(' ')
        }
        fmt.Fprint(out, v)
    }
    _ = heap.Init
}

Starter — Java.

import java.util.*;

public class Task7 {
    static int[] sortK(int[] a, int k) {
        // TODO
        return new int[0];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();
        int[] res = sortK(a, k);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            if (i > 0) sb.append(' ');
            sb.append(res[i]);
        }
        System.out.println(sb);
    }
}

Starter — Python.

import heapq
import sys
from typing import List


def sort_k(a: List[int], k: int) -> List[int]:
    # TODO
    return []


def main() -> None:
    data = sys.stdin.read().split()
    n, k = int(data[0]), int(data[1])
    a = list(map(int, data[2:2 + n]))
    sys.stdout.write(" ".join(map(str, sort_k(a, k))))


if __name__ == "__main__":
    main()

Evaluation criteria. - Output is fully sorted. - Heap size stays at most k + 1. - Works correctly for k = 0 (already sorted) and k = n - 1 (effectively unsorted).

Task 8 — Connect ropes for minimum cost¶

Problem. You have n ropes of given lengths. Connecting two ropes of length x and y costs x + y and yields one rope of length x + y. Connect them all into a single rope so that the total cost is minimized. Return that cost.

Input / Output spec. - Input: n, then n rope lengths. - Output: total minimum cost.

Constraints. - 1 <= n <= 10^6. - Lengths fit in 32 bits, but the total cost can need 64-bit. - Time: O(n log n).

Hint. Use a min-heap. Repeatedly pop the two smallest ropes, push their sum, accumulate the sum into the total.

Starter — Go.

package main

import (
    "bufio"
    "container/heap"
    "fmt"
    "os"
)

type minH64 []int64

func (h minH64) Len() int            { return len(h) }
func (h minH64) Less(i, j int) bool  { return h[i] < h[j] }
func (h minH64) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *minH64) Push(x any)         { *h = append(*h, x.(int64)) }
func (h *minH64) Pop() any           { n := len(*h); v := (*h)[n-1]; *h = (*h)[:n-1]; return v }

func connectRopes(lengths []int64) int64 {
    // TODO
    return 0
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var n int
    fmt.Fscan(in, &n)
    lengths := make([]int64, n)
    for i := range lengths {
        fmt.Fscan(in, &lengths[i])
    }
    fmt.Println(connectRopes(lengths))
    _ = heap.Init
}

Starter — Java.

import java.util.*;

public class Task8 {
    static long connectRopes(long[] lengths) {
        // TODO: PriorityQueue<Long>
        return 0L;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long[] lengths = new long[n];
        for (int i = 0; i < n; i++) lengths[i] = sc.nextLong();
        System.out.println(connectRopes(lengths));
    }
}

Starter — Python.

import heapq
import sys
from typing import List


def connect_ropes(lengths: List[int]) -> int:
    # TODO
    return 0


def main() -> None:
    data = sys.stdin.read().split()
    n = int(data[0])
    lengths = list(map(int, data[1:1 + n]))
    print(connect_ropes(lengths))


if __name__ == "__main__":
    main()

Evaluation criteria. - Returns 0 for n <= 1. - Uses 64-bit accumulation to avoid overflow. - Optimal cost matches the Huffman-style lower bound.

Task 9 — Top-k frequent elements¶

Problem. Given an array a and an integer k, return the k values with the highest frequencies. Order among the returned k is unspecified, but the set must be correct.

Input / Output spec. - Input: n, k, then n integers. - Output: k distinct values, space-separated.

Constraints. - 1 <= k <= |distinct(a)| <= n <= 10^6. - Time: O(n + d log k) where d = |distinct(a)|.

Hint. Count frequencies in a hash map, then push (count, value) pairs into a min-heap bounded at size k. Whatever remains is the top-k by frequency.

Starter — Go.

package main

import (
    "bufio"
    "container/heap"
    "fmt"
    "os"
)

type freq struct{ count, val int }
type minFreq []freq

func (h minFreq) Len() int            { return len(h) }
func (h minFreq) Less(i, j int) bool  { return h[i].count < h[j].count }
func (h minFreq) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *minFreq) Push(x any)         { *h = append(*h, x.(freq)) }
func (h *minFreq) Pop() any           { n := len(*h); v := (*h)[n-1]; *h = (*h)[:n-1]; return v }

func topK(a []int, k int) []int {
    // TODO
    return nil
}

func main() {
    in := bufio.NewReader(os.Stdin)
    var n, k int
    fmt.Fscan(in, &n, &k)
    a := make([]int, n)
    for i := range a {
        fmt.Fscan(in, &a[i])
    }
    res := topK(a, k)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    for i, v := range res {
        if i > 0 {
            out.WriteByte(' ')
        }
        fmt.Fprint(out, v)
    }
    _ = heap.Init
}

Starter — Java.

import java.util.*;

public class Task9 {
    static int[] topK(int[] a, int k) {
        // TODO: HashMap counts, PriorityQueue<int[]> min-by-count, cap at k
        return new int[0];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();
        int[] res = topK(a, k);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            if (i > 0) sb.append(' ');
            sb.append(res[i]);
        }
        System.out.println(sb);
    }
}

Starter — Python.

import heapq
import sys
from collections import Counter
from typing import List


def top_k(a: List[int], k: int) -> List[int]:
    # TODO: Counter + bounded heap of (count, value)
    return []


def main() -> None:
    data = sys.stdin.read().split()
    n, k = int(data[0]), int(data[1])
    a = list(map(int, data[2:2 + n]))
    sys.stdout.write(" ".join(map(str, top_k(a, k))))


if __name__ == "__main__":
    main()