একটি অ্যারের থেকে উপাদানগুলির একটি জুড়ি সন্ধান করুন যার যোগফল একটি প্রদত্ত সংখ্যার সমান

122

এন পূর্ণসংখ্যার অ্যারে দেওয়া এবং একটি নম্বর দেওয়া, সমস্ত উপাদানগুলির অনন্য জোড়া (ক, খ) সন্ধান করুন, যার সমষ্টি এক্স এর সমান

নিম্নলিখিতটি আমার সমাধানটি হ'ল এটি ও (এনলগ (এন) + এন), তবে এটি অনুকূল কিনা আমি নিশ্চিত নই।

int main(void)
{
    int arr [10] = {1,2,3,4,5,6,7,8,9,0};
    findpair(arr, 10, 7);
}
void findpair(int arr[], int len, int sum)
{
    std::sort(arr, arr+len);
    int i = 0;
    int j = len -1;
    while( i < j){
        while((arr[i] + arr[j]) <= sum && i < j)
        {
            if((arr[i] + arr[j]) == sum)
                cout << "(" << arr[i] << "," << arr[j] << ")" << endl;
            i++;
        }
        j--;
        while((arr[i] + arr[j]) >= sum && i < j)
        {
            if((arr[i] + arr[j]) == sum)
                cout << "(" << arr[i] << "," << arr[j] << ")" << endl;
            j--;
        }
    }
}
algorithm 
— জিন
সূত্র
3
আপনি অ্যারে বাছাইয়ের পরিবর্তে কোনও কিছু (O) (1) সেটটিতে সব কিছু ছড়িয়ে দিলে একটি ও (এন) সমাধান সম্ভব।
— আনন
1
@ অনন আপনি আরও বিশদ বলতে পারেন, কীভাবে এই জাতীয় সেট তৈরি করবেন?
— জিন
3
হ্যাশ ব্যবহার করুন। বেশিরভাগ ভাষাগুলিতে তাদের স্ট্যান্ডার্ড লাইব্রেরিতে কোথাও এমোরিটাইজড ও (1) হ্যাশসেট থাকবে।
— আনন
15
একটি ছোটখাটো নিট - O (nLog (n) + n) হ'ল O (nLog (n))। বিগ ও স্বরলিপি কেবল প্রভাবশালী শব্দটি ধরে রাখে এবং সমস্ত নিম্ন অর্ডার শর্তাদি ফেলে দেয়।
— pjs
2
উল্লেখ্য শর্ট সার্কিট মূল্যায়ন এবং বন্ধ-বাই-এক অ্যাড্রেসিং: while((arr[i] + arr[j]) <= sum && i < j)হওয়া উচিত while( i < J && arr[i] + arr[j] <= sum )। (দ্বিতীয়
— সাবলুপের

উত্তর:

135 
# Let arr be the given array.
# And K be the give sum


for i=0 to arr.length - 1 do
  hash(arr[i]) = i  // key is the element and value is its index.
end-for

for i=0 to arr.length - 1 do
  if hash(K - arr[i]) != i  // if Kth element exists and it's different then we found a pair
    print "pair i , hash(K - arr[i]) has sum K"
  end-if
end-for
— codaddict
সূত্র
26
প্রথম লুপের হ্যাশ অ্যাসাইনমেন্টের ঠিক পরে, দ্বিতীয় লুপ থেকে আপনার if স্টেটমেন্টটি রেখে আপনি অ্যারের মাধ্যমে এক পুনরাবৃত্তিতে এটি করতেও পারেন।
— আলেকজান্ডার কনড্রেটস্কি
4
গৌণ দ্রষ্টব্য: এটি (পাশাপাশি আলেকজান্ডারের পরামর্শ) কিছু জোড় ডাবল-মুদ্রণ করবে, কোনও জোড়ের স্বতন্ত্রতা সূচক দ্বারা নির্ধারিত হয় (এই উত্তর থেকে বোঝানো যেতে পারে) বা মান দ্বারা (যেমন এটি ওপিতে মনে হয়)। সূচক অনুসারে বেশ কয়েকটি (O (n ^ 2)) অনন্য জোড়া থাকতে পারে arr=[1,2,1,2,1,2,1,...]। মান অনুসারে স্বতন্ত্রতার জন্য, দেখে মনে হচ্ছে একটি মান-জোড় দ্বারা কীড করা অন্য হ্যাশ টেবিলটি কৌশলটি করবে। এখনও একটি দুর্দান্ত, কমপ্যাক্ট, মার্জিত উত্তর। +1
— উইলিয়াম
2
@ কোডডডিক্ট তবে অ্যারে খুব বড় হলে কী হবে? মানে এর মানগুলির পরিসরটি কি খুব বড়? সুতরাং, হ্যাশ সমাধানটি তখন কম ব্যবহারিক হবে। এর জন্য কোনও বিকল্প এবং সর্বোত্তম পদ্ধতি?
— প্রশান্ত সিং
15
ডুপ্লিকেট থাকলে কী হবে?
— জাদ
2
না hash(K - arr[i]) != iএকরকম উভয় উপস্থিতি এবং একটি ম্যাচ অভাব দেখতে চান? আমি উপস্থিতি জন্য একটি পৃথক চেক হবে আশা করি।
— জোসেফ গারভিন
185

এই সমাধানের জন্য 3 টি পন্থা রয়েছে:

যোগফলটি T এবং n এর অ্যারের আকার হতে দিন

পদ্ধতির 1:
এটি করার সহজ উপায় হ'ল সমস্ত সংমিশ্রণ পরীক্ষা করা (এন 2 বেছে নিন)। এই বিস্তৃত অনুসন্ধান হ'ল ও (এন 2 )।

পদ্ধতির 2: 
 অ্যারে বাছাই করা আরও ভাল উপায়। এটি O (n লগ এন) নেয়
তারপরে অ্যারে A তে প্রতিটি এক্সের জন্য, Tx সন্ধানের জন্য বাইনারি অনুসন্ধান ব্যবহার করুন। এটি O (nlogn) নেবে।
সুতরাং, সামগ্রিক অনুসন্ধান হ'ল (এন লগ এন)

পদ্ধতি 3:
সর্বোত্তম উপায় হ্যাশ টেবিলের মধ্যে প্রতিটি উপাদান inোকানো (বাছাই ছাড়াই)। এটি স্থির সময় সন্নিবেশ হিসাবে ও (এন) লাগে।
তারপরে প্রতিটি এক্স এর জন্য আমরা কেবলমাত্র এর পরিপূরক, টিএক্স, যা ও (1) এর সন্ধান করতে পারি।
সামগ্রিকভাবে এই পদ্ধতির রান সময় হ'ল ও (এন)।


আপনি এখানে আরও উল্লেখ করতে পারেন .ধন্যবাদ।


— kinshuk4
সূত্র
অ্যারের উপাদানগুলির জন্য আপনি কীভাবে হ্যাশ টেবিল তৈরি করবেন?
— সতীশ প্যাটেল
আমার ভাগ করা লিঙ্কটি উল্লেখ করুন। উপাদানটিকে সূচক হিসাবে সংরক্ষণ করার জন্য আমাদের একটি সমান্তরাল অ্যারে থাকতে পারে, বা আপনি উপাদানগুলি হ্যাশটেবলে যুক্ত করতে এবং সেগুলিতে ব্যবহার করতে পারেন। এইরকম দেরী জবাবের জন্য দুঃখিত।
— কিনশুক 4
11
টার্গেটের যোগফলের ঠিক অর্ধেক যদি এমন কোনও উপাদান থাকে তবে আপনি একটি মিথ্যা ইতিবাচক পেতে পারেন।
— ফ্লোরিয়ান এফ
2
@ ফ্লোরিয়ান_এফ যেখানে আপনি এমন কোনও বিশেষ ক্ষেত্র রাখতে পারবেন না যেখানে আপনার এমন উপাদান রয়েছে যা অর্ধেক?
— জোসেফ গারভিন
1
@ জাজজ্জ মানে এখানে হ্যাশম্যাপ, যদিও হ্যাশসেটও এটি করবে। এখানে বাস্তবায়নটি রয়েছে - github.com/kinshuk4/AlgorithmUtil/blob/master/src/com/vaani/… । আশা করি এটা সাহায্য করবে.
— কিনশুক
64

জাভাতে বাস্তবায়ন: কোডাডডিক্টের অ্যালগরিদম ব্যবহার করে (সম্ভবত কিছুটা আলাদা)

import java.util.HashMap;

public class ArrayPairSum {


public static void main(String[] args) {        

    int []a = {2,45,7,3,5,1,8,9};
    printSumPairs(a,10);        

}


public static void printSumPairs(int []input, int k){
    Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();

    for(int i=0;i<input.length;i++){

        if(pairs.containsKey(input[i]))
            System.out.println(input[i] +", "+ pairs.get(input[i]));
        else
            pairs.put(k-input[i], input[i]);
    }

}
}

ইনপুট জন্য = {2,45,7,3,5,1,8,9}এবং যদি যোগফল হয়10

আউটপুট জোড়া: 

3,7 
8,2
9,1

সমাধান সম্পর্কে কিছু নোট:

  • অ্যারে -> ও (এন) সময়ের মাধ্যমে আমরা একবারে পুনরাবৃত্তি করি
  • হ্যাশে সন্নিবেশ এবং দেখার সময় হল ও (1))
  • সামগ্রিক সময় হ'ল (এন), যদিও এটি হ্যাশের ক্ষেত্রে অতিরিক্ত স্থান ব্যবহার করে।
— Rambo7
সূত্র
1
ইনপুট অ্যারে সদৃশ না থাকলে এটি কেবলমাত্র ভাল।
— নরেন
2
@ নরেন: প্রদত্ত অ্যারেতে ডুপ্লিকেট থাকলেও তাতে কোনও পার্থক্য নেই
— অভিষেক
1
কোডডডিক্টস যা লিখেছিল তা কার্যকর করে না এবং আপনি যা করেছেন তা কার্যকর হলেও এটি জটিল নয় is এটি অর্থহীন put(k-input[i], input[i])(কোডডডিক্টস সূচককে মূল্য হিসাবে কার্যকর করে তোলে যা কার্যকর।) আপনি যা লিখেছেন তা সরল করা যেতে পারেfor (i:input){ if (intSet.contains(sum-i) { print(i + "," + (sum-i) ); } else {intSet.add(i)}
— অ্যাড্রিয়ান শাম
1
ঠিক আছে, ধন্যবাদ. অন্যান্য লোকেদের রেফারেন্সের উদ্দেশ্যে, আমি কেবল একটি অন্য থ্রেড তৈরি করেছি যাতে এই সমাধানটি কীভাবে কাজ করে তা বিশ্লেষণ করতে যারা অসুবিধায় আছেন তারা সঠিকভাবে বুঝতে পারেন। এখানে লিঙ্কটি দেওয়া হয়েছে: stackoverflow.com/questions/33274952/…
— জন
2
@ অভিষেক
— ০৮ আউগ এটি
8

জাভা সমাধান। আপনি স্ট্রিংগুলির একটি অ্যারেলিস্টে সমস্ত স্ট্রিং উপাদান যুক্ত করতে পারেন এবং তালিকাটি ফিরে আসতে পারেন। এখানে আমি এটি প্রিন্ট করছি।

void numberPairsForSum(int[] array, int sum) {
    HashSet<Integer> set = new HashSet<Integer>();
    for (int num : array) {
        if (set.contains(sum - num)) {
            String s = num + ", " + (sum - num) + " add up to " + sum;
            System.out.println(s);
        }
        set.add(num);
    }
}
— বিক্রম দাভে
সূত্র
4

পাইথন বাস্তবায়ন: 

import itertools
list = [1, 1, 2, 3, 4, 5,]
uniquelist = set(list)
targetsum = 5
for n in itertools.combinations(uniquelist, 2):
    if n[0] + n[1] == targetsum:
        print str(n[0]) + " + " + str(n[1])

আউটপুট:

1 + 4
2 + 3
— গরম
সূত্র
2
সন্ধান করুন ... অনুসন্ধানের উপাদানটির জন্য ওভারহেড হবে
— নিখিল রূপনওয়ার
4

সি ++ 11, রান টাইম জটিলতা ও (এন):

#include <vector>
#include <unordered_map>
#include <utility>

std::vector<std::pair<int, int>> FindPairsForSum(
        const std::vector<int>& data, const int& sum)
{
    std::unordered_map<int, size_t> umap;
    std::vector<std::pair<int, int>> result;
    for (size_t i = 0; i < data.size(); ++i)
    {
        if (0 < umap.count(sum - data[i]))
        {
            size_t j = umap[sum - data[i]];
            result.push_back({data[i], data[j]});
        }
        else
        {
            umap[data[i]] = i;
        }
    }

    return result;
}
— iamantony
সূত্র
3

এখানে একটি সমাধান ডাইনী সদৃশ এন্ট্রি অ্যাকাউন্টে নেয়। এটি জাভাস্ক্রিপ্টে লেখা হয়েছে এবং ধরে নেওয়া হচ্ছে অ্যারে বাছাই করা হয়েছে। সমাধানটি ও (এন) সময়ে চলে এবং ভেরিয়েবলটি বাদ দিয়ে কোনও অতিরিক্ত মেমরি ব্যবহার করে না।

var count_pairs = function(_arr,x) {
  if(!x) x = 0;
  var pairs = 0;
  var i = 0;
  var k = _arr.length-1;
  if((k+1)<2) return pairs;
  var halfX = x/2; 
  while(i<k) {
    var curK = _arr[k];
    var curI = _arr[i];
    var pairsThisLoop = 0;
    if(curK+curI==x) {
      // if midpoint and equal find combinations
      if(curK==curI) {
        var comb = 1;
        while(--k>=i) pairs+=(comb++);
        break;
      }
      // count pair and k duplicates
      pairsThisLoop++;
      while(_arr[--k]==curK) pairsThisLoop++;
      // add k side pairs to running total for every i side pair found
      pairs+=pairsThisLoop;
      while(_arr[++i]==curI) pairs+=pairsThisLoop;
    } else {
      // if we are at a mid point
      if(curK==curI) break;
      var distK = Math.abs(halfX-curK);
      var distI = Math.abs(halfX-curI);
      if(distI > distK) while(_arr[++i]==curI);
      else while(_arr[--k]==curK);
    }
  }
  return pairs;
}

আমি এটি একটি বড় কর্পোরেশনের জন্য একটি সাক্ষাত্কারের সময় সমাধান করেছি। তারা এটা নিয়েছিল কিন্তু আমাকে নয়। সুতরাং এখানে এটি প্রত্যেকের জন্য।

অ্যারের উভয় দিক থেকে শুরু করুন এবং নকলগুলি উপস্থিত থাকলে তা গণনা করে তা নিশ্চিত করে আস্তে আস্তে আপনার দিকে কাজ করুন work

এটি কেবল জোড়া গণনা করে তবে পুনরায় কাজ করা যায়

  • জোড়া খুঁজে পেতে
  • জোড় খুঁজে <এক্স
  • জোড়া> এক্স

উপভোগ করুন!

— ড্রোন ব্রেন
সূত্র
এই লাইনগুলি কী করে ?: if(distI > distK) while(_arr[++i]==curI); else while(_arr[--k]==curK);
— ইউরি চের্নিশভ
এই রেখাগুলি উভয় দিক থেকে সদৃশ মানগুলির মধ্য দিয়ে যায় এবং যদি তারা জোড়ার অংশ = N হয় তবে তাদের জোড় হিসাবে গণনা করে
— ড্রোন ব্রেন
3

চালু)

def find_pairs(L,sum):
    s = set(L)
    edgeCase = sum/2
    if L.count(edgeCase) ==2:
        print edgeCase, edgeCase
    s.remove(edgeCase)      
    for i in s:
        diff = sum-i
        if diff in s: 
            print i, diff


L = [2,45,7,3,5,1,8,9]
sum = 10          
find_pairs(L,sum)

পদ্ধতি: a + b = c, সুতরাং (a, b) অনুসন্ধান করার পরিবর্তে আমরা a = c - b খুঁজছি

— garg10may
সূত্র
আপনার মতো ইনপুটটিতে সদৃশ থাকলে তা কি জাগে না: [3, 4, 3, 2, 5] এবং যোগফল = 6
— আন্তন ড্যানিলচেনকো 5:48 এ 14
সমস্ত প্রান্তের কেস সংশোধন করা হয়েছে, এখন চেষ্টা করুন
— ই
2

জাভাতে বাস্তবায়ন: কোডাডডিক্টের অ্যালগরিদম ব্যবহার করে:

import java.util.Hashtable;
public class Range {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Hashtable mapping = new Hashtable();
    int a[]= {80,79,82,81,84,83,85};
    int k = 160;

    for (int i=0; i < a.length; i++){
        mapping.put(a[i], i);
    }

    for (int i=0; i < a.length; i++){
        if (mapping.containsKey(k - a[i]) && (Integer)mapping.get(k-a[i]) != i){
            System.out.println(k-a[i]+", "+ a[i]);
        }
    }      

}

}

আউটপুট:

81, 79
79, 81

আপনি যদি নকল জোড়া চান (যেমন: ৮০,৮০) তবে কেবল শর্ত থেকে && (পূর্ণসংখ্যা) ম্যাপিং.টাকে সরান (কা [i])! = আমি যদি শর্ত থেকে এবং আপনি ভাল হন to

— অর্পিত আগরওয়াল
সূত্র
সি # এর জন্য এটি কাজ হতে পারে - int কে = 16; int গণনা = 0; int [] intArray = {5, 7, 11, 23,8,9,15,1,10,6}; (int i = 0; i <intArray.Length; i++) {for (int j = i; j <intArray.Length; j ++) {if ((k - intArray [i]) == intArray [j]) { ++, গণনা; So}} কনসোল.উরাইটলাইন (গণনা);
— মুকুলশর্মা
2

হ্যাকারর্যাঙ্কে সবেমাত্র এই প্রশ্নে অংশ নিয়েছেন এবং এখানে আমার 'উদ্দেশ্য সি' সমাধান রয়েছে :

-(NSNumber*)sum:(NSArray*) a andK:(NSNumber*)k {
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    long long count = 0;
    for(long i=0;i<a.count;i++){

        if(dict[a[i]]) {
            count++;
            NSLog(@"a[i]: %@, dict[array[i]]: %@", a[i], dict[a[i]]);
        }
        else{
            NSNumber *calcNum = @(k.longLongValue-((NSNumber*)a[i]).longLongValue);
            dict[calcNum] = a[i];
        }

    }
    return @(count);
}

আশা করি এটি কাউকে সাহায্য করবে।

— সারু
সূত্র
কোড সিনট্যাক্সটি নিজেই অ্যালগরিদমের চেয়ে বোঝা শক্ত! :)
— রাজেন্দ্র উৎপল
1

এটি লুপের ভিতরে বাইনারি অনুসন্ধান প্রয়োগ করে ও (এন * এলজি এন) এর বাস্তবায়ন।

#include <iostream>

using namespace std;

bool *inMemory;


int pairSum(int arr[], int n, int k)
{
    int count = 0;

    if(n==0)
        return count;
    for (int i = 0; i < n; ++i)
    {
        int start = 0;
        int end = n-1;      
        while(start <= end)
        {
            int mid = start + (end-start)/2;
            if(i == mid)
                break;
            else if((arr[i] + arr[mid]) == k && !inMemory[i] && !inMemory[mid])
            {
                count++;
                inMemory[i] = true;
                inMemory[mid] = true;
            }
            else if(arr[i] + arr[mid] >= k)
            {
                end = mid-1;
            }
            else
                start = mid+1;
        }
    }
    return count;
}


int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    inMemory = new bool[10];
    for (int i = 0; i < 10; ++i)
    {
        inMemory[i] = false;
    }
    cout << pairSum(arr, 10, 11) << endl;
    return 0;
}
— লোকেশ বসু
সূত্র
1

কোডডিক্টিক্ট থেকে দুর্দান্ত সমাধান। আমি রুবিতে এর একটি সংস্করণ বাস্তবায়নের স্বাধীনতা নিয়েছি:

def find_sum(arr,sum)
 result ={}
 h = Hash[arr.map {|i| [i,i]}]
 arr.each { |l| result[l] = sum-l  if h[sum-l] && !result[sum-l]  }
 result
end

নকল জোড়া (1,5), (5,1) অনুমতি দেওয়ার জন্য আমাদের কেবল && !result[sum-l]নির্দেশটি সরিয়ে ফেলতে হবে

— obaqueiro
সূত্র
1

এখানে তিনটি পদ্ধতির জাভা কোড রয়েছে:
১. মানচিত্র ও (এন) ব্যবহার করে হ্যাশসেটটিও এখানে ব্যবহার করা যেতে পারে।
2. অ্যারে বাছাই করুন এবং তারপরে পরিপূরক ও (nLog (n)) সন্ধানের জন্য বাইনারি অনুসন্ধান ব্যবহার করুন
3.. Traতিহ্যবাহী ব্রুটফর্স দুটি লুপ হে (এন ^ 2) 

public class PairsEqualToSum {

public static void main(String[] args) {
    int a[] = {1,10,5,8,2,12,6,4};
    findPairs1(a,10);
    findPairs2(a,10);
    findPairs3(a,10);

}


//Method1 - O(N) use a Map to insert values as keys & check for number's complement in map
    static void findPairs1(int[]a, int sum){
        Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
        for(int i=0; i<a.length; i++){
            if(pairs.containsKey(sum-a[i]))
                System.out.println("("+a[i]+","+(sum-a[i])+")");
            else
               pairs.put(a[i], 0);
        }
    }



//Method2 - O(nlog(n)) using Sort
static void findPairs2(int[]a, int sum){
        Arrays.sort(a);
        for(int i=0; i<a.length/2; i++){
            int complement = sum - a[i];
            int foundAtIndex = Arrays.binarySearch(a,complement);
            if(foundAtIndex >0 && foundAtIndex != i) //to avoid situation where binarySearch would find the original and not the complement like "5"
                System.out.println("("+a[i]+","+(sum-a[i])+")");
        }
 }

//Method 3 - Brute Force O(n^2)
static void findPairs3(int[]a, int sum){

    for(int i=0; i<a.length; i++){
        for(int j=i; j<a.length;j++){
            if(a[i]+a[j] == sum)
                System.out.println("("+a[i]+","+a[j]+")");
        }
    }
}

}
— user1529412
সূত্র
1

জাভাতে একটি অনন্য উপাদান রয়েছে এমন অ্যারেগুলির জন্য একটি সহজ প্রোগ্রাম:

import java.util.*;
public class ArrayPairSum {
    public static void main(String[] args) { 
        int []a = {2,4,7,3,5,1,8,9,5};
        sumPairs(a,10);  
    }

    public static void sumPairs(int []input, int k){
      Set<Integer> set = new HashSet<Integer>();    
      for(int i=0;i<input.length;i++){

        if(set.contains(input[i]))
            System.out.println(input[i] +", "+(k-input[i]));
        else
            set.add(k-input[i]);
       }
    }
}
— পঙ্কজ জয়সওয়াল
সূত্র
1

নীচে জোড়া মুদ্রণের জন্য একটি সাধারণ জাভা কোড স্নিপেট:

    public static void count_all_pairs_with_given_sum(int arr[], int S){
        if(arr.length < 2){
        return;
    }        
    HashSet values = new HashSet(arr.length);
    for(int value : arr)values.add(value);
    for(int value : arr){
        int difference = S - value;
    if(values.contains(difference) && value<difference){
        System.out.printf("(%d, %d) %n", value, difference);
        }
    }
    }
— karthikbv
সূত্র
1

সুইফ্টের আরেকটি সমাধান: ধারণাটি হ্যাশ তৈরি করা উচিত যা (যোগফল - কারেন্টভ্যালু) এর মানগুলি সঞ্চয় করে এবং লুপের বর্তমান মানের সাথে এটি তুলনা করে। জটিলতা হ'ল ও (এন)।

func findPair(list: [Int], _ sum: Int) -> [(Int, Int)]? {
    var hash = Set<Int>() //save list of value of sum - item.
    var dictCount = [Int: Int]() //to avoid the case A*2 = sum where we have only one A in the array
    var foundKeys  = Set<Int>() //to avoid duplicated pair in the result.

    var result = [(Int, Int)]() //this is for the result.
    for item in list {

        //keep track of count of each element to avoid problem: [2, 3, 5], 10 -> result = (5,5)
        if (!dictCount.keys.contains(item)) {
            dictCount[item] = 1
        } else {
            dictCount[item] = dictCount[item]! + 1
        }

        //if my hash does not contain the (sum - item) value -> insert to hash.
        if !hash.contains(sum-item) {
            hash.insert(sum-item)
        }

        //check if current item is the same as another hash value or not, if yes, return the tuple.
        if hash.contains(item) &&
            (dictCount[item] > 1 || sum != item*2) // check if we have item*2 = sum or not.
        {
            if !foundKeys.contains(item) && !foundKeys.contains(sum-item) {
                foundKeys.insert(item) //add to found items in order to not to add duplicated pair.
                result.append((item, sum-item))
            }
        }
    }
    return result
}

//test:
let a = findPair([2,3,5,4,1,7,6,8,9,5,3,3,3,3,3,3,3,3,3], 14) //will return (8,6) and (9,5)
— Duyên-Hoa থেকে
সূত্র
1

আমার সমাধান - জাভা - সদৃশ ছাড়াই

    public static void printAllPairSum(int[] a, int x){
    System.out.printf("printAllPairSum(%s,%d)\n", Arrays.toString(a),x);
    if(a==null||a.length==0){
        return;
    }
    int length = a.length;
    Map<Integer,Integer> reverseMapOfArray = new HashMap<>(length,1.0f);
    for (int i = 0; i < length; i++) {
        reverseMapOfArray.put(a[i], i);
    }

    for (int i = 0; i < length; i++) {
        Integer j = reverseMapOfArray.get(x - a[i]);
        if(j!=null && i<j){
            System.out.printf("a[%d] + a[%d] = %d + %d = %d\n",i,j,a[i],a[j],x);
        }
    }
    System.out.println("------------------------------");
}
— LiozM
সূত্র
0

এটি জোড়া মুদ্রণ করে এবং বিটওয়াইজ ম্যানিপুলেশন ব্যবহার করে সদৃশগুলি এড়িয়ে চলে।

public static void findSumHashMap(int[] arr, int key) {
    Map<Integer, Integer> valMap = new HashMap<Integer, Integer>();
    for(int i=0;i<arr.length;i++)
        valMap.put(arr[i], i);

    int indicesVisited = 0; 
    for(int i=0;i<arr.length;i++) {
        if(valMap.containsKey(key - arr[i]) && valMap.get(key - arr[i]) != i) {
            if(!((indicesVisited & ((1<<i) | (1<<valMap.get(key - arr[i])))) > 0)) {
                int diff = key-arr[i];
                System.out.println(arr[i] + " " +diff);
                indicesVisited = indicesVisited | (1<<i) | (1<<valMap.get(key - arr[i]));
            }
        }
    }
}
— codewarrior
সূত্র
0

আমি বিট ম্যানুপ্লেশনকে বাইপাস করেছিলাম এবং কেবল সূচকের মানগুলির তুলনা করি। এটি লুপ পুনরাবৃত্তির মানের চেয়ে কম (আমি এই ক্ষেত্রে)। এটি সদৃশ জোড়া এবং নকল অ্যারে উপাদানগুলিও মুদ্রণ করবে না।

public static void findSumHashMap(int[] arr, int key) {
    Map<Integer, Integer> valMap = new HashMap<Integer, Integer>();
    for (int i = 0; i < arr.length; i++) {
        valMap.put(arr[i], i);
    }
    for (int i = 0; i < arr.length; i++) {
        if (valMap.containsKey(key - arr[i])
                && valMap.get(key - arr[i]) != i) {
            if (valMap.get(key - arr[i]) < i) {
                int diff = key - arr[i];
                System.out.println(arr[i] + " " + diff);
            }
        }
    }
}
— সূর্য
সূত্র
0

সি # তে:

        int[] array = new int[] { 1, 5, 7, 2, 9, 8, 4, 3, 6 }; // given array
        int sum = 10; // given sum
        for (int i = 0; i <= array.Count() - 1; i++)
            if (array.Contains(sum - array[i]))
                Console.WriteLine("{0}, {1}", array[i], sum - array[i]);
— Chrishan
সূত্র
এই উত্তরটি আরও কার্যকর হবে যদি আপনি নিজের সমাধানের বৃদ্ধির
— টমাস
0

একটি সমাধান এটি হতে পারে, তবে অনুকূল নয় (এই কোডটির জটিলতা হ'ল O (n ^ 2)):

public class FindPairsEqualToSum {

private static int inputSum = 0;

public static List<String> findPairsForSum(int[] inputArray, int sum) {
    List<String> list = new ArrayList<String>();
    List<Integer> inputList = new ArrayList<Integer>();
    for (int i : inputArray) {
        inputList.add(i);
    }
    for (int i : inputArray) {
        int tempInt = sum - i;
        if (inputList.contains(tempInt)) {
            String pair = String.valueOf(i + ", " + tempInt);
            list.add(pair);
        }
    }
    return list;
   }
}
— শ্রীদত্ত কোঠারি
সূত্র
0

কোডটির একটি সাধারণ অজগর সংস্করণ যা শূন্যের জুড়ি খুঁজে পায় এবং কে খুঁজে পেতে পরিবর্তিত হতে পারে:

def sumToK(lst):
    k = 0  # <- define the k here
    d = {} # build a dictionary 

# build the hashmap key = val of lst, value = i
for index, val in enumerate(lst):
    d[val] = index

# find the key; if a key is in the dict, and not the same index as the current key
for i, val in enumerate(lst):
    if (k-val) in d and d[k-val] != i:
        return True

return False

ফাংশনের রান টাইম জটিলতা হ'ল ও (এন) এবং স্পেস: ও (এন) পাশাপাশি।

— Billz
সূত্র
0 
 public static int[] f (final int[] nums, int target) {
    int[] r = new int[2];
    r[0] = -1;
    r[1] = -1;
    int[] vIndex = new int[0Xfff];
    for (int i = 0; i < nums.length; i++) {
        int delta = 0Xff;
        int gapIndex = target - nums[i] + delta;
        if (vIndex[gapIndex] != 0) {
            r[0] = vIndex[gapIndex];
            r[1] = i + 1;
            return r;
        } else {
            vIndex[nums[i] + delta] = i + 1;
        }
    }
    return r;
}
— ব্রুস জু
সূত্র
0

o (n) এর চেয়ে কম সমাধান হবে =>

function(array,k)
          var map = {};
          for element in array
             map(element) = true;
             if(map(k-element)) 
                 return {k,element}
— শিশির অরোরা
সূত্র
নির্দিষ্ট ইনপুট জন্য ব্যর্থ হবে। এছাড়াও আপনাকে প্যারিস না করে একটি অর্থ ফেরত দিতে হবে
— অ্যাভিড
0

পাইথনে সমাধান বোধগম্যতা ব্যবহার করে সমাধান

f= [[i,j] for i in list for j in list if j+i==X];

ও (এন 2 )

পাশাপাশি দুটি অর্ডারযুক্ত জোড়া দেয় (ক, খ) এবং (খ, ক)

— আশ্বিন আরাবিন্দ
সূত্র
আপনি কোনও ভাষার উল্লেখ করতে পারেন, জোড়গুলি (ক, খ) এবং (খ, ক) অনন্য কিনা এবং কী প্রশ্ন এই উত্তর দেয় (প্রশ্নটিতে স্পষ্ট কোনটি নেই - I am not sure … Thanks for comments)। আপনি জটিলতার সময়ে ছুরিকাঘাতকে ও (N²) এর কাছাকাছি চিহ্নিত করতে পারেন।
— গ্রেইয়ার্ড
0

আমি ও (এন) এ এটি করতে পারি। আপনি উত্তর চান যখন আমাকে জানতে দিন। নোট করুন এটিতে কেবল বিনা বাছাই ইত্যাদির সাহায্যে একবারে অ্যারে ট্র্যাভার করা জড়িত ... আমার আরও উল্লেখ করা উচিত যে এটি সংযোজনীয় পরিবহণকে কাজে লাগায় এবং হ্যাশগুলি ব্যবহার করে না কিন্তু স্মৃতিকে অপচয় করে।

সিস্টেম ব্যবহার করে; সিস্টেম.কলেশন.জেনারিক ব্যবহার করে;

/ * একটি ও (এন) পদ্ধতির উপস্থিতি একটি সারণী ব্যবহার করে exists পদ্ধতির মান হ'ল একটি "বিন" -এ সংরক্ষণ করা যা সহজেই দেখা যায় (যেমন, ও (1)) যদি এটি কোনও উপযুক্ত অঙ্কের প্রার্থী হয়।

যেমন,

অ্যারেতে প্রতিটি [কে] এর জন্য আমরা এটিকে সহজভাবে এক্স - এ [কে] অবস্থানে অন্য অ্যারেতে রেখেছি।

ধরুন আমাদের কাছে [0, 1, 5, 3, 6, 9, 8, 7] এবং x = 9 রয়েছে

আমরা একটি নতুন অ্যারে তৈরি করি,

সূচকের মান

9 - 0 = 9     0
9 - 1 = 8     1
9 - 5 = 4     5
9 - 3 = 6     3
9 - 6 = 3     6
9 - 9 = 0     9
9 - 8 = 1     8
9 - 7 = 2     7

তারপরে কেবলমাত্র সেই মানগুলিই নতুন টেবিলে একটি সূচক রয়েছে।

সুতরাং, বলুন যখন আমরা 9 ​​বা সমানতে পৌঁছান তখন আমরা দেখতে পাই যে আমাদের নতুন অ্যারেতে 9 - 9 = 0. সূচক রয়েছে কিনা তা যেহেতু আমরা জানি যে এটিতে থাকা সমস্ত মান 9 যোগ করে দেবে (এই কারণে এটি উল্লেখ করুন যে এটি কেবল সেখানে স্পষ্টই আছে 1 সম্ভাব্য একটি তবে এটিতে আমাদের একাধিক সূচক মান থাকতে পারে যা আমাদের সংরক্ষণ করতে হবে)।

সুতরাং কার্যকরভাবে আমরা শেষ পর্যন্ত কেবল একবার অ্যারের মধ্য দিয়ে যেতে পারি। সংযোজনটি পরিবর্তনমূলক কারণ আমরা সম্ভাব্য সকল ফলাফল দিয়ে শেষ করব।

উদাহরণস্বরূপ, যখন আমরা 6 এ পৌঁছে যাই তখন আমরা আমাদের নতুন টেবিলটিতে সূচিটি 9 - 6 = 3 হিসাবে পাই the যেহেতু সারণীতে সেই সূচকের মান রয়েছে যা আমরা মানগুলি জানি।

এটি মূলত মেমরির জন্য গতি বন্ধ করে দিচ্ছে। * /

namespace sum
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 25;
            int X = 10;
            var arr = new List<int>();
            for(int i = 0; i <= num; i++) arr.Add((new Random((int)(DateTime.Now.Ticks + i*num))).Next(0, num*2));
            Console.Write("["); for (int i = 0; i < num - 1; i++) Console.Write(arr[i] + ", "); Console.WriteLine(arr[arr.Count-1] + "] - " + X);
            var arrbrute = new List<Tuple<int,int>>();
            var arrfast = new List<Tuple<int,int>>();

            for(int i = 0; i < num; i++)
            for(int j = i+1; j < num; j++)
                if (arr[i] + arr[j] == X) 
                    arrbrute.Add(new Tuple<int, int>(arr[i], arr[j]));




            int M = 500;
            var lookup = new List<List<int>>();
            for(int i = 0; i < 1000; i++) lookup.Add(new List<int>());
            for(int i = 0; i < num; i++)        
            {
                // Check and see if we have any "matches"
                if (lookup[M + X - arr[i]].Count != 0)
                {
                    foreach(var j in lookup[M + X - arr[i]])
                    arrfast.Add(new Tuple<int, int>(arr[i], arr[j])); 
                }

                lookup[M + arr[i]].Add(i);

            }

            for(int i = 0; i < arrbrute.Count; i++)
                Console.WriteLine(arrbrute[i].Item1 + " + " + arrbrute[i].Item2 + " = " + X);
            Console.WriteLine("---------");
            for(int i = 0; i < arrfast.Count; i++)
                Console.WriteLine(arrfast[i].Item1 + " + " + arrfast[i].Item2 + " = " + X);

            Console.ReadKey();
        }
    }
}
— AbstractDissonance
সূত্র
মূলত হ্যাশগুলি এড়ানোর জন্য আমাদের একটি টেবিল তৈরি করতে হবে যা কিছুটা স্বেচ্ছাসেবক সূচকগুলিতে এলোমেলো সন্নিবেশ গ্রহণ করতে পারে। অতএব আমি পর্যাপ্ত উপাদান রয়েছে তা নিশ্চিত করতে এম ব্যবহার করি এবং বেশিরভাগটি ব্যবহার করা হবে না তবুও একটি স্বচ্ছ সেট প্রাক-বরাদ্দ করুন। একটি হ্যাশ সেট সরাসরি এটি যত্ন নেবে।
— AbstractDissonance
সুতরাং, আপনি একটি হ্যাশ সেট ব্যবহার করছেন যা একটি সাধারণ হ্যাশ ফাংশন এবং আকার আপনার হ্যাশ ফাংশনের সর্বাধিক মানের চেয়ে বেশি?
— ক্রিস হপম্যান
এছাড়াও এই সময়ে আপনার হ্যাশ ফাংশনের জন্য পরিচয় ফাংশনটিও ব্যবহার করতে পারে। এটি, একটি [কে] - তম "বিন" এ একটি [কে] রাখুন।
— ক্রিস হপম্যান
যেহেতু একটি [কে] এবং এক্স - এ [কে] একটি সূচক ব্যবহৃত হয় এবং আমি একটি অ্যারে ব্যবহার করছি, এর অর্থ হ'ল ন্যূনতম সূচকটি 0 হতে পারে না Hence তাই আমি এগুলি স্থানান্তরিত করতে কেবল খুব বড় সংখ্যক যুক্ত করি। যদি কেউ হ্যাশ ফাংশন করতে পারে যা নির্বিচার মানগুলির জন্য কাজ করে তবে তারা এই স্থানান্তরটি না করেই একটি সাধারণ তালিকা ব্যবহার করতে পারে। স্থানান্তরিত + পূর্বপ্রস্তুতি হ্যাশ তৈরি করা এড়াতে সহায়তা করে (বা এটি একটি খুব সাধারণ (এবং দ্রুত) হ্যাশ হিসাবে ভাবা যেতে পারে)।
— অ্যাবস্ট্রাক্ট
-1

জাভাস্ক্রিপ্ট সমাধান:

var sample_input = [0, 1, 100, 99, 0, 10, 90, 30, 55, 33, 55, 75, 50, 51, 49, 50, 51, 49, 51];
var result = getNumbersOf(100, sample_input, true, []);

function getNumbersOf(targetNum, numbers, unique, res) {
    var number = numbers.shift();

    if (!numbers.length) {
        return res;
    }

    for (var i = 0; i < numbers.length; i++) {
        if ((number + numbers[i]) === targetNum) {
            var result = [number, numbers[i]];
            if (unique) {
              if (JSON.stringify(res).indexOf(JSON.stringify(result)) < 0) {
                res.push(result);                
              }
            } else {
              res.push(result);
            }
            numbers.splice(numbers.indexOf(numbers[i]), 1);
            break;
        }
    }
    return getNumbersOf(targetNum, numbers, unique, res);
}
— gor181
সূত্র
অত্যন্ত বর্ধমান .... আপনি প্রতিটি পুনরাবৃত্তি স্ট্রিংফাই (ও (এন) সময় এবং স্থান) ব্যবহার করছেন ..
— অ্যাভিড
-1

https://github.com/clockzhong/findSumPairNumber

আমি ও (এম + এন) সময় এবং মেমরি উভয়ের জায়গার জন্য জটিলতার ব্যয়ের অধীনে এটি করেছি। আমি সন্দেহ করি এটি এখন পর্যন্ত সেরা অ্যালগরিদম।

— ঘড়ি
সূত্র
-4

int [] আরার = {1,2,3,4,5,6,7,8,9,0};

var z = (আর ইন থেকে আর এ থেকে আরে যেখানে 10 - এ == বি নতুন {এ, বি select নির্বাচন করুন)।

— ভবেশ লাদ
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.