如何将打乱后的数组还原

如果打乱后的数组是一个排列（permutation），即每个元素都唯一且恰好出现一次，那么可以通过以下方法将其还原：

1. 从左到右遍历数组，记录下每个元素的位置和值；
2. 将记录的位置和值按照位置从小到大排序；
3. 遍历排序后的记录，将每个元素放回其记录的位置。

如果打乱后的数组不是一个排列，那么通常需要更多的信息才能将其还原。例如，如果打乱前的数组是一个有序数组，那么可以通过将打乱后的数组排序来还原。如果打乱前的数组有某种特定的结构或性质，那么可以根据这些结构或性质来还原。否则可能需要更多的信息或者无法完全还原。

相关问题

int [][]arr = {{12,23,43,23,2},{2,54,76}}，打乱该数组

在Java中，要打乱一个二维数组，可以使用Fisher-Yates洗牌算法的变种来处理二维数组。以下是一个示例方法，它首先将二维数组扁平化为一维数组，然后打乱一维数组，最后再将打乱后的一维数组还原成二维数组的形式。

import java.util.Arrays;
import java.util.Random;

public class ShuffleArray {
    public static void main(String[] args) {
        int[][] arr = {{12, 23, 43, 23, 2}, {2, 54, 76}};
        shuffle2DArray(arr);
        System.out.println(Arrays.deepToString(arr)); // 打印打乱后的二维数组
    }

    public static void shuffle2DArray(int[][] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int totalSize = 0;
        for (int[] row : arr) {
            totalSize += row.length;
        }
        int[] flatArray = new int[totalSize];
        int index = 0;
        for (int[] row : arr) {
            for (int value : row) {
                flatArray[index++] = value;
            }
        }
        shuffleArray(flatArray);
        index = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = flatArray[index++];
            }
        }
    }

    public static void shuffleArray(int[] array) {
        Random rand = new Random();
        for (int i = array.length - 1; i > 0; i--) {
            int index = rand.nextInt(i + 1);
            // Simple swap
            int a = array[index];
            array[index] = array[i];
            array[i] = a;
        }
    }
}

这段代码首先将二维数组转换为一维数组，然后使用Fisher-Yates算法进行洗牌，最后将洗牌后的一维数组重新映射到二维数组结构中。注意，这种方法假设每个内部数组的长度是相同的，如果长度不同，则需要调整代码以适应不同的长度。

将喊7游戏中，游戏参与者喊“过”的次数存储在数组中。给定一个长度为N的数组，存储了打乱顺序的每个人喊“过”的次数，请把它还原成正确的顺序，即数组的第i个元素存储编号i的人喊“过”的次数。乱序数组 0,1,0，输出1,0,0 。输出java

在Java中，这个问题可以通过构建一个哈希表或者字典来解决。首先遍历输入数组，将每个人的喊“过”次数作为键（key），他们的位置作为值（value）存入哈希表。然后根据原始的位置i来获取对应的实际次数。

下面是一个简单的Java方法来实现这个过程：

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        int[] input = {0, 1, 0}; // 输入的乱序数组
        int n = input.length; // 数组长度

        // 创建一个HashMap来存储喊过次数和玩家编号的关系
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.put(i + 1, input[i]); // 玩家编号从1开始
        }

        // 根据哈希表中的值还原数组
        int[] output = new int[n];
        for (int i = 0; i < n; i++) {
            output[i] = map.get(i + 1); // 获取位置i的正确次数并放入新数组
        }

        // 输出结果
        for (int num : output) {
            System.out.print(num + " ");
        }
    }
}

运行这段代码，你会得到输出 `1 0 0`，这就是按照原数组位置重构的数组。