Is Sort Threats by Severity and Exploitability easy or hard?

The problem is generally classified as Medium difficulty. The logic is straightforward once you recognize it as a multi-field sorting task, but interview candidates must correctly implement the comparator and reason about ordering rules and complexity.

Sort Threats by Severity and Exploitability Python/Java solution

In Python, the problem is typically solved with sorted() or list.sort() using a key such as (-severity, -exploitability). In Java, developers use Arrays.sort or Collections.sort with a custom Comparator that compares severity first and exploitability second.

How to solve Sort Threats by Severity and Exploitability in O(n)?

An O(n) solution is possible only if severity and exploitability values come from small bounded ranges. In that case, counting sort or bucket sort can group threats by severity and then order them by exploitability within each bucket. The runtime becomes O(n + k), where k is the range of values.

What is the best approach for Sort Threats by Severity and Exploitability?

The best approach is sorting with a custom comparator. Compare threats by severity first and use exploitability as a tie‑breaker when severities match. Using the built‑in sorting functions available in most languages results in O(n log n) time complexity with minimal extra space.

Is Sort Threats by Severity and Exploitability asked at Google/Amazon/Meta?

Problems involving multi-key sorting appear frequently in interviews at companies like Amazon, Google, and Meta. While the exact problem title may vary, interviewers often test whether candidates can implement custom comparators and reason about sorting complexity.

What data structure is used in Sort Threats by Severity and Exploitability?

The primary data structure is an array or list containing threat records. The algorithm applies a sorting technique with a comparator that inspects two attributes for each element: severity and exploitability.

What is the time complexity of Sort Threats by Severity and Exploitability?

The optimal solution runs in O(n log n) time because it relies on comparison-based sorting. Each comparison checks severity and possibly exploitability, but that comparison still takes constant time. Space complexity is typically O(log n) due to recursion or stack usage in the sorting algorithm.

3631. Sort Threats by Severity and Exploitability - Practice Online

You are given a 2D integer array threats, where each threats[i] = [ID_i, sev_i, exp_i]

ID_i: Unique identifier of the threat.
sev_i: Indicates the severity of the threat.
exp_i: Indicates the exploitability of the threat.

The score of a threat i is defined as: score = 2 × sev_i + exp_i

Your task is to return threats sorted in descending order of score.

If multiple threats have the same score, sort them by ascending ID.

Example 1:

Input: threats = [[101,2,3],[102,3,2],[103,3,3]]

Output: [[103,3,3],[102,3,2],[101,2,3]]

Explanation:

Threat	ID	sev	exp	Score = 2 × sev + exp
`threats[0]`	101	2	3	2 × 2 + 3 = 7
`threats[1]`	102	3	2	2 × 3 + 2 = 8
`threats[2]`	103	3	3	2 × 3 + 3 = 9

Sorted Order: [[103, 3, 3], [102, 3, 2], [101, 2, 3]]

Example 2:

Input: threats = [[101,4,1],[103,1,5],[102,1,5]]

Output: [[101,4,1],[102,1,5],[103,1,5]]

Explanation:

Threat	ID	sev	exp	Score = 2 × sev + exp
`threats[0]`	101	4	1	2 × 4 + 1 = 9
`threats[1]`	103	1	5	2 × 1 + 5 = 7
`threats[2]`	102	1	5	2 × 1 + 5 = 7

threats[1] and threats[2] have same score, thus sort them by ascending ID.

Sorted Order: [[101, 4, 1], [102, 1, 5], [103, 1, 5]]

Constraints:

1 <= threats.length <= 10⁵
threats[i] == [ID_i, sev_i, exp_i]
1 <= ID_i <= 10⁶
1 <= sev_i <= 10⁹
1 <= exp_i <= 10⁹
All ID_i are unique