Java 用于检查数组（具有9个位置）是否具有整数1到9的算法，与它们的排序方式无关_Java_Arrays_Algorithm

Java 用于检查数组（具有9个位置）是否具有整数1到9的算法，与它们的排序方式无关

java arrays algorithm

Java 用于检查数组（具有9个位置）是否具有整数1到9的算法，与它们的排序方式无关,java,arrays,algorithm,Java,Arrays,Algorithm,你们认为一个好的算法是检查（返回true）一个大小为9的数组是否有数字1到9，不管它们如何排序我正在考虑创建一个已经用整数1到9初始化的数组V，然后将第一个数组的第一个元素与V的每个元素进行比较，如果匹配，将V的元素替换为-1，然后当我们完成时，我们应该检查是否有一个数组V充满了-1。你们觉得我的想法怎么样谢谢在函数中创建一个位集使用该值作为位集中的位置，对传入的向量进行迭代如果该位置已设置，则为dup，因此返回false 如果在末尾，并且位集的长度为9，则返回true 在函数中创建一

你们认为一个好的算法是检查（返回true）一个大小为9的数组是否有数字1到9，不管它们如何排序

我正在考虑创建一个已经用整数1到9初始化的数组V，然后将第一个数组的第一个元素与V的每个元素进行比较，如果匹配，将V的元素替换为-1，然后当我们完成时，我们应该检查是否有一个数组V充满了-1。你们觉得我的想法怎么样

谢谢

在函数中创建一个位集

使用该值作为位集中的位置，对传入的向量进行迭代

如果该位置已设置，则为dup，因此返回false

如果在末尾，并且位集的长度为9，则返回true

在函数中创建一个位集

使用该值作为位集中的位置，对传入的向量进行迭代

如果该位置已设置，则为dup，因此返回false

如果在末尾，并且位集的长度为9，则返回true

您可以使用一个数组，该数组由您希望看到的值索引。每个元素最初都是0，如果i是输入的元素，则将[i]（如果未设置）设置为1，并递增一个计数器。最后，计数器必须为9。

您可以使用一个数组，该数组按您希望看到的值进行索引。每个元素最初都是0，如果i是输入的元素，则将[i]（如果未设置）设置为1，并递增一个计数器。最后，计数器必须为9。

将所有数组元素相乘。如果它们等于

1*2*3*4*5*6*7*8*9

，那么就很好。

将所有数组元素相乘。如果它们等于

1*2*3*4*5*6*7*8*9

，那么就可以了。

对它们进行排序，然后检查每个数字是否=索引+1。第一次失败时返回false，否则返回true

它必须是数组吗？如果使用集合，则可以使用

set1.containsAll（set2）
它必须是数组吗？如果使用集合，则可以使用set1.containsAll（set2）
只需使用第二个数组作为“检查列表”即可查看缺少的条目（请注意，这是伪代码）：
只需使用第二个数组作为“检查列表”即可查看缺少的条目（请注意，这是伪代码）：
以下是一种方法：
public static boolean check1_9(int arr[]) {
    if (arr == null || arr.length != 9) {
        return false;
    }
    int mask = 0;
    for (int val : arr) {
        mask |= (1 << val);
    }
    return mask == (1 << 10) - 2; // true iff bits 1..9 are set
}

公共静态布尔校验1_9（int arr[]{
如果（arr==null | | arr.length！=9）{
返回false；
}
int-mask=0；
用于（内部值：arr）{
mask |=（1这里有一种方法：
public static boolean check1_9(int arr[]) {
    if (arr == null || arr.length != 9) {
        return false;
    }
    int mask = 0;
    for (int val : arr) {
        mask |= (1 << val);
    }
    return mask == (1 << 10) - 2; // true iff bits 1..9 are set
}

公共静态布尔校验1_9（int arr[]{
如果（arr==null | | arr.length！=9）{
返回false；
}
int-mask=0；
用于（内部值：arr）{
mask |=（1如果数组的大小为9，则只需检查数组中是否包含从1到9的每个数字。
一种方法是：
public boolean check(Integer[] array) {
    List<Integer> list = Arrays.asList(array);
    for (int i = 1; i < 10; i++) {
        if (!list.contains(i)) {
            return false;
        }
    }
    return true;
}

公共布尔检查（整数[]数组）{
列表=数组。asList（数组）；
对于（int i=1；i<10；i++）{
如果（！list.contains（i））{
返回false；
}
}
返回true；
}

另一种方法是：
public boolean check(Integer[] array) {
    List<Integer> list = Arrays.asList(array);
    return list.containsAll(Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9}));
}

公共布尔检查（整数[]数组）{
列表=数组。asList（数组）；
return list.containsAll（Arrays.asList（新整数[]{1,2,3,4,5,6,7,8,9}））；
}
如果数组的大小为9，则只需检查数组中是否包含从1到9的每个数字。
一种方法是：
public boolean check(Integer[] array) {
    List<Integer> list = Arrays.asList(array);
    for (int i = 1; i < 10; i++) {
        if (!list.contains(i)) {
            return false;
        }
    }
    return true;
}

公共布尔检查（整数[]数组）{
列表=数组。asList（数组）；
对于（int i=1；i<10；i++）{
如果（！list.contains（i））{
返回false；
}
}
返回true；
}

另一种方法是：
public boolean check(Integer[] array) {
    List<Integer> list = Arrays.asList(array);
    return list.containsAll(Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9}));
}

公共布尔检查（整数[]数组）{
列表=数组。asList（数组）；
return list.containsAll（Arrays.asList（新整数[]{1,2,3,4,5,6,7,8,9}））；
}
让我们用一个布尔数组来试试：
static boolean distinct9(final int... a) {
    return a.length == 9 && check(a);
}

static boolean check(final int... a) {
    final boolean[] b = new boolean[a.length];
    for (final int i : a) {
        final int j = i - 1;
        if (j < 0 || j >= b.length || b[j]) {
            return false;
        }
        b[j] = true;
    }
    return true;
}

static boolean distinct9（final int…a）{
返回a.length==9&&check（a）；
}
静态布尔检查（最终整数…a）{
最终布尔值[]b=新布尔值[a.长度]；
对于（最终int i:a）{
最终积分j=i-1；
如果（j<0 | | j>=b.length | b[j]）{
返回false；
}
b[j]=真；
}
返回true；
}

我们遍历int
数组，并使用这些数字作为boolean
数组中的索引。如果索引超出范围，则数字太低或太高。如果索引处的boolean
为true
，则存在重复。如果不是，则将其设置为true
，然后继续下一个n翁贝尔
如果循环中没有一个负标准匹配，则检查成功。
让我们使用布尔值数组进行尝试：
static boolean distinct9(final int... a) {
    return a.length == 9 && check(a);
}

static boolean check(final int... a) {
    final boolean[] b = new boolean[a.length];
    for (final int i : a) {
        final int j = i - 1;
        if (j < 0 || j >= b.length || b[j]) {
            return false;
        }
        b[j] = true;
    }
    return true;
}

static boolean distinct9（final int…a）{
返回a.length==9&&check（a）；
}
静态布尔检查（最终整数…a）{
最终布尔值[]b=新布尔值[a.长度]；
对于（最终int i:a）{
最终积分j=i-1；
如果（j<0 | | j>=b.length | b[j]）{
返回false；
}
b[j]=真；
}
返回true；
}

我们遍历int
数组，并使用这些数字作为boolean
数组中的索引。如果索引超出范围，则数字太低或太高。如果索引处的boolean
为true
，则存在重复。如果不是，则将其设置为true
，然后继续下一个n翁贝尔
如果循环中没有一个负标准匹配，则检查成功。
对它们进行排序，然后检查每个数字是否=索引+1，第一次失败返回False。因此，对于一个数组中的每个元素，您将检查另一个数组中的每个元素？肯定有一个性能更高的选项