自学内容网 自学内容网
自学内容网 > 正文

有 n个整数，使其前面各数顺序向后移 m 个位置，最后m个数变成最前面的 m 个数。- 多语言

🕗 发布于 2024-12-10 17:06 算法  数据结构  python  java  c语言  

目录

C 语言实现

Python 实现

Java 实现

Js 实现

题目：有 n个整数，使其前面各数顺序向后移 m 个位置，最后m个数变成最前面的 m 个数。

程序分析：无。

C 语言实现

包含了输入数组大小、数组内容、滚动偏移量

#include <stdio.h>
#include <stdlib.h>

// 函数声明
void print_arr(int array[], int n);
void move(int array[], int n, int offset);

int main() {
    int arr[20];
    int i, n, offset;

    // 输入数组大小和数组内容
    printf("Total numbers?\n");
    scanf("%d", &n);
    printf("Input %d numbers:\n", n);
    for (i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    // 输入滚动偏移量
    printf("Set your offset:\n");
    scanf("%d", &offset);
    printf("Offset is %d.\n", offset);

    // 打印滚动前数组
    printf("Array before rolling:\n");
    print_arr(arr, n);

    // 滚动数组并打印
    move(arr, n, offset);
    printf("Array after rolling:\n");
    print_arr(arr, n);

    return 0;
}

// 打印数组
void print_arr(int array[], int n) {
    int i;
    for (i = 0; i < n; ++i)
        printf("%4d", array[i]);
    printf("\n");
}

// 滚动数组
void move(int array[], int n, int offset) {
    // 处理负偏移量和大于数组大小的偏移量
    offset = offset % n; // 确保偏移量在有效范围内
    if (offset < 0) {
        offset += n; // 将负偏移量转换为正偏移量
    }

    int *p, *arr_end;
    arr_end = array + n; // 数组最后一个元素的下一个位置
    int last;

    // 滚动直到偏移量为0
    while (offset) {
        last = *(arr_end - 1); // 保存最后一个元素
        for (p = arr_end - 1; p != array; --p) // 向右滚动一位
            *p = *(p - 1);
        *array = last; // 将最后一个元素放到数组的开头
        --offset; // 减少偏移量
    }
}
  1. 输入部分：程序首先询问用户输入数组的大小和内容，然后输入滚动的偏移量。
  2. 打印数组：print_arr 函数用于打印数组的内容。
  3. 滚动数组：move 函数实现了数组的滚动操作。它首先处理负偏移量和大于数组大小的偏移量，然后通过循环将数组元素向右滚动。
  4. 主函数：在 main 函数中，调用上述函数来实现功能。

Python 实现

输入数组的大小和内容，输入滚动偏移量，并打印滚动前后的数组。

def print_arr(array):
    """打印数组"""
    for num in array:
        print(f"{num:4}", end=' ')
    print()

def move(array, offset):
    """滚动数组"""
    n = len(array)
    # 处理负偏移量和大于数组大小的偏移量
    offset = offset % n  # 确保偏移量在有效范围内
    if offset < 0:
        offset += n  # 将负偏移量转换为正偏移量

    # 向右滚动数组
    return array[-offset:] + array[:-offset]

def main():
    # 输入数组大小和数组内容
    n = int(input("Total numbers?\n"))
    arr = []
    print(f"Input {n} numbers:")
    for _ in range(n):
        arr.append(int(input()))

    # 输入滚动偏移量
    offset = int(input("Set your offset:\n"))
    print(f"Offset is {offset}.\n")

    # 打印滚动前数组
    print("Array before rolling:")
    print_arr(arr)

    # 滚动数组并打印
    arr = move(arr, offset)
    print("Array after rolling:")
    print_arr(arr)

if __name__ == "__main__":
    main()
  1. print_arr 函数：用于打印数组的内容，格式化输出每个元素。
  2. move 函数：实现了数组的滚动操作。它首先处理负偏移量和大于数组大小的偏移量，然后通过切片操作将数组元素向右滚动。
  3. main 函数：用于接收用户输入，创建数组并调用 move 函数来实现滚动功能。

Java 实现

输入数组的大小和内容，输入滚动偏移量，并打印滚动前后的数组。

import java.util.Scanner;

public class ArrayRoller {

    // 打印数组
    public static void printArr(int[] array) {
        for (int num : array) {
            System.out.printf("%4d", num);
        }
        System.out.println();
    }

    // 滚动数组
    public static int[] move(int[] array, int offset) {
        int n = array.length;
        // 处理负偏移量和大于数组大小的偏移量
        offset = offset % n; // 确保偏移量在有效范围内
        if (offset < 0) {
            offset += n; // 将负偏移量转换为正偏移量
        }

        // 创建新的数组并进行滚动
        int[] result = new int[n];
        for (int i = 0; i < n; i++) {
            result[i] = array[(i - offset + n) % n];
        }
        return result;
    }

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

        // 输入数组大小和数组内容
        System.out.println("Total numbers?");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        System.out.printf("Input %d numbers:\n", n);
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        // 输入滚动偏移量
        System.out.println("Set your offset:");
        int offset = scanner.nextInt();
        System.out.printf("Offset is %d.\n", offset);

        // 打印滚动前数组
        System.out.println("Array before rolling:");
        printArr(arr);

        // 滚动数组并打印
        arr = move(arr, offset);
        System.out.println("Array after rolling:");
        printArr(arr);

        scanner.close();
    }
}
  1. printArr 方法：用于打印数组的内容，格式化输出每个元素。
  2. move 方法：实现了数组的滚动操作。它首先处理负偏移量和大于数组大小的偏移量，然后通过计算新的索引来创建一个新的数组。
  3. main 方法：用于接收用户输入，创建数组并调用 move 方法来实现滚动功能。

Js 实现

输入数组的大小和内容，输入滚动偏移量，并打印滚动前后的数组。

function printArr(array) {
    // 打印数组
    console.log(array.join(' '));
}

function move(array, offset) {
    const n = array.length;
    // 处理负偏移量和大于数组大小的偏移量
    offset = offset % n; // 确保偏移量在有效范围内
    if (offset < 0) {
        offset += n; // 将负偏移量转换为正偏移量
    }

    // 创建新的数组并进行滚动
    const result = new Array(n);
    for (let i = 0; i < n; i++) {
        result[i] = array[(i - offset + n) % n];
    }
    return result;
}

function main() {
    const prompt = require('prompt-sync')(); // 使用 prompt-sync 库来获取用户输入

    // 输入数组大小和数组内容
    const n = parseInt(prompt("Total numbers?\n"), 10);
    const arr = [];
    console.log(`Input ${n} numbers:`);
    for (let i = 0; i < n; i++) {
        arr.push(parseInt(prompt(), 10));
    }

    // 输入滚动偏移量
    const offset = parseInt(prompt("Set your offset:\n"), 10);
    console.log(`Offset is ${offset}.\n`);

    // 打印滚动前数组
    console.log("Array before rolling:");
    printArr(arr);

    // 滚动数组并打印
    const rolledArr = move(arr, offset);
    console.log("Array after rolling:");
    printArr(rolledArr);
}

main();
  1. printArr 函数：用于打印数组的内容，使用 join 方法将数组元素连接成字符串。
  2. move 函数：实现了数组的滚动操作。它首先处理负偏移量和大于数组大小的偏移量，然后通过计算新的索引来创建一个新的数组。
  3. main 函数：用于接收用户输入，创建数组并调用 move 函数来实现滚动功能。

原文地址：https://blog.csdn.net/xinfanyyds/article/details/144357884

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024