Javascript 为什么不起作用：如果可能的话，找到使数组A或数组B一致所需的最小交换量？

答案是1。在索引0处交换

如果它们都不可能是一致的，则返回-1

我的方法是将两个数组中的每个元素与该数组索引为0的项进行比较。如果不匹配，请查看0处的元素是否位于同一索引的其他数组中。若并没有，那个么答案是-1，因为并没有多少交换可以导致100%的均匀阵列

这个问题可以在leetcode上找到，我正在练习，我已经不知所措了。

函数mindominorotions（A，B）{
设a计=0；
设bCount=0；
让阿拉=真；
让allB=true；
for（设i=0；i

您正在尝试将第一行的每个元素设置为A[0]，或将第二行的每个元素设置为B[0]

但第一行的每个元素都可以设置为B[0]，或者第二行的每个元素都可以设置为A[0]

例如：

A=[1,2,2,2]
B=[2,3,4,5]

在这种情况下，在您的代码中，allA将为false，bCount将为3，所以答案将为3

但是如果你交换A[0]和B[0]，答案将是1

考虑所有A[I]到B[0 ]的相等的情况，以及所有B[i]与A〔0〕的相等的情况。

我已更改了您的代码以获得所需的结果。 我接受的代码是：

function minDominoRotations(A, B) {
    let aCount = 0;
    let bCount = 0;
    let allA = true;
    let allB = true;

    for(let i = 0; i < A.length; i++) {
        if (A[i] !== A[0]) {
            if (B[i] === A[0]) {
                aCount++;
            } else {
                allA = false;
            }
        }

        if (B[i] !== B[0]) {
            if (A[i] === B[0]) {
                bCount++;
            } else {
                allB = false;
            }
        } 
    }

    if (allA || allB) {
        if (allA && allB) {
            return Math.min(aCount, bCount);
        } else if (allA) {
            return aCount;
        } else {
            return bCount;
        }
    } else {
        return -1;
    }

};

函数mindominorotions（A，B）{
设a计=0；
设bCount=0；
让阿拉=真；
让allB=true；
设res=A.length+1；
for（设i=0；i类解决方案{
公共交通（int[]A、int[]B）{
int min=Math.min（交换（A[0]，A，B），交换（B[0]，A，B））；
min=Math.min（min，Math.min（交换（A[0]，B，A），交换（B[0]，B，A））；
返回最小值==Integer.MAX_值？-1:min；
}
整数互换（整数t，整数[]A，整数[]B）{
int结果=0；
for（int i=0；i

两者都是1。这就是他们应该在视觉上看到的。漂亮的接球，我看到了问题。我会尝试修复it@MuhammadUmer如果我的评论有帮助，请单击“有帮助”。谢谢：我无法解决它，你知道什么可以解决它吗。@穆罕默德·默多默我更改了你的代码并添加了我的评论。我也被接受了

function minDominoRotations(A, B) {
    let aCount = 0;
    let bCount = 0;
    let allA = true;
    let allB = true;

    for(let i = 0; i < A.length; i++) {
        if (A[i] !== A[0]) {
            if (B[i] === A[0]) {
                aCount++;
            } else {
                allA = false;
            }
        }

        if (B[i] !== B[0]) {
            if (A[i] === B[0]) {
                bCount++;
            } else {
                allB = false;
            }
        } 
    }

    if (allA || allB) {
        if (allA && allB) {
            return Math.min(aCount, bCount);
        } else if (allA) {
            return aCount;
        } else {
            return bCount;
        }
    } else {
        return -1;
    }

};

function minDominoRotations(A, B) {
    let aCount = 0;
    let bCount = 0;
    let allA = true;
    let allB = true;
    let res=A.length+1;

    for(let i = 0; i < A.length; i++) {
        if (A[i] !== A[0]) {
            if (B[i] === A[0]) {
                aCount++;
            } else {
                allA = false;
            }
        }
    }
    if(allA)res=Math.min(res,aCount);

    for(let i = 0; i < A.length; i++) {
        if (B[i] !== B[0]) {
            if (A[i] === B[0]) {
                bCount++;
            } else {
                allB = false;
            }
        } 
    }
       if(allB)res=Math.min(res,bCount);
   allA=true,allB=true;
   aCount=0,bCount=0;
    for(let i = 0; i < A.length; i++) {
        if (A[i] !== B[0]) {
            if (B[i] === B[0]) {
                aCount++;
            } else {
                allA = false;
            }
        }
    }
    if(allA)res=Math.min(res,aCount);

    for(let i = 0; i < A.length; i++) {
        if (B[i] !== A[0]) {
            if (A[i] === A[0]) {
                bCount++;
            } else {
                allB = false;
            }
        } 
    }
       if(allB)res=Math.min(res,bCount);
    if (res<A.length) {
       return res;
    } else {
        return -1;
    }

};

class Solution {
    public int minDominoRotations(int[] A, int[] B) {
        int min = Math.min(swaps(A[0], A, B), swaps(B[0], A, B));
        min = Math.min(min, Math.min(swaps(A[0], B, A), swaps(B[0], B, A)));
        return min == Integer.MAX_VALUE ? -1 : min;
    }
    
    int swaps(int t, int[] A, int[] B) {
        int result = 0;
        for (int i = 0; i < A.length; i++) {
            if (A[i] != t) {
                if (B[i] == t) result++;s
                else return Integer.MAX_VALUE;
            }
        }
        return result;
    }
}