Subsequence Sum Threshold — Problem Statement & Solution Guide

#include <iostream>
#include <vector>
#include <algorithm>

// Returns the maximum sum of a subsequence that uses at most 50 elements
// and contains at least 10 elements greater than 200. Returns -1 if impossible.
long long subsequenceSumThreshold(const std::vector<int>& readings) {
    int n = readings.size();
    int largeCount = 0;
    for (int v : readings) if (v > 200) ++largeCount;
    if (largeCount < 10) return -1; // not enough large elements

    // Sort descending to pick the biggest elements first.
    std::vector<int> sorted = readings;
    std::sort(sorted.begin(), sorted.end(), std::greater<int>());
    int take = std::min(50, n);
    long long sum = 0;
    for (int i = 0; i < take; ++i) sum += sorted[i];
    return sum;
}

int main() {
    int n;
    std::cin >> n;
    std::vector<int> readings(n);
    for (int i = 0; i < n; ++i) std::cin >> readings[i];
    std::cout << subsequenceSumThreshold(readings) << std::endl;
    return 0;
}

import java.util.*;
import java.util.stream.*;

public class SubsequenceSumThreshold {
    // Returns the maximum sum of a subsequence that uses at most 50 elements
    // and contains at least 10 elements greater than 200. Returns -1 if impossible.
    public static long subsequenceSumThreshold(int[] readings) {
        long largeCount = Arrays.stream(readings).filter(v -> v > 200).count();
        if (largeCount < 10) return -1;
        // Sort descending
        Integer[] arr = Arrays.stream(readings).boxed().toArray(Integer[]::new);
        Arrays.sort(arr, Collections.reverseOrder());
        int take = Math.min(50, arr.length);
        long sum = 0;
        for (int i = 0; i < take; ++i) sum += arr[i];
        return sum;
    }

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

def subsequence_sum_threshold(readings):
    """Return the maximum sum of a subsequence that uses at most 50 elements
    and contains at least 10 elements greater than 200. Return -1 if impossible.
    """
    large_count = sum(1 for v in readings if v > 200)
    if large_count < 10:
        return -1
    sorted_readings = sorted(readings, reverse=True)
    take = min(50, len(sorted_readings))
    return sum(sorted_readings[:take])

if __name__ == "__main__":
    import sys
    data = sys.stdin.read().strip().split()
    if not data:
        sys.exit(0)
    n = int(data[0])
    readings = list(map(int, data[1:1 + n]))
    print(subsequence_sum_threshold(readings))

// Returns the maximum sum of a subsequence that uses at most 50 elements
// and contains at least 10 elements greater than 200. Returns -1 if impossible.
function subsequenceSumThreshold(readings) {
    const largeCount = readings.filter(v => v > 200).length;
    if (largeCount < 10) return -1;
    const sorted = readings.slice().sort((a, b) => b - a);
    const take = Math.min(50, sorted.length);
    let sum = 0;
    for (let i = 0; i < take; ++i) sum += sorted[i];
    return sum;
}

const readline = require('readline');
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
let data = [];
rl.on('line', line => data.push(line.trim()))
  .on('close', () => {
    const n = parseInt(data[0], 10);
    const readings = data.slice(1).join(' ').trim().split(/\s+/).map(Number);
    console.log(subsequenceSumThreshold(readings));
  });