ריעריינדזש אַ מענגע אַזוי אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַמאַזאָן דעליווערי Kuliza Nagarro אָפּערע Times אינטערנעט יאַטראַ
מענגע

פּראָבלעם סטאַטעמענט

די פּראָבלעם "ריעריינדזש אַ מענגע אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'" שטאַטן אַז איר האָט אַן “N” סייזד מענגע מיט ינטאַדזשערז. די נומערן אין די מענגע זענען אין אַ קייט פון 0 צו n-1. די פּראָבלעם ויסזאָגונג פרעגט צו ריעריינדזש די מענגע אַזוי אַז די מענגע [i] = j ווערט אַרר [j] = i.

בייַשפּיל

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

דערקלערונג

אַרר [0] = 1 איז געביטן צו אַרר [1] = 0

אַרר [1] = 3 איז געביטן צו אַרר [3] = 1

אַרר [2] = 5 איז געביטן צו אַרר [5] = 2

אַרר [3] = 2 איז געביטן צו אַרר [2] = 3

אַרר [4] = 0 איז געביטן צו אַרר [0] = 4

אַרר [5] = 4 איז געביטן צו אַרר [4] = 5

אַזוי ווען געדרוקט ⇒

אַרר [0] ⇒ אַרר [1] ⇒ אַרר [2] ⇒ אַרר [3] ⇒ אַרר [4] ⇒ אַרר [5]

קסנומקס קסנומקס קסנומקס קסנומקס קסנומקס קסנומקס

אַלגערידאַם צו ריעריינדזש אַ מענגע אַזאַ אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'

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 מענגע. אַזוי אַז די עלעמענטן אין דער מענגע ווערן אַזוי אַז אַרר [j] = i אויב עס איז אַרר [i] = j. אזוי, דאָס מיינט אַז אויב מיר האָבן עטלעכע ווערט ביי יט שטעלע ווי דזש, דאַן טוישן דעם ווערט צו די דזשט שטעלע פון ​​אַ מענגע. מיר אויך געבן מענגע עלעמענטן אין די קייט 0 צו N-1. אַזוי די נומער קען נישט יקסיד די לענג פון אַ מענגע. אַזוי עס קען זיין וווילטויק ווען מיר אַריבער די מענגע, מיר קענען נעמען קיין נומער ווערט ווי אַן אינדעקס און דורכפירן עטלעכע אַפּעריישאַנז אויף אים.

ווייַל מיר וועלן דורכפירן עטלעכע אַפּעריישאַנז אויף די מענגע זיך. מיר קלייַבן יעדער מענגע עלעמענט און געפֿינען די modulo פון אַרר [i]% n, ווו n איז די לענג פון אַ מענגע. איצט, ווי מיר דערמאנט אַז די נומערן זענען אין די קייט פון 0 צו n-1. אַזוי ווען מיר געפֿינען די מאָדולאָ פון קיין נומער מיט די n. עס וועט נישט יקסיד די נומער גרעסער ווי אַן אינדעקס פון די מענגע, ווייַל די מאָדולאָ פון אַרר [i]% n וועט זיין באהאנדלט ווי אַן אינדעקס פון מענגע. דערנאָך מיר קראָם עס אין די קייפל פון i * n. דערהייַנטיקן יעדער ווערט פון מאָדולאָ ווי אַן אינדעקס פון די מענגע און סומע עס מיט זיך.

מיר נאָר טאָן דאָס צו קראָם און דערהייַנטיקן די וואַלועס אין די מענגע אויב מיר וועלן צו ברענגען זיי. מיר נאָר האָבן צו טיילן זיי. ווייַל אויב איר מערן די נומער מיט X און טיילן מיט די X, די נומער וועט ווערן נייטראַל ווי עס איז. דערהייַנטיקן די אַרר [i] דורך דיוויידינג די זעלבע אַרר [i] דורך n און סטאָר עס צו אַרר [i]. אין דעם וועג, מיר וועלן באַקומען די געבעטן רעזולטאַט. אַז ס ווי צו ריעריינדזש אַ מענגע אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'.

ריעריינדזש אַ מענגע אַזוי אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'

קאָדעקס

C ++ קאָד צו ריעריינדזש אַ מענגע אַזוי אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'

#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

Java קאָד צו ריעריינדזש אַ מענגע אַז 'אַרר [דזש]' ווערט 'איך' אויב 'אַרר [איך]' איז 'דזש'

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

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין דער מענגע. אפילו כאָטש מיר דורכגעקאָכט די עלעמענטן פון די מענגע צוויי מאָל. אַזוי, דאָס נאָך קאַונץ בלויז ווי בלויז לינעאַר קאַמפּלעקסיטי.

ספעיס קאַמפּלעקסיטי

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין דער מענגע. זינט מיר האָבן נישט סטאָרד עפּעס וואָס איז שייך צו יעדער עלעמענט און מיר האָבן בלויז גענומען אַ קעסיידערדיק פּלאַץ. אַזוי די פּלאַץ קאַמפּלעקסיטי פֿאַר די אַלגערידאַם איז קעסיידערדיק.