എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും സ്ഥിരമായ അധിക ഇടം ഉപയോഗിച്ച് അവസാനിപ്പിക്കാനും പോസിറ്റീവ് ആയി നീക്കുക


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു കാപ്ജെമിനിയും ഉയർത്തൽ MAQ o9 പരിഹാരങ്ങൾ ടിസിഎസ്
അറേ ക്രമപ്പെടുത്തൽ

നിങ്ങൾക്ക് ഒരു ഉണ്ടെന്ന് കരുതുക ശ്രേണി പൂർണ്ണസംഖ്യകളുടെ. അതിൽ നെഗറ്റീവ്, പോസിറ്റീവ് സംഖ്യകൾ അടങ്ങിയിരിക്കുന്നു, കൂടാതെ അധിക സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാതെ തന്നെ നെഗറ്റീവ്, പോസിറ്റീവ് ഘടകങ്ങളെല്ലാം അറേയുടെ ഇടത്തേക്കും അറേയുടെ വലത്തേക്കും മാറ്റാൻ / നീക്കാൻ പ്രശ്ന പ്രസ്താവന ആവശ്യപ്പെടുന്നു. എല്ലാ നെഗറ്റീവ് സംഖ്യകളെയും തുടക്കത്തിലേക്കും പോസിറ്റീവായും സ്ഥിരമായ അധിക ഇടത്തിൽ അവസാനിപ്പിക്കുന്നതിനുള്ള ഒരു പരിഹാരമാണിത്.

ഉദാഹരണം

 ഇൻപുട്ട്:

arr[]={2,4,-10,13,-7,-60,52,8,-19 }

ഔട്ട്പുട്ട്:

-10 -7 -60 -19 4 2 52 8 13

വിശദീകരണം: എല്ലാ അക്കങ്ങളും ഇടത്തേക്ക് മാറ്റുകയും പോസിറ്റീവ് നമ്പറുകളെല്ലാം വലത്തേക്ക് മാറ്റുകയും ചെയ്യുന്നതിനാൽ.

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും സ്ഥിരമായ അധിക ഇടം ഉപയോഗിച്ച് അവസാനിപ്പിക്കാനും പോസിറ്റീവ് ആയി നീക്കുക

അൽഗോരിതം

  1. J 0 ആയി സജ്ജമാക്കുക.
  2. 0 മുതൽ n വരെ അറേയിലൂടെ സഞ്ചരിക്കുന്നു (പ്രത്യേകമായി, ഇവിടെ n എന്നത് അറേയുടെ നീളം).
    1. ഒരു അറേയുടെ ഏതെങ്കിലും ഘടകം 0 നേക്കാൾ കുറവാണോയെന്ന് പരിശോധിക്കുക,
      1. ഞാൻ j ന് തുല്യമാകരുത് എന്ന് പരിശോധിക്കുക,
        1. സൂചികകളുടെ അറ [i], arr [j] എന്നിവയുടെ മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്ത് j ന്റെ മൂല്യം വർദ്ധിപ്പിക്കുക.
  3. അറേ പ്രിന്റുചെയ്യുക.

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും അവസാനത്തിലേക്ക് പോസിറ്റീവായും നീക്കുന്നതിനുള്ള വിശദീകരണം

ഞങ്ങൾക്ക് ഒരു സംഖ്യ സംഖ്യ നൽകിയിട്ടുണ്ട്, കൂടാതെ അറേയിൽ പോസിറ്റീവ്, നെഗറ്റീവ് ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു. എല്ലാ നെഗറ്റീവ് ഘടകങ്ങളും ഇടത്തേക്കും പോസിറ്റീവ് നമ്പറുകൾ വലത്തേയ്ക്കും മാറ്റാൻ ഞങ്ങൾ ആവശ്യപ്പെട്ടു. ഇതിനായി ഞങ്ങൾ പോകുന്നു സ്വാപ്പ് പോസിറ്റീവ്, നെഗറ്റീവ് ഘടകങ്ങളായ എല്ലാ അക്കങ്ങളും. ആദ്യം അറേയിലൂടെ സഞ്ചരിച്ച് നെഗറ്റീവ് നമ്പറുകൾക്കായി പരിശോധിക്കുക, നമ്പർ നെഗറ്റീവ് ആണെങ്കിൽ മാത്രമേ മൂല്യങ്ങൾ കൈമാറാൻ ഞങ്ങൾ പോകുകയുള്ളൂ.

J ന്റെ മൂല്യം 0 ആയി സജ്ജമാക്കുക, ഇത് സ്വാപ്പ് ചെയ്യുന്നതിനുള്ള ഇതര മൂല്യത്തിനായി ഉപയോഗിക്കും. അറേയിലൂടെ സഞ്ചരിക്കാൻ ഞങ്ങൾ ആരംഭിക്കും, ഓരോ നമ്പറും arr [i] 0 ൽ കുറവാണെന്നത് പരിശോധിക്കും, അത് 0 ൽ കുറവാണെങ്കിൽ, ഞങ്ങൾ നെഗറ്റീവ് നമ്പർ കണ്ടെത്തിയെന്നാണ് അർത്ഥമാക്കുന്നത്, അതിനാൽ രണ്ട് സൂചികകളും സമാനമല്ലേ എന്ന് ഞങ്ങൾ പരിശോധിക്കും, മുകളിലുള്ള എല്ലാ നിബന്ധനകളും ശരിയാണെങ്കിൽ‌, ഞങ്ങൾ‌ അക്കങ്ങളെ arr [i] ആയി സ്വാപ്പ് ചെയ്യുകയും arr [j] സ്വാപ്പ് ചെയ്യുകയും j യുടെ മൂല്യം വർദ്ധിപ്പിക്കുകയും ചെയ്യും. സാധ്യമായ എല്ലാ മൂല്യങ്ങളും കടന്നുപോകുകയും കൈമാറ്റം ചെയ്യുകയും തന്നിരിക്കുന്ന വ്യവസ്ഥ അനുസരിച്ച് പുന ar ക്രമീകരിക്കുകയും ചെയ്യുന്നതുവരെ ഞങ്ങൾ ആ യാത്ര തുടരും.

Arr [i] 0 ൽ കുറവാണെന്ന് ഞങ്ങൾ പരിശോധിച്ചു, കാരണം ഞങ്ങൾ നെഗറ്റീവ് നമ്പറുകൾ ക്രമീകരിക്കുകയാണ്, സ്വാപ്പിന് ശേഷമുള്ള എല്ലാ നെഗറ്റീവ് നമ്പറുകളും അറേയുടെ ഇടതുവശത്ത് ക്രമീകരിക്കും, കൂടാതെ മറ്റ് എല്ലാ പോസിറ്റീവ് നമ്പറുകളും സ്വപ്രേരിതമായി വലതുവശത്ത് ക്രമീകരിക്കും അറേയുടെ. ഞങ്ങൾ‌ ചെയ്‌ത എല്ലാ സ്വാപ്പിംഗിനും ശേഷം, സ്വാപ്പിംഗ് പ്രവർ‌ത്തനങ്ങൾ‌ നടത്തിയ അറേ ഞങ്ങൾ‌ പ്രിന്റുചെയ്യേണ്ടതുണ്ട്.

നടപ്പിലാക്കൽ

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും അവസാനത്തിലേക്ക് പോസിറ്റീവിലേക്കും നീക്കുന്നതിനുള്ള സി ++ പ്രോഗ്രാം

#include<iostream>

using namespace std;

void shiftIntegers(int arr[], int n)
{
    int j = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] < 0)
        {
            if (i != j)
                swap(arr[i], arr[j]);
            j++;
        }
    }
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
}
int main()
{
    int arr[] = { 2,4,-10,13,-7,-60,52,8,-19 };
    int n = sizeof(arr) / sizeof(arr[0]);
    shiftIntegers(arr, n);

    return 0;
}
-10 -7 -60 -19 4 2 52 8 13

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും അവസാനത്തിലേക്ക് പോസിറ്റീവിലേക്കും നീക്കുന്നതിനുള്ള ജാവ പ്രോഗ്രാം

class rearrangeNegativePositive
{
    public static void shiftIntegers(int arr[], int n)
    {
        int j = 0, temp;
        for (int i = 0; i < n; i++)
        {
            if (arr[i] < 0)
            {
                if (i != j)
                {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                j++;
            }
        }
    }
    public static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
    public static void main(String args[])
    {
        int arr[] = { 2,4,-10,13,-7,-60,52,8,-19 };
        int n = arr.length;

        shiftIntegers(arr, n);
        printArray(arr, n);
    }
}
-10 -7 -60 -19 4 2 52 8 13

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും പോസിറ്റീവിലേക്കും അവസാനിപ്പിക്കുന്നതിനുള്ള സങ്കീർണ്ണ വിശകലനം

സമയ സങ്കീർണ്ണത

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം.

ബഹിരാകാശ സങ്കീർണ്ണത

O (1) അധിക ഇടം ആവശ്യമില്ലാത്തതിനാൽ.

തീരുമാനം

എല്ലാ നെഗറ്റീവ് നമ്പറുകളും ആരംഭത്തിലേക്കും പോസിറ്റീവ് ആയി ജാവയിലും സി ++ ലും സ്ഥിരമായ അധിക ഇടം ഉപയോഗിച്ച് അവസാനിപ്പിക്കുന്നതിനുള്ള ഒരു പ്രോഗ്രാമാണിത്.

അവലംബം