Question

我已经解决了hackerrank Sock Merchant问题，但是我想减少代码的复杂性（我不确定是否可能）。

  约翰在一家服装店工作。他有一堆袜子，必须按颜色配对以出售。给定代表每个袜子颜色的整数数组，确定有多少双颜色匹配的袜子。

例如，有 n = 7 袜子，颜色为 ar = [1,2,1,2,1,3,2] 。有一对颜色 1 和一种颜色 2 。剩下三只奇怪的袜子，每种颜色一只。对数为2。

功能描述

在下面的编辑器中完成sockMerchant函数。它必须返回一个整数，表示可用的匹配的袜子对数。

sockMerchant具有以下参数：



n：一堆袜子的数量



ar：每只袜子的颜色



输入格式

第一行包含整数 n ，以 ar 表示的袜子数。   第二行包含 n 个以空格分隔的整数，它们描述了桩中袜子的颜色 ar [i] 。

约束



1 <= n <= 100



1 <= ar [i] <= 100，其中0 <= i


输出格式

返回John可以出售的匹配袜子的总数。

样本输入

9
10 20 20 10 10 30 50 10 20

样本输出

我的解决方案：

package com.hackerrank.test;

public class Solution {
    public static void main(String[] args) {
        //Initialize array
        int[] arr = new int[]{10, 20, 20, 10, 10, 30, 50, 10, 20};
        //Array fr will store frequencies of element


        System.out.println("---------------------------------------");
        System.out.println(" sockMerchant output " + sockMerchant(9, arr));
        System.out.println("---------------------------------------");

    }

    static int sockMerchant(int n, int[] ar) {
        int pairs = 0;
        int frequencyArray[] = new int[ar.length];
        int frequencyTemp = -1;
        for (int i = 0; i < ar.length; i++) {
            int count = 1;
            for (int j = i + 1; j < ar.length; j++) {
                if (ar[i] == ar[j]) {
                    count++;
                    frequencyArray[j] = frequencyTemp;
                }
            }
            if (frequencyArray[i] != frequencyTemp) {
                frequencyArray[i] = count;
            }
        }

        for (int i = 0; i < frequencyArray.length; i++) {
            if (frequencyArray[i] != frequencyTemp) {
                int divide = frequencyArray[i] / 2;
                pairs += divide;
            }
        }
        return pairs;
    }
}

输出为：

    ---------------------------------------
    sockMerchant frequency 3
    ---------------------------------------

Answer 1

您可以使用HashSet在O(n)中进行一次遍历（O(1)），它具有int[] arr = new int[]{10, 20, 20, 10, 10, 30, 50, 10, 20}; HashSet<Integer> unmatched = new HashSet<>(); int pairs = 0; for(int i = 0; i < arr.length; i++) { if(!unmatched.add(arr[i])) { unmatched.remove(arr[i]); pairs++; } }放置和查找时间。每个元素都已经在集合中，在这种情况下，它会被删除，并且对计数器会增加，或者不是，在这种情况下，您可以添加它：

 void calculateBalanceValue(BinaryNode *& t)
        {
            if (t==nullptr) return;

            int left = height(t->left);
            int right = height(t->right);
            t->bal=abs(left -right);
            calculateBalanceValue(t->right);
            calculateBalanceValue(t->left);

        }

Answer 2

这是我的简单代码，供初学者使用 c++ 理解，它打印用户定义向量中的对数计数：

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

// Complete the sockMerchant function below.
int sockMerchant(int n, vector<int> ar) {
  int count=0;
  vector<int> x;
  for(int i=0;i<n;i++){
    if(ar[i]!=0)
    {
      for(int j=i+1;j<n;j++)
        {
          if(ar[i]==ar[j]){
            count++;
            ar[j]=0;
            break;
        }
    }}
  }
  return count;
}

int main()
{
  int a,b;
  vector<int> v;
  cin>>a;
  for(int i=0;i<a;i++){
    cin>>b;
    v.push_back(b);
    
  }
  cout<<sockMerchant(a,v);
}

Answer 3

这个问题可以通过哈希集轻松解决。我们可以利用 HashSet 不存储重复元素的能力。这是下面的代码。

    Set<Integer> set = new HashSet<>();
    int pairCount = 0;
    for(int i = 0; i < arr.length; i++) {
        if(set.add(a[i])
           set.add(a[i])
        else {
           pairCount++; 
           set.remove(a[i]);
        }
    }
    return pairCount;

Answer 4

使用 Python 3：

def sockMerchant(n, ar):

    flag = 0
    for i in range(n):
        if ar[i:].count(ar[i])%2==0:
            flag+=1
    return flag

Answer 5

它也可以使用内置的 Set 数据类型来解决，如下（我的尝试）-

function sockMerchant(n, ar) {
    // Write your code here
    let numberSet = [...new Set(ar)];
    let pairs = 0;
    for(let i=0;i<numberSet.length;i++){
        let count = 0;
        ar.filter(x => {
           if(x == numberSet[i])
               count++;
        });
        pairs+= count / 2 >= 1 ? Math.trunc(count / 2) : 0;
    }
    return pairs;
}

Answer 6

我喜欢的更简单的方法。 Kotlin 中的答案

var counter = 0
for (i in 0 until n) {
    if (arr[i] != 0) {
        loop@ for (j in i + 1 until n) {
            if (arr[i] == arr[j]) {
                counter++
                arr[j] = 0
                break@loop
            }
        }
    }
}

评论更好的编程

Answer 7

你可以计算一个数字在列表中出现的次数并除以2

def sockMerchant(n, ar):
     unq = set(ar)
     count = 0
     for i in unq:
      count_vals = ar.count(i)
      if count_vals>1:
        count = count + int(count_vals/2)
     return count

Answer 8

function sockMerchant(n, ar) {
  //Need to initiate a count variable to count pairs and return the value
  let count = 0
  //sort the given array
  ar = ar.sort()
  //loop through the sorted array 
  for (let i=0; i < n-1; i++) {
    //if the current item equals to the next item 
    if(ar[i] === ar[i+1]){
      //then that's a pair, increment our count variable
      count++
      //also increment i to skip the next item
      i+=1
    }
  }
  //return the count value
  return count
}

sockMerchant(9, [10, 20, 20, 10, 10, 30, 50, 10, 20])

Answer 9

Javascript 代码

const set = new Set()
let count = 0;

for(let i = 0; i < i; i++) {
    if (set.has(ar[i])) {
        count++;
        set.delete(ar[i])
    } else {
        set.add(ar[i])
    }
}

Answer 10

我想用数组来解决这个问题。这是我在 HackerRank (Java 8) 上解决 Sock Merchant 问题的解决方案：

.... 导入 org.apache.commons.lang3.ArrayUtils; 导入 java.util.Arrays;

类结果{

public static int sockMerchant(int n, List<Integer> ar) {

int[] arr = ar.stream().mapToInt(i->i).toArray();

int counter = 0;

for(int i = 0; i<n; i++) {
    if(arr[i]>0) {
        int t = arr[i];
        arr[i] = -1;
        int j = ArrayUtils.indexOf(arr, t);
        if(j == -1) {
            continue;
        } else {
            arr[j] = -1;
            counter += 1;
        }
    } else {
        continue;
    }
}

return counter;    

}

}

时间复杂度为 O(n)。

Answer 11

My answer in C
        int sockMerchant(int n, int ar_count, int* ar) {
        int matchcounter =0;// each number repeating count
        int paircounter=0;//total pair
        int size=0;int i,j,k;
        bool num_av=false;//number available or not in new array
        int numberarray[n];//creating new (same length) array of length n
       for(i=0;i<n;i++){
          num_av=false;
          for(k=0;k<=size;k++){
            if(numberarray[k] == ar[i]){
              num_av=true;
              break;  
            }
          }
          if(!num_av){
                size+=1;
                numberarray[size-1]=ar[i];
                for(j=0;j<n;j++){
                    if(ar[i]==ar[j]){
                        matchcounter++;
                    }
                }
                paircounter += matchcounter/2;
                matchcounter=0;
          }
           
       }
       return paircounter;
    }

Answer 12

/*
 * Complete the 'sockMerchant' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER n
 *  2. INTEGER_ARRAY ar
 */

function sockMerchant(n, ar) {
    // Write your code here    
    let count = [];
    for (var i = 0; i < ar.length; i++) {
        if (count.hasOwnProperty(ar[i])) {
            count[ar[i]]++;
        }
        else {
            count[ar[i]] = 1;
        }
    }
    
    let number = 0;
    for (const key in count) {
        number += parseInt(count[key] / 2);
    }
    return number;
}

Answer 13

package com.java.example.sock;

import java.io.IOException;
/**
 * 
 * @author Vaquar Khan
 *
 */
public class Solution1 {

// Complete the sockMerchant function below.
    /*
     * John works at a clothing store. He has a large pile of socks that he must pair by color for sale. Given an array of integers representing the color of each sock, determine how many pairs
     * of socks with matching colors there are.
     * For example, there are  socks with colors . There is one pair of color  and one of color . There are three odd socks left, one of each color. The number of pairs is .
     */
    static int sockMerchant(int n, int[] ar) {

        int counter = 0;
        int count = 0;
        //
        for (int i = 0; i < ar.length; i++) {
            count = 1;
            //
            for (int j = i + 1; j < ar.length; j++) {
                if (ar[i] == ar[j]) {
                    count++;
                }
            }

            if (count % 2 == 0) {
                counter++;
            }
        }

        return counter;
    }

    public static void main(String[] args) throws IOException {

        int array[] = { 10, 20, 20 ,10 ,10, 30, 50, 10 ,20};

        System.out.println(sockMerchant(9, array));
    }
}

Answer 14

我们可以使用哈希表。由于哈希表的复杂度为 O(1)
看看下面的代码片段，我在 python 中创建了一个字典，即具有键和值的哈希表。在字典中，每个值只存在一个唯一的 Key。因此，在开始时字典将为空。我们将遍历提供的列表并检查字典键中的值。如果该值不在字典键中，则表示它是唯一的，请将其添加到字典中。如果我们在字典键中找到值，只需增加 pairs counter 并从哈希表即字典中删除该键值对。

def sockMerchant(n, ar):
    hash_map = dict()
    pairs = 0
    for x in range(len(ar)):
        if ar[x] in hash_map.keys():
            del hash_map[ar[x]]
            pairs += 1
        else:
            hash_map.setdefault(ar[x])
    return pairs

Answer 15

这适用于 Java 8！！

static int sockMerchant(int n, int[] ar) {
        Set<Integer> list = new HashSet<Integer>();
        int count = 0;
        for(int i= 0; i < n; i++){
            if(list.contains(ar[i])){
                count++;
                list.remove(ar[i]);
            }
            else{
                list.add(ar[i]);
            }
        }
        return count;
    }

Answer 16

def sockMerchant（n，ar）：

socks = dict()
pairs = 0
for i in ar:
    if i in socks:
        socks[i] = socks[i]+1
    if i not in socks:
        socks[i] = 1
    if socks[i]%2 == 0:
        pairs += 1

return pairs

Answer 17

Python 3的代码

n = 9
ar = [10, 20, 20, 10, 10, 30, 50, 10, 20]
def sockMerchant(n, ar):
    totalpair = 0
    test= list(set(ar))
    for i in test:
        pair = 0
        for j in ar:
            if i==j:
                pair+=1
        if pair>=2:
            totalpair=totalpair+int(pair/2)
    return totalpair
print(sockMerchant(n,ar))

Answer 18

static int sockMerchant(int n, int[] ar) {
    int pairs = 0;
    for (int i = 0; i < ar.length; i++) {
        int counter = 0;
        for (int j = 0; j < ar.length; j++) {
            if (j < i && ar[j] == ar[i]) break;
            if(ar[j]==ar[i]) counter++;
        }
        pairs+=counter/2;
    }
    return pairs;
}

Answer 19

使用字典解决问题的Py3

def sockMerchant(n, ar):
    pair = 0
    d = {}
    for i in ar:
        if i in d:
            d[i] += 1
        if i not in d:
            d[i] = 1
    print(d)
    for x in d:
        u = d[x]//2
        pair += u
    return pair

Answer 20

Refer below one using HashMap and having complexity O(1)

static int sockMerchant(int n, int[] ar) {
        int pairs=0;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i=0;i<n;i++){
            if(map.containsKey(ar[i])){
                int count=map.get(ar[i]);
                map.put(ar[i],++count);
            }
            else{
                map.put(ar[i],1);
            }
        }
        for(int i : map.values()){
            pairs=pairs+(i/2);
        } 
        return pairs;

    }

Answer 21

这是我用JAVA在HackerRank上进行Sock Merchant测试的解决方案

import java.io.*;
import java.util.*;

public class sockMerchant {

public static void main(String[] args) {
    Scanner en = new Scanner(System.in);
    int n=en.nextInt();
    int[] hash = new int[300];
    for(int i=0; i<n; i++){
        hash[en.nextInt()]++;
    }
    long res=0;
    for(int f: hash){
        res+=f/2;
    }
    System.out.println(res);
 }
}

Answer 22

是的，您可以将其复杂度降低为O（n）。只需迭代一次输入数组，然后为找到的每个新元素在哈希图中创建一个值为1的条目。如果找到重复的条目，请在映射中将该条目的值递增。

完成传递后，迭代映射中的项目，将其值除以2，仅保留除法的整数部分，然后加上累加和。

我们可以用更少的复杂性解决这个袜子商人的问题吗？

22 个答案: