Java 求和为一个整数的不同整数对的数目

我试图计算数组中的对数，这样每对都给出一个整数的和

我使用了以下代码：

    public static int SumPairs(Integer []input, int k){
    Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
    int tmp=0;
    //System.out.println(pairs.toString());
     for(int i=0;i<input.length;i++){
     if(pairs.containsKey(input[i])){
            System.out.println(pairs.containsKey(input[i]));
             System.out.println(input[i] +", "+ pairs.get(input[i]));
             input[i]=0; 
            tmp++;      

        }

        else
            pairs.put(k-input[i], input[i]);
    }return tmp;
}

我想防止该方法多次使用数字！！ 因此，输出将是

(4,1)
(3,2)

公共静态int-sumPairs（整数[]输入，int-sum）{
List complementaries=newarraylist（input.length）；
整数对=0；
for（整数：输入）{
if（补充项.包含（编号））{
补充。删除（编号）；
pairs++；
}
否则{
补充。加（和数）；
}
}
返回对；
}

现在它应该可以完美地工作了

互补数组仅用于跟踪求和所需的数字。如果它包含数字，这意味着我们之前迭代了它的互补项，所以我们可以只添加一对，然后从互补项列表中删除该数字。Oherwise我们在不增加pairs计数器的情况下将当前数字的补码添加到列表中。

公共静态int-sumPairs（Integer[]输入，int-sum）{
List complementaries=newarraylist（input.length）；
整数对=0；
for（整数：输入）{
if（补充项.包含（编号））{
补充。删除（编号）；
pairs++；
}
否则{
补充。加（和数）；
}
}
返回对；
}

现在它应该可以完美地工作了

---

互补数组仅用于跟踪求和所需的数字。如果它包含数字，这意味着我们之前迭代了它的互补项，所以我们可以只添加一对，然后从互补项列表中删除该数字。否则，我们会在不增加配对计数器的情况下，将当前数字的互补项添加到列表中。

我使用存储值及其频率的映射：

public static int SumPairs(Integer[] input, int k){
    Map<Integer, Integer> frequencies = new HashMap<>();
    int pairsCount = 0;      

    for(int i=0; i<input.length; i++){
        int value = input[i];
        int complement = k - input[i];

        if(frequencies.containsKey(complement)){                
            int freq = frequencies.get(complement) - 1;
            pairsCount++;
            //System.out.println(value + ", " + complement);    
            if(freq == 0){
                frequencies.remove(complement);
            }else{
                frequencies.put(complement, freq);
            }
        }else{
            if(frequencies.containsKey(value)){         
                frequencies.put(value, frequencies.get(value) + 1);             
            }else{
                frequencies.put(value, 1);
            }
        }
    }
    return pairsCount;
}

公共静态int-SumPairs（整数[]输入，int k）{
映射频率=新HashMap（）；
int pairscont=0；
对于（int i=0；i我使用存储值及其频率的映射：

public static int SumPairs(Integer[] input, int k){
    Map<Integer, Integer> frequencies = new HashMap<>();
    int pairsCount = 0;      

    for(int i=0; i<input.length; i++){
        int value = input[i];
        int complement = k - input[i];

        if(frequencies.containsKey(complement)){                
            int freq = frequencies.get(complement) - 1;
            pairsCount++;
            //System.out.println(value + ", " + complement);    
            if(freq == 0){
                frequencies.remove(complement);
            }else{
                frequencies.put(complement, freq);
            }
        }else{
            if(frequencies.containsKey(value)){         
                frequencies.put(value, frequencies.get(value) + 1);             
            }else{
                frequencies.put(value, 1);
            }
        }
    }
    return pairsCount;
}

公共静态int-SumPairs（整数[]输入，int k）{
映射频率=新HashMap（）；
int pairscont=0；
对于（int i=0；i查找不同对问题的最简单解决方案：

public static int SumPairs(int[] input, int k) {

    Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
    int tmp = 0;
    for (int data : input) {
        if (pairs.containsKey(k - data) && pairs.get(k - data) == 0) {
            tmp++;
            pairs.put((k - data), pairs.get(k - data) + 1);
        } else if (!pairs.containsKey(data)) {
            pairs.put(data, 0);
        }
    }

    return tmp;
}

公共静态int-SumPairs（int[]输入，int k）{
映射对=新的HashMap（）；
int-tmp=0；
for（int数据：输入）{
if（pairs.containsKey（k-data）&&pairs.get（k-data）==0）{
tmp++；
pairs.put（（k-data），pairs.get（k-data）+1）；
}如果（！pairs.containsKey（数据））{
pairs.put（数据，0）；
}
}
返回tmp；
}

它已被测试为123444和sum=5。也被测试为44444和sum=8。
如果有任何困惑，请随时问我。干杯。
找到不同配对问题的最简单解决方案：

public static int SumPairs(int[] input, int k) {

    Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
    int tmp = 0;
    for (int data : input) {
        if (pairs.containsKey(k - data) && pairs.get(k - data) == 0) {
            tmp++;
            pairs.put((k - data), pairs.get(k - data) + 1);
        } else if (!pairs.containsKey(data)) {
            pairs.put(data, 0);
        }
    }

    return tmp;
}

import java.util.HashSet;
public class DistinctPairs {     
   static int numberOfPairs(int[] arr,int k)
   {
       HashSet<String> s=new HashSet<String>();
       int n=arr.length;
       int sum=0;
       for(int i=0;i<n;i++)
       {
           for(int j=0;j<n;j++)
           {
               sum=arr[i]+arr[j];
               if(i==j)
               {
                   continue;
               }
               else
               {
                  if(sum==k)
                  {
                      String l=String.valueOf("("+arr[i]+","+arr[j]+")");
                      StringBuilder sb=new StringBuilder(l);
                      String rl=sb.reverse().toString();
                      if(s.add(l)==false)
                      {

                      }

                  }
               }

           }
       }
        System.out.println(s.toString());

       return s.size()/2;
   }
    public static void main(String args[])
    {
        int b[]={1,5,66,2,3,4,7,0,2,5};
     int size=numberOfPairs(b,5);  
     System.out.println(size);
    }
}

公共静态int-SumPairs（int[]输入，int k）{
映射对=新的HashMap（）；
int-tmp=0；
for（int数据：输入）{
if（pairs.containsKey（k-data）&&pairs.get（k-data）==0）{
tmp++；
pairs.put（（k-data），pairs.get（k-data）+1）；
}如果（！pairs.containsKey（数据））{
pairs.put（数据，0）；
}
}
返回tmp；
}

它已被测试为123444和sum=5。也被测试为44444和sum=8。
如果有任何困惑，请随时问我。干杯。
import java.util.HashSet；
import java.util.HashSet;
public class DistinctPairs {     
   static int numberOfPairs(int[] arr,int k)
   {
       HashSet<String> s=new HashSet<String>();
       int n=arr.length;
       int sum=0;
       for(int i=0;i<n;i++)
       {
           for(int j=0;j<n;j++)
           {
               sum=arr[i]+arr[j];
               if(i==j)
               {
                   continue;
               }
               else
               {
                  if(sum==k)
                  {
                      String l=String.valueOf("("+arr[i]+","+arr[j]+")");
                      StringBuilder sb=new StringBuilder(l);
                      String rl=sb.reverse().toString();
                      if(s.add(l)==false)
                      {

                      }

                  }
               }

           }
       }
        System.out.println(s.toString());

       return s.size()/2;
   }
    public static void main(String args[])
    {
        int b[]={1,5,66,2,3,4,7,0,2,5};
     int size=numberOfPairs(b,5);  
     System.out.println(size);
    }
}

公共类DistinctPairs{
静态int numberOfPairs（int[]arr，int k）
{
HashSet s=新的HashSet（）；
int n=阵列长度；
整数和=0；
对于（inti=0；i
import java.util.HashSet；
公共类DistinctPairs{
静态int numberOfPairs（int[]arr，int k）
{
HashSet s=新的HashSet（）；
int n=阵列长度；
整数和=0；
对于（int i=0；i
该代码获取一个数组并返回所有可能的对，这些对的和都是指定的。当问题要求打印对数而不是对数时，数组长度除以2将给出所需的答案

int-notInArray（浮点a[]，浮点m，整数n）
{
int i，j，k；
对于（i=0；i
该代码获取一个数组并返回所有可能的对，这些对的和都是指定的。当问题要求打印对数而不是对数时，数组长度除以2将给出所需的答案

int-notInArray（浮点a[]，浮点m，整数n）
{
int i，j，k；
对于（i=0；i
public void distinctPairs（int[]arr，int k）{
int-length=arr.length；
整数计数=0；
映射对=新的HashMap（）；
对于（int i=0；i
public void distinctPairs（int[]arr，int k）{
int-length=arr.length；
整数计数=0；
映射对=新的HashMap（）；
对于（int i=0；i我们可以使用hashmap来存储数组的所有值。然后遍历数组并检查映射是否包含（K-a[i]）。如果映射包含，则递增计数并从映射中删除两个键

private int getDistinctPair(int k,int[] input){
        HashMap<Integer,Integer> map = new HashMap<>();
        int pairs = 0;
        for (int i = 0; i < input.length-1; i++) {
            map.put(input[i], input[i]);
        }
        for (int i = 0; i <input.length-1 ; i++) {
            int diff = k - input[i];
            if(map.containsKey(diff)){
                pairs++;
                map.remove(diff);
                map.remove(input[i]);
            }
        }
        return  pairs;
    }

private int getDistinctPair（int k，int[]输入）{
HashMap=newHashMap（）；
整数对=0；
for（int i=0；i对于（int i=0；i我们可以使用hashmap来存储数组的所有值。然后遍历数组并检查映射是否包含（K-a[i]）。如果映射包含，则递增计数并从映射中删除两个键

private int getDistinctPair(int k,int[] input){
        HashMap<Integer,Integer> map = new HashMap<>();
        int pairs = 0;
        for (int i = 0; i < input.length-1; i++) {
            map.put(input[i], input[i]);
        }
        for (int i = 0; i <input.length-1 ; i++) {
            int diff = k - input[i];
            if(map.containsKey(diff)){
                pairs++;
                map.remove(diff);
                map.remove(input[i]);
            }
        }
        return  pairs;
    }

private int getDistinctPair（int k，int[]输入）{
HashMap=newHashMap（）；
整数对=0；
for（int i=0；i
def numberOfPairs(a, k):

    # Let's do a o(n) approach by maintaining all the compliments of the K in a 
    # visited set

    compliments = set()
    result = set()
    for v in a:
        # See if the element is in the compliments set, if so thats the pair
        if v in compliments:
            result.add((v, k-v))
        # If the element is not found in visited save the compliment of it in the visited set    
        else:
            compliments.add(k-v)
    


    return len(result)

        

我希望这能有所帮助

def numberOfPairs(a, k):

    # Let's do a o(n) approach by maintaining all the compliments of the K in a 
    # visited set

    compliments = set()
    result = set()
    for v in a:
        # See if the element is in the compliments set, if so thats the pair
        if v in compliments:
            result.add((v, k-v))
        # If the element is not found in visited save the compliment of it in the visited set    
        else:
            compliments.add(k-v)
    


    return len(result)

        

这适用于所有测试
int count(int target, int... nums) {
    Set<Pair> uniPairs = new HashSet<>();
    Set<Integer> seen = new HashSet<>();
    for (int i = 0; i < nums.length; i++) {
        int diff = target - nums[i];
        if (seen.contains(diff)) {
            Pair pair = new Pair(nums[i], diff);
            uniPairs.add(pair);
        }
        seen.add(nums[i]);
    }
    return uniPairs.size();
}

class Pair {
    int a;
    int b;
    public Pair (int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public boolean equals(Object obj) {
        Pair pair2 = (Pair) obj;
        return ((a == pair2.a) && (b == pair2.b)) || ((b == pair2.a) && (a == pair2.b));
    }

    @Override
    public int hashCode() {
        return Objects.hash(a, b) + Objects.hash(b, a);
    }
}

def countPairs(arr, k):
    possible_maps = []

    for num in arr:
        pair_matches = list(filter(lambda n: n + num == k, arr))

        if len(pair_matches) > 0:
            possible_maps += list(map(lambda nm: (num, nm), pair_matches))

    return len(set(map(lambda pair: ','.join(str(n) for n in sorted(pair)), possible_maps)))

        private static int SumPairs(int[] arr, int sum)
        {
            Dictionary<int, int> frequency = new Dictionary<int, int>();
            List<int> temp = new List<int>();
            int count = 0;

            foreach (int i in arr)
            {
                int diff = sum - i;

                if (!frequency.ContainsKey(i))
                {
                    if (temp.Contains(i))
                    {
                        frequency.Add(i, diff);
                        count++;
                    }
                    else
                    {
                        temp.Add(diff);
                    }
                }
            };

            return count;
        }

static List<Tuple<int,int>> GetUniquePairs(int[] arr, int sum)
        {
            Dictionary<Tuple<int, int>, int> kvp = new Dictionary<Tuple<int, int>, int>();
            List<Tuple<int,int>> result = new List<Tuple<int,int>>();
            int length = arr.Length;
            for(int i = 0;i < length; i++)
            {
                int j = i + 1;
                while (j < length)
                {
                    if(arr[i]+arr[j] == sum)
                    {
                        Tuple<int, int> key = new Tuple<int, int>(arr[i], arr[j]);
                        if (!kvp.ContainsKey(key))
                            kvp.Add(key, 1);
                    }

                    j++;
                }
            }

            var keys = kvp.Keys;
            foreach(var k in keys)
            {
                result.Add(k);
            }
            return result;
        }