Java 袜子商人问题：我正试图用一种不同的方法来解决这个问题

我正试图从HackerRank解决袜子商人的问题

约翰在一家服装店工作。他有一大摞袜子要买 必须按颜色配对出售。给定一个表示 每只袜子的颜色，决定有多少双袜子 有很多颜色相配的

例如，有

n=7

颜色为

ar=[1,2,1,3,2]

的袜子。有一对颜色

1

还有一种颜色

2

。剩下三只袜子，每种颜色一只。 成对数为

2

我的代码：

class Sock
{
    public static void  main(String args[])
    {
        int n=10;
        int ar[] = new int[]{1,1,3,1,2,1,3,3,3,3};
        int count = 0,number=0;

        for(int i=0;i<n-1;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                if(ar[i]==ar[j])
                {
                    count++;
                }
            }

             if(count%2==0)
                number++;

        }
        System.out.println("Pairs =  "+number);
    }
}

classsock
{
公共静态void main（字符串参数[]）
{
int n=10；
int ar[]=新int[]{1,1,3,1,2,1,3,3,3}；
整数计数=0，数字=0；
对于（int i=0；i你的基本想法还可以，不过我花了一点时间才理解。如果这只袜子右边有偶数只相同颜色的袜子。那么我可以把它算为一双袜子（如果是奇数，那么它可能是一双袜子中的另一只，所以不要再算了）

我认为您的程序中有两个错误：

对于外部循环的每次迭代，必须将
count
重置为0；上一次迭代的值是无关的
因为您没有计算当前的sock in，所以需要奇数而不是偶数来调用pair
因此，您的程序变成：

    int ar[] = { 1, 1, 3, 1, 2, 1, 3, 3, 3, 3 };
    int numberOfPairs = 0;

    for (int i = 0; i < ar.length - 1; i++)
    {
        int countSocksToTheRight = 0;

        for (int j = i + 1; j < ar.length; j++)
        {
            if (ar[i] == ar[j])
            {
                countSocksToTheRight++;
            }
        }
        if (countSocksToTheRight % 2 != 0)
        {
            numberOfPairs++;
        }

    }
    System.out.println("Pairs =  " + numberOfPairs);

intar[]={1,1,3,1,2,1,3,3}；
int numberOfPairs=0；
对于（int i=0；i

我试图想出更好的变量名。我没有做任何彻底的测试。就目前的程序而言，它输出：

成对=4

备选方案：作为一个完整的旁白，没有回答您提出的任何问题，但其他读者可能会感兴趣：如果我要编写该程序，我将使用两个流操作。我首先使用数组中的流，并按袜子颜色分组，然后计算每组中的袜子。接下来，我将根据地图，将每个袜子数除以2，然后扔掉剩余的袜子（任何不匹配的袜子）要获得该颜色的对数，最后将所有对数相加。
在这种情况下，您可以使用嵌套循环，因为HackerRank只会在长度不超过100的数组上测试您的解决方案。但是如果您想采取不同的方法，请考虑如果有绘图，您将如何自己手动解决此问题呃，装满了袜子，你想数一数有多少双。我想你不会拿一只袜子，数一数抽屉里有多少只那种颜色的袜子，然后再拿一只袜子，再数一数，依此类推

自然的解决方案是一次拿一只袜子，把它们放在抽屉旁边的一个单独的空间里，当你拿一只袜子与你放在一边的袜子配对时，把它们配对放在一起，然后放到其他地方。这个解决方案可以用Java建模，使用
集
来存储未配对的袜子，并使用一个计数器变量to数一对袜子的数量。每次从阵列中取出一只新袜子时，如果同一颜色的袜子已经在集合中，则从集合中取出一只袜子并配对（即，将一只袜子添加到计数器中），否则将新袜子放入集合中

public int countPairs（int[]socks）{
Set oddSocks=新HashSet（）；
整数对=0；
用于（int sock:socks）{
if（oddSocks.contains（sock））{
拆下（袜子）；
pairs++；
}否则{
oddSocks.add（sock）；
}
}
返回对；
}
如果使用哈希表，这可以在O（n）时间复杂度和O（n）空间中完成

哈希表的键=袜子的颜色，值=每种颜色的总计数

total_count = dict()
for i in range(len(arr)):
    if arr[i] in total_count:
        total_count[arr[i]] += 1

pairs = 0
for i in total_count:
    pairs += int(total_count[i] / 2)

print(pairs)

在数组上迭代一次，并将每次出现的颜色存储在哈希表中。然后在哈希表上迭代以检查每种颜色的计数是否可被2整除。这将为您提供颜色对

我用python实现了这一点，但希望您能理解这一点。
var res=0；
ar.sort（功能（a、b）{
返回a-b
});
对于（var i=0；i试试这个，你很容易理解它

x=[]
y=[]
ar.sort()
while len(ar)>1:
 if ar[0]==ar[1]:
  x.append(ar[:2])
  del ar[:2]
 else:
  del ar[0]

这是绝对有效的
你的问题是什么？虽然这段代码可能会回答这个问题，但最好包括一些上下文，解释它是如何工作的以及何时使用它。从长远来看，只使用代码的答案是没有用的。字典检查_bucket以socks number为键，以socks number为值，然后检查all值，如果它是偶数，则从该特定值中减去1，然后将所有值相加并除以2。
def sockMerchant(n, ar):
check_bucket = {}
for i in range(len(ar)):
    if ar.count(ar[i]) > 1:
        check_bucket[ar[i]] = ar.count(ar[i])
for key, value in check_bucket.items():
    if check_bucket[key] % 2 != 0:
        check_bucket[key] = check_bucket[key] - 1

values = check_bucket.values()
total = round(sum(values) / 2)
return total