Java应用——关于CSDN一些简单题目利用java解决

持续更新 loading
1840.一维数组的动态和
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。

请返回 nums 的动态和。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/running-sum-of-1d-array

package HashSetClass;

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6};
        int[] result = new int[nums.length];
        result = runningSum(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] runningSum(int[] nums) {
        int[] res = new int[nums.length]; //暴力解法，时间复杂度不行，但是空间复杂度还可.
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<=i;j++){
                res[i]+=nums[j];
            }
        }
        return res;
    }
}

在此基础上，从键盘上输入数组代码如下（可改良）

package HashSetClass;

import java.util.Arrays;
import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入数组长度：");
        int ArrayList = input.nextInt();
        int[] nums = new int[ ArrayList];
        System.out.println("请输入数组");
        Scanner put = new Scanner(System.in);
        for (int i = 0; i < nums.length; i++) {
            nums[i] = put.nextInt();
        }
        int[] result = new int[nums.length];
        result = runningSum(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] runningSum(int[] nums) {
        int[] res = new int[nums.length];
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<=i;j++){
                res[i]+=nums[j];
            }
        }
        return res;
    }
}


请输入数组长度：
6
请输入数组
1
2
3
4
5
6
[1, 3, 6, 10, 15, 21]

1431.拥有最多糖果的孩子
给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

示例 1：

输入：candies = [2,3,5,1,3], extraCandies = 3
输出：[true,true,true,false,true]
解释：
孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

示例 2：
输入：candies = [4,2,1,1,2], extraCandies = 1
输出：[true,false,false,false,false]
解释：只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/kids-with-the-greatest-number-of-candies

package HashSetClass;

import java.util.ArrayList;
import java.util.List;

public class Candy {
    public static void main(String[] args) {
        List<Boolean> show = new ArrayList<>();
        int[] candies = {2,3,5,1,3};
        int extraCandies = 3;
        show = kidsWithCandies(candies,extraCandies);
        System.out.println(show);

    }
    public static List<Boolean> kidsWithCandies(int[] candies, int extraCandies){
        List<Boolean> result = new ArrayList<>();
        int Max = 0;
        for (int i = 0; i < candies.length; i++) {
            if (candies[i] > Max){
                Max = candies[i];
            }
        }
        for (int i = 0; i < candies.length; i++) {
            if (candies[i] + extraCandies >= Max)
            {
                result.add(true);
            }
            else{
                result.add(false);
            }
        }
        return result;
    }
}

1470.重新排列数组
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。

请你将数组按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排后的数组。

示例 1：

输入：nums = [2,5,1,3,4,7], n = 3
输出：[2,3,5,4,1,7]
解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shuffle-the-array

package LeetCode;

import java.util.Arrays;

public class Qs1470 {
    public static void main(String[] args) {
        int[] nums = {2,5,1,3,4,7};
        int n = (nums.length)/2;
        System.out.println(Arrays.toString(shuffle(nums,n)));
    }
    public static int[] shuffle(int[] nums, int n) {
        int[] sub1 = Arrays.copyOf(nums, n);
        int[] sub2 = Arrays.copyOfRange(nums , n, nums.length);
        int[] result = new int[nums.length];
        int j = 0;
        for (int i = 0; i < n; i++ ,j += 2) {
            result[j] = sub1[i];
            result[j + 1] = sub2[i];
        }
        return result;
    }
}

老废物了==