## 方法一：纯暴力破解
![image-20230317113420398](https://img.slcp.top/image-20230317113420398.png)
### 解题思路
- 排序，将`nums`进行排序，得到从小到大的数组。根据题意，我们不需要考虑满足条件的元素集合，只要考虑满足条件的数量
- 遍历，将`queries`进行遍历并依次比较

> 复杂度分析
时间复杂度: `O(nq)`，`n`为`nums`的数组长度，`q`为`queries`的数组长度
空间复杂度: `O(q)`

### 代码
~~~java
class Solution {
    public static int[] answerQueries(int[] nums, int[] queries) {
        Arrays.sort(nums);
        int[] arr = new int[queries.length];
        for(int i = 0;i < queries.length; i++) {
            int sum = 0;
            int num = 0;
            for(int j = 0;j < nums.length; j++) {
                sum += nums[j];
                if(sum <= queries[i]) {
                    num++;
                }else {
                    break;
                }
            }
            arr[i] = num;
        }
        return arr;
    }
}
~~~

## 方法二：非纯暴力破解
![image-20230317131605806](https://img.slcp.top/image-20230317131605806.png)

### 解题思路
- 复用数组，求前缀和
- 遍历

> 复杂度分析
时间复杂度: `O(log(nq))`，`n`为`nums`的数组长度，`q`为`queries`的数组长度
空间复杂度: `O(q)`

### 代码
~~~java
class Solution {
    public  int[] answerQueries(int[] nums, int[] queries) {
        int[] arr = new int[queries.length];
        int nl = nums.length;
        Arrays.sort(nums);
        for (int i = 1; i < nl; i++) {
            nums[i]=nums[i-1]+nums[i];
        }

for (int i = 0; i <queries.length ; i++) {
            if (queries[i]<nums[0]){
                arr[i]=0;
            }else if (queries[i]>=nums[nl-1]){
                arr[i]=nl;
            }else {
                for (int j = 0; j < nums.length; j++) {
                    if(queries[i]<nums[j]){
                        arr[i]=j;
                        break;
                    }
                }
            }
        }
        return arr;
    }
}
~~~

2389. 和有限的最长子序列

目录