એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડી  


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન બેલ્ઝાબાર હનીવેલ Hulu Nvidia રોબિન હૂડ દરદથી ચીસ પાડવી
અરે હેશ

એકમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડીમાં એરે સમસ્યા આપણે અલગ પૂર્ણાંકોની એક એરે આપી છે, એરેમાં અસ્તિત્વમાં છે તે સંખ્યાના હકારાત્મક મૂલ્ય અને નકારાત્મક મૂલ્ય ધરાવતી બધી જોડીઓ છાપો. આપણે તેમની ઘટનાઓના ક્રમમાં જોડીઓ પ્રિન્ટ કરવાની જરૂર છે. એક જોડી જેનું કોઈપણ તત્વ પહેલા દેખાય છે તે પહેલા છાપવું જોઈએ.

ઉદાહરણ  

ઇનપુટ:

A[]={2, 3, -1, -2, 9, 1}

આઉટપુટ:

Pairs having positive value and negative in the array are: -2 2 -1 1

અભિગમ 1: જડ બળ  

ઇનપુટ એરેમાં દરેક તત્વ એ [i] માટે, તપાસો કે –A [i] જો હું હાજર હોઉં તો ઇન્ડેક્સ સાથે IA [i] હાજર હોય તો આ જોડી છાપે.

અલ્ગોરિધમ

  1. 0 થી n-1 રેન્જમાં I માટે લૂપ ચલાવો
    1. I + 1 થી n-1 રેન્જમાં j માટે લૂપ ચલાવો
      1. જો A [i] બરાબર -A [j] છે, તો પછી આ જોડી છાપો.
    2. પાછા.

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડી શોધવા માટે સી ++ પ્રોગ્રામ

#include <bits/stdc++.h>
using namespace std;
void printPairs(vector<int> &A)
{
    int n = A.size();
    cout << "Pairs having positive value and negative in the array are: ";
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (A[i] == -A[j])
            {
                if (A[i] <= 0)
                {
                    cout << A[i] << " " << (-A[i]) << " ";
                }
                else
                {
                    cout << (-A[i]) << " " << A[i] << " ";
                }
            }
        }
    }
    cout << endl;
    return;
}
int main()
{
    vector<int> A = {2, 3, -1, -2, 9, 1};
    printPairs(A);
    return 0;
}
Pairs having positive value and negative in the array are: -2 2 -1 1

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડી શોધવા માટે જાવા પ્રોગ્રામ

public class Main
{
    static void printPairs(int[] A)
    {
        int n = A.length;
        System.out.print("Pairs having positive value and negative in the array are: ");
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                if (A[i] == -A[j])
                {
                    if (A[i] <= 0)
                    {
                       A[i]=-A[i];
                    }
                    System.out.print(A[i]+" -"+A[i]+" ");
                }
            }
        }
        return;
    }
  public static void main(String[] args) {
    int[] A={2, 3, -1, -2, 9, 1};
    printPairs(A);
  }
}
Pairs having positive value and negative in the array are: 2 -2 1 -1

જટિલતા વિશ્લેષણ

સમયની જટિલતા

આપણે બે નેસ્ટેડ લૂપ્સ વાપરી રહ્યા છીએ, બંને સાઇઝ એન. તેથી કુલ સમય જટિલતા છે ઓ (એન ^ 2)

આ પણ જુઓ
આપેલ રકમ સાથે સબઅરેરે (નકારાત્મક નંબરો સંભાળે છે) શોધો

જગ્યાની જટિલતા

જગ્યાની જટિલતા છે તેથી અમે કોઈ વધારાની જગ્યાનો ઉપયોગ કરી રહ્યાં નથી ઓ (1)

અભિગમ 2: હેશીંગનો ઉપયોગ કરીને  

મુખ્ય વિચાર

હેશ કોષ્ટકમાં એરેમાં કયા તત્વો છે તે આપણે સંગ્રહિત કરી શકીએ છીએ. હવે એરેમાં દરેક તત્વ એ [i] માટે, તપાસ કરો કે હેશ ટેબલમાં –A [i] નું મૂલ્ય 1 છે કે નહીં, જો તે 1 છે, તો પછી આ જોડી છાપો અને [i] અને –A નું ઘટતું મૂલ્ય [i] હેશ ટેબલમાં 1 દ્વારા જેથી અમે તે જ જોડી બે વાર છાપીશું નહીં.

અલ્ગોરિધમ

  1. હેશ ટેબલ પ્રારંભ કરો.
  2. હેશ ટેબલમાં દરેક તત્વની આવર્તન સંગ્રહિત કરો.
  3. 0 થી n-1 રેન્જમાં I માટે લૂપ ચલાવો
    1. જો hA [i] ની કિંમત હેશ ટેબલમાં 1 છે, તો પછી આ જોડી છાપો અને A [i] અને –A [i] નું મૂલ્ય 1 દ્વારા ઘટાડે છે.

ઉદાહરણ સાથે સમજો

ચાલો ઇનપુટ એરે લઈએ [] = {2, 3, -1, -2, 9, 1}

તેથી અમારું હેશ ટેબલ આપણે આના જેવું લાગે છે:

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડીપિન

હવે આપણે એરેને પુનરાવર્તિત કરીશું,

નારંગી રંગ વર્તમાન અનુક્રમણિકા બતાવે છે,

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડીપિન એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડીપિન

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડીપિન પિન પિન પિન

તેથી અંતિમ આઉટપુટ છે: -2 2 -1 1

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડી શોધવા માટે સી ++ પ્રોગ્રામ

#include <bits/stdc++.h>
using namespace std;
void printPairs(vector<int> &A)
{
    int n = A.size();
    unordered_map<int, int> hash_table;
    for (int i = 0; i < n; i++)
    {
        hash_table[A[i]]++;
    }
    cout << "Pairs having positive value and negative in the array are: ";
    for (int i = 0; i < n; i++)
    {
        if (hash_table[-A[i]] == 1)
        {
            if (A[i] <= 0)
            {
                cout << A[i] << " " << (-A[i]) << " ";
            }
            else
            {
                cout << (-A[i]) << " " << A[i] << " ";
            }
            hash_table[A[i]]--;
            hash_table[-A[i]]--;
        }
    }
    cout << endl;
    return;
}
int main()
{
    vector<int> A = {2, 3, -1, -2, 9, 1};
    printPairs(A);
    return 0;
}
Pairs having positive value and negative in the array are: -2 2 -1 1

એરેમાં સકારાત્મક નકારાત્મક મૂલ્યોની જોડી શોધવા માટે જાવા પ્રોગ્રામ

import java.util.*; 
public class Main
{
    static void printPairs(int[] A)
    {
        int n = A.length;
        HashMap<Integer,Integer> hash_table = new HashMap<Integer,Integer>();
        for (int i = 0; i < n; i++)
        {
            hash_table.put(A[i],1);
        }
        System.out.print("Pairs having positive value and negative in the array are: ");
        for (int i = 0; i < n; i++)
        {
            if(hash_table.containsKey(-1*A[i]) && hash_table.get(-1*A[i])==1)
            {
                if (A[i] <= 0)
                {
                    A[i]*=-1;
                }
                System.out.print(A[i]+" -"+A[i]+" ");
                hash_table.put(A[i],0);
                hash_table.put(-1*A[i],0);
            }
        }
        return;
    }
  public static void main(String[] args) {
    int[] A={2, 3, -1, -2, 9, 1};
    printPairs(A);
  }
}
Pairs having positive value and negative in the array are: -2 2 -1 1

જટિલતા વિશ્લેષણ

સમયની જટિલતા

અમે આખા એરેને બે વાર ફેરવીએ છીએ, તેથી સમય જટિલતા છે ઓ (એન).

આ પણ જુઓ
મહત્તમ બનતું અક્ષર

જગ્યાની જટિલતા

અમે હેશ ટેબલનો ઉપયોગ કરી રહ્યા છીએ, તેથી જગ્યાની જટિલતા છે ઓ (એન).

સંદર્ભ