'Arr [i]' 'j' ആണെങ്കിൽ 'arr [j]' 'i' ആയി മാറുന്ന ഒരു ശ്രേണി പുന range ക്രമീകരിക്കുക.  


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു ആമസോൺ ദില്ലി കുലിസ നാഗാരോ Opera ടൈംസ് ഇന്റർനെറ്റ് യാത്ര
അറേ

പ്രശ്നം പ്രസ്താവന  

“Ar [i] '' j 'ആണെങ്കിൽ' arr [j] '' i 'ആയിത്തീരുന്ന ഒരു ശ്രേണി പുന range ക്രമീകരിക്കുക” “N” പൂർണ്ണസംഖ്യകൾ അടങ്ങിയ വലുപ്പ അറേ. അറേയിലെ സംഖ്യകൾ 0 മുതൽ n-1 വരെയാണ്. [I] = j അറേ അറ [j] = i ആകുന്ന തരത്തിൽ അറേ പുന range ക്രമീകരിക്കാൻ പ്രശ്ന പ്രസ്താവന ആവശ്യപ്പെടുന്നു.

ഉദാഹരണം  

arr[]={1,3,5,2,0,4}
4 0 3 1 5 2

വിശദീകരണം

arr [0] = 1 arr [1] = 0 ആയി മാറ്റി

arr [1] = 3 arr [3] = 1 ആയി മാറ്റി

arr [2] = 5 arr [5] = 2 ആയി മാറ്റി

arr [3] = 2 arr [2] = 3 ആയി മാറ്റി

arr [4] = 0 arr [0] = 4 ആയി മാറ്റി

arr [5] = 4 arr [4] = 5 ആയി മാറ്റി

അതിനാൽ അച്ചടിക്കുമ്പോൾ

arr [0] ⇒ arr [1] ⇒ arr [2] ⇒ arr [3] ⇒ arr [4] ⇒ arr [5]

4 0 3 XIX XIX 1

ഒരു അറേ പുന ar ക്രമീകരിക്കാനുള്ള അൽ‌ഗോരിതം, 'arr [j]' 'i' ആയിത്തീർന്നാൽ 'arr [i]' 'j' ആണെങ്കിൽ  

1. Traverse the array from 0 to n-1(inclusively).
    1. Do arr [ arr % n ] + = i * n.
2. Then update the value of arr[ i ] =arr[ i ] / n.
3. Print the array.

വിശദീകരണം

ഒരു നൽകി ശ്രേണി of പൂർണ്ണസംഖ്യകൾ. ഇത് കൈവശമുള്ള അക്കങ്ങൾ 0 മുതൽ n - 1 വരെയാണ്. ഞങ്ങൾ pf അറേ നമ്പറുകൾ പുന range ക്രമീകരിക്കും. അതിനാൽ അറേയിലെ ഘടകങ്ങൾ arr [j] = i ആണെങ്കിൽ അത് arr [i] = j ആണെങ്കിൽ. ഇതിനർത്ഥം, j എന്ന സ്ഥാനത്ത് നമുക്ക് കുറച്ച് മൂല്യമുണ്ടെങ്കിൽ, ആ മൂല്യം ഒരു അറേയുടെ jth സ്ഥാനത്തേക്ക് മാറ്റുക. കൂടാതെ, 0 മുതൽ n-1 വരെയുള്ള ശ്രേണിയിലെ അറേ ഘടകങ്ങൾ ഞങ്ങൾ നൽകി. അതിനാൽ സംഖ്യ ഒരു അറേയുടെ ദൈർഘ്യം കവിയരുത്. അതിനാൽ ഞങ്ങൾ അറേയിലൂടെ സഞ്ചരിക്കുമ്പോൾ ഇത് പ്രയോജനകരമാകും, നമുക്ക് ഒരു സംഖ്യയെ ഒരു സൂചികയായി എടുത്ത് അതിൽ ചില പ്രവർത്തനങ്ങൾ നടത്താം.

ഇതും കാണുക
ഡീകോഡ് വഴികൾ

കാരണം ഞങ്ങൾ അറേയിൽ തന്നെ ചില പ്രവർത്തനങ്ങൾ നടത്താൻ പോകുന്നു. ഞങ്ങൾ ഓരോ അറേ ഘടകങ്ങളും തിരഞ്ഞെടുത്ത് കണ്ടെത്തും മൊഡ്യൂൾ ന്റെ [i]% n, ഇവിടെ n എന്നത് ഒരു അറേയുടെ നീളം. ഇപ്പോൾ, നമ്മൾ നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, സംഖ്യകൾ 0 മുതൽ n-1 വരെയാണ്. അതിനാൽ n ഉള്ള ഏത് സംഖ്യയുടെയും മൊഡ്യൂൾ കണ്ടെത്തുമ്പോൾ. ഇത് അറേയുടെ ഒരു സൂചികയേക്കാൾ വലിയ സംഖ്യ കവിയരുത്, കാരണം arr [i]% n ന്റെ മൊഡ്യൂളോ വീണ്ടും അറേയുടെ സൂചികയായി കണക്കാക്കും. എന്നിട്ട് അതിനെ i * n ന്റെ ഗുണനത്തിൽ സൂക്ഷിക്കുന്നു. മൊഡ്യൂളിന്റെ ഓരോ മൂല്യവും അറേയുടെ സൂചികയായി അപ്‌ഡേറ്റുചെയ്‌ത് അത് സ്വയം സംഗ്രഹിക്കുക.

മൂല്യങ്ങൾ ലഭ്യമാക്കാൻ പോകുകയാണെങ്കിൽ അറേയിലെ മൂല്യങ്ങൾ സംഭരിക്കുന്നതിനും അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുമാണ് ഞങ്ങൾ ഇത് ചെയ്യുന്നത്. നമ്മൾ അവയെ വിഭജിക്കണം. കാരണം നിങ്ങൾ സംഖ്യയെ x ഉപയോഗിച്ച് ഗുണിച്ച് x- മായി വിഭജിച്ചാൽ സംഖ്യ നിഷ്പക്ഷമാകും. ഒരേ arr [i] നെ n കൊണ്ട് ഹരിച്ചാൽ arr [i] അപ്‌ഡേറ്റുചെയ്‌ത് arr [i] ലേക്ക് സംഭരിക്കുക. ഈ രീതിയിൽ, ഞങ്ങൾക്ക് ആവശ്യമുള്ള ഫലം ലഭിക്കും. അങ്ങനെയാണ് ഒരു അറേ പുന ar ക്രമീകരിക്കുന്നത്, 'arr [j]' 'i' ആണെങ്കിൽ 'arr [i]' 'j' ആണെങ്കിൽ.

'Arr [i]' 'j' ആണെങ്കിൽ 'arr [j]' 'i' ആയി മാറുന്ന ഒരു ശ്രേണി പുന range ക്രമീകരിക്കുക.

കോഡ്  

ഒരു അറേ പുന range ക്രമീകരിക്കുന്നതിനുള്ള സി ++ കോഡ് 'arr [j]' 'arr' i ആണെങ്കിൽ 'i' ആയി മാറുന്നു.

#include<iostream>

using namespace std;

void rearrangeIndexValue(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        arr[arr[i] % n] += i * n;
    }

    for (int i = 0; i < n; i++)
    {
        arr[i] /= n;
    }
}
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = { 1,3,5,2,0,4};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Array after modifying :";
    rearrangeIndexValue(arr,n);
    printArray(arr, n);

    return 0;
}
Array after modifying :4 0 3 1 5 2

ഒരു അറേ പുന range ക്രമീകരിക്കുന്നതിനുള്ള ജാവ കോഡ് 'arr [j]' 'i' ആണെങ്കിൽ 'arr [i]' 'j' ആണെങ്കിൽ

class rearrangeArray2
{
    public static void rearrangeIndexValue(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
        {
            arr[arr[i] % n] += i * n;
        }
        for (int i = 0; i < n; i++)
        {
            arr[i] /= n;
        }
    }
    public static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args)
    {
        int arr[] = { 1,3,5,2,0,4};
        int n = arr.length;

        rearrangeIndexValue(arr, n);

        System.out.print("Array after modifying : ");
        printArray(arr, n);
    }
}
Array after modifying : 4 0 3 1 5 2

സങ്കീർണ്ണത വിശകലനം  

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

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. അറേയിലെ ഘടകങ്ങളെ ഞങ്ങൾ രണ്ടുതവണ സഞ്ചരിച്ചെങ്കിലും. അതിനാൽ, ഇത് ഇപ്പോഴും രേഖീയ സമയ സങ്കീർണ്ണതയായി മാത്രം കണക്കാക്കുന്നു.

ഇതും കാണുക
ഒരേ തുല്യവും വിചിത്രവുമായ ഘടകങ്ങൾ ഉപയോഗിച്ച് സബ്‌റേകൾ എണ്ണുക

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

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. ഓരോ ഘടകവുമായി ബന്ധപ്പെട്ട ഒന്നും ഞങ്ങൾ സംഭരിക്കാത്തതിനാൽ സ്ഥിരമായ ഇടം മാത്രം എടുക്കുന്നു. അതിനാൽ, അൽഗോരിത്തിനായുള്ള സ്ഥല സങ്കീർണ്ണത സ്ഥിരമാണ്.