返回目录

题目描述

给一个正整数数列 nums，一个跳数 jump，及幸存数量 left。
运算过程为：从索引0的位置开始向后跳，中间跳过 J 个数字，命中索引为 J+1 的数字，该数被敲出，并从该点起跳，以此类推，直到幸存 left 个数为止，然后返回幸存数之和。

约束：

• 0是第一个起跳点
• 起跳点和命中点之间间隔 jump 个数字，已被敲出的数字不计入在内。
• 跳到末尾时无缝从头开始（循环查找），并可以多次循环。
• 若起始时 left > len(nums) 则无需跳数处理过程。

方法设计：

 * @param nums 正整数数列，长度范围 [1, 10000]
 * @param jump 跳数，范围 [1, 10000]
 * @param left 幸存数量，范围 [0, 10000]
 * @return 幸存数之和
 int sumOfLeft(int[] nums, int jump, int left){
   
 }

输入描述

第一行输入正整数数列

第二行输入跳数

第三行输入幸存数量

输出描述

输出幸存数之和

示例：

解题思路

本题考试时为Lettoce模式,无需自己获取输入数据。

本题主要是模拟操作，按照每次跳数的位置，从数列中删掉跳到的数组，直到剩余幸存数量的数字。

Python算法源码

def sumOfLeft(nums, jump, left):
    # 如果幸存数量大于等于数组长度，则直接返回数组元素之和
    if left >= len(nums):
        return sum(nums)

    # 使用列表存储数组元素，方便删除操作
    lst = nums[:]

    # 初始化起跳点索引为0
    index = 0
    # 当列表大小大于幸存数量时，执行删除操作
    while len(lst) > left:
        # 计算下一个要删除元素的索引
        index = (index + jump + 1) % len(lst)
        # 删除计算出的索引处的元素
        del lst[index]
        # 由于删除元素后，列表会缩短，下一个起跳点应当向前移动一位
        index -= 1

    # 计算并返回剩余元素之和
    return sum(lst)

if __name__ == "__main__":
    # 读取一行输入，按逗号分割，转换为整数列表
    nums = list(map(int, input().split(",")))
    # 读取跳数
    jump = int(input())
    # 读取幸存数量
    left = int(input())

    # 输出幸存数之和
    print(sumOfLeft(nums, jump, left))

C语言算法源码

#include <stdio.h>

int sumOfLeft(int nums[], int size, int jump, int left) {
    // 如果幸存数量大于等于数组长度，则直接返回数组元素之和
    if (left >= size) {
        int sum = 0;
        for (int i = 0; i < size; ++i) {
            sum += nums[i];
        }
        return sum;
    }

    // 使用数组存储数组元素，方便删除操作
    int lst[size];
    for (int i = 0; i < size; ++i) {
        lst[i] = nums[i];
    }

    // 初始化起跳点索引为0
    int index = 0;
    // 当列表大小大于幸存数量时，执行删除操作
    while (size > left) {
        // 计算下一个要删除元素的索引
        index = (index + jump + 1) % size;
        // 删除计算出的索引处的元素
        for (int i = index; i < size - 1; ++i) {
            lst[i] = lst[i + 1];
        }
        // 由于删除元素后，列表会缩短，下一个起跳点应当向前移动一位
        --size;
        --index;
    }

    // 计算并返回剩余元素之和
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += lst[i];
    }
    return sum;
}

int main() {
    // 读取数组元素，按逗号分割，转换为整数数组
    int nums[100];
    char comma;
    int size = 0;
    do {
        scanf("%d%c", &nums[size], &comma);
        size++;
    } while (comma == ',');

    // 读取跳数
    int jump;
    scanf("%d", &jump);
    // 读取幸存数量
    int left;
    scanf("%d", &left);

    // 输出幸存数之和
    printf("%d\n", sumOfLeft(nums, size, jump, left));

    return 0;
}

Java算法源码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取一行输入，按逗号分割，转换为整数数组
        int[] nums = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
        // 读取跳数
        int jump = Integer.parseInt(sc.nextLine());
        // 读取幸存数量
        int left = Integer.parseInt(sc.nextLine());

        // 输出幸存数之和
        System.out.println(sumOfLeft(nums, jump, left));
    }

    public static int sumOfLeft(int[] nums, int jump, int left) {
        // 如果幸存数量大于等于数组长度，则直接返回数组元素之和
        if (left >= nums.length) {
            return Arrays.stream(nums).sum();
        }

        // 使用列表存储数组元素，方便删除操作
        List<Integer> list = new ArrayList<>();
        for (int num : nums) {
            list.add(num);
        }

        // 初始化起跳点索引为0
        int index = 0;
        // 当列表大小大于幸存数量时，执行删除操作
        while (list.size() > left) {
            // 计算下一个要删除元素的索引
            index = (index + jump + 1) % list.size();
            // 删除计算出的索引处的元素
            list.remove(index);
            // 由于删除元素后，列表会缩短，下一个起跳点应当向前移动一位
            index = index - 1;
        }

        // 计算并返回剩余元素之和
        return list.stream().mapToInt(Integer::intValue).sum();
    }
}