Fatal编程技术网
  • java/
  • Java 我们能以较低的复杂性解决这个袜子商人问题吗？

Java 我们能以较低的复杂性解决这个袜子商人问题吗？

java algorithm

Java 我们能以较低的复杂性解决这个袜子商人问题吗？,java,algorithm,Java,Algorithm,我已经解决了hackerrank Sock Merchant问题，但我想降低代码的复杂性（我不确定这是否可行） 约翰在一家服装店工作。他有一大堆袜子，必须按颜色配对出售。给定一个表示每个袜子颜色的整数数组，确定有多少双颜色匹配的袜子 例如，有n=7袜子的颜色ar=[1,2,1,3,2]。有一对颜色1和一对颜色2。剩下三只袜子，每种颜色一只。成对的数量是2 功能描述 在下面的编辑器中完成sockMerchant功能。它必须返回一个整数，表示可用的匹配袜子对数 sockMerchant具有以下参数：

我已经解决了hackerrank Sock Merchant问题，但我想降低代码的复杂性（我不确定这是否可行）

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

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

功能描述

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

sockMerchant具有以下参数：

  • n:这堆袜子的数量

  • ar：每只袜子的颜色

输入格式

第一行包含一个整数n，即ar中表示的袜子数量。 第二行包含n空间分隔整数，用于描述袜子堆中的颜色ar[i]

约束

  • 1是的，你可以把这个问题的复杂度降低到O（n）。仅迭代输入数组一次，并为找到的每个新元素在哈希映射中创建一个值为1的条目。如果发现重复条目，请在地图中增加该条目的值

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

    您可以使用具有
    O（1）
    放置和查找时间的a在一次传递（
    O（n）
    ）中解决此问题。每个元素都已在集合中，在这种情况下，它将被删除，对计数器将递增，或者不递增，在这种情况下，您将添加它：

    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++;
    }
}

    int[]arr=newint[]{10,20,20,10,10,30,50,10,20}；
HashSet unmatched=新HashSet（）；
整数对=0；
对于（int i=0；i
    包com.java.example.sock；
导入java.io.IOException；
/**
* 
*@作者Vaquar Khan
*
*/
公共类解决方案1{
//完成下面的功能。
/*
*约翰在一家服装店工作。他有一大堆袜子，他必须按颜色配对出售。给定代表每只袜子颜色的整数数组，确定有多少双
*有许多颜色相配的袜子。
*例如，有带颜色的袜子。有一双颜色和一种颜色。还有三只单数的袜子，每种颜色一只。成对的数量是。
*/
静态整数（整数n，整数[]ar）{
int计数器=0；
整数计数=0；
//
for（int i=0；i
    这里是我用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);
 }
}

    import java.io.*；
导入java.util.*；
公营袜商{
公共静态void main（字符串[]args）{
扫描器en=新扫描器（System.in）；
int n=en.nextInt（）；
int[]散列=新的int[300]；
对于（inti=0；i
    ，请参阅下面使用HashMap且复杂性为O（1）的一个
静态整数（整数n，整数[]ar）{
整数对=0；
Map Map=newhashmap（）；

    对于（int i=0；iPy3），使用字典解决问题
    

    def（n，ar）：
配对=0
d={}
对于ar中的i：
如果我是d：
d[i]+=1
如果我不在d：
d[i]=1
印刷品（d）
对于d中的x：
u=d[x]//2
对+=u
返回对

    静态整数（整数n，整数[]ar）{
整数对=0；
for（int i=0；i
    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))

    
def（n，ar）：
    

    这适用于Java8
    

    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;
    }

    

    static int（int n，int[]ar）{
Set list=新的HashSet（）；
整数计数=0；
对于（int i=0；i
    我们可以使用哈希表，因为哈希表的复杂性是O（1）
    
请看下面的代码片段，我用python创建了一个字典，即具有键和值的哈希表。在字典中，每个值只存在一个唯一的键。因此，在开始时，字典将为空。我们将循环提供的列表并检查字典键中的值。如果该值不在字典键中，则表示它是唯一的，请将其添加到字典。如果我们在字典键中找到值，只需增加对计数器，并从哈希表（即字典）中删除该键值对
    

    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

    

    <>这是我用C++简单的代码，用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);
}

    

    

    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);
 }
}

    

    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;

    }

    

    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;
}

    

    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))

    

    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  

    

    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;
    }

    

    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

    

    #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);
}

    

        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;

    

    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;
    }

    

    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;    

}

    

    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])
    }
}