פּראָדוקט פון מענגע אַחוץ זיך  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַקקאָליטע אַמאַזאָן DE שאָ מאָרגאַן סטאַנלי אָפּערע
מענגע מאַט

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

"פּראָדוקט פון מענגע אַחוץ זיך" פּראָבלעם, שטאַטן אַז איר זענען געגעבן אַ מענגע אַ []. דרוקן אנדערן מענגע פּ [] פון דער זעלביקער גרייס אַזאַ ווי ווערט ביי י'ט אינדעקס פון מענגע פּ איז גלייַך צו די פּראָדוקט פון אַלע די עלעמענטן פון דער אָריגינעל מענגע אַחוץ עלעמענט ביי י'ט אינדעקס אין מענגע אַ.

בייַשפּיל  

פּראָדוקט פון מענגע אַחוץ זיךשפּילקע

a [ ] = {1, 2, 3}
{6, 3, 2}

דערקלערונג: זינט די מענגע גרייס איז 3. אויב מיר פאַרמערן די 2 & 3 עלעמענט, די פּראָדוקט איז 6. סימילאַרלי, מיר טאָן דאָס פֿאַר די 2 & 3 אינדעקס עלעמענטן. אזוי דער רעזולטאַט איז {6, 3, 2}.

a [ ] = {4, 6, 1, 2}
{12, 8, 48, 24}

ניצן דיוויזשאַן מעטאַד  

דער אופֿן איז בלויז עפעקטיוו אין די פאַל ווען אַלע מענגע עלעמענטן זענען שטענדיק גרעסער ווי 0.

אַלגאָריטהם

1. Initialize an array a[] of size n.
2. Initialize a variable prod and store product of all the elements of the array a[] in it.
3. Create another array p[] to store products of all elements except self.
4. Traverse through array a[] and update the value of array p[] such that p[i] is equal to the division of a[i] and prod.
5. Print the array p[].

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

זע אויך
Kth Largest Element אין אַ סטרים לעעטקאָדע סאַלושאַן

קאָדעקס

C ++ פּראָגראַם פֿאַר פּראָדוקטן פון מענגע אַחוץ זיך

#include <bits/stdc++.h>
using namespace std;

void prodArray(int a[], int n){
    int p[n], prod=1;
    
    //Find product of all elements of a[]
    for(int i=0; i<n; i++){
        prod = prod * a[i];
    }
    
    //Create array p[] to store
    //product except self
    for(int i=0; i<n; i++){
        p[i] = prod / a[i];
    }
    
    for(int i=0; i<n; i++){
        cout<<p[i]<<" ";
    }
}

int main() {
  int a[] = {4, 6, 1, 2};
  int n = sizeof(a)/sizeof(a[0]);
  prodArray(a,n);
  return 0;
}
12 8 48 24

Java פּראָגראַם פֿאַר פּראָדוקט פון מענגע אַחוץ זיך

class product{
    
    void prodArray(int a[], int n){
        int p[] = new int[n], prod=1;
        
        //Find product of all elements of a[]
        for(int i=0; i<n; i++){
            prod = prod * a[i];
        }
        
        //Create array p[] to store
        //product except self
        for(int i=0; i<n; i++){
            p[i] = prod / a[i];
        }
        
        for(int i=0; i<n; i++){
            System.out.print(p[i] + " ");
        }
    }
    
    public static void main(String[] args){
        product pro = new product();
    	int a[] = {4, 6, 1, 2};
    	int n = a.length;
    	pro.prodArray(a,n);
    }
}
12 8 48 24

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

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

אָ (N), וואו די נומער פון עלעמענטן איז N. ווייַל דאָ מיר ערשטער דורכגעקאָכט די מענגע וואָס אַלאַוז די אַלגערידאַם לויפן אין אָ (ען) צייט.

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

אָ (1), ווייַל מיר געוויינט קעסיידערדיק עקסטרע פּלאַץ. אָבער די פּראָגראַם אין אַלגעמיין נעמט אָרט O (N) זינט מיר סטאָרד דעם אַרייַנשרייַב.

אָן דיוויזשאַן מעטאַד  

אַלגערידאַם פֿאַר פּראָדוקט מענגע אַחוץ זיך פּראָבלעם

1. Initialize an array a[] of size n and a variable prod as 1.
2. Create another array p[] of the same size with all the elements as 1.
3. Traverse all the values from starting index to last index and update the values of array p[] such that p[i] = prod and prod = prod * a[i].
4. Initialize prod as 1 again and start traversing the array from last index to starting index.
5. Update array p[] such that p[i] = prod and prod = prod * a[i].
6. Print the array p[].

קאָדעקס

C ++ פּראָגראַם פֿאַר פּראָדוקטן פון מענגע אַחוץ זיך

#include <bits/stdc++.h>
using namespace std;

void prodArray(int a[], int n){
        
    if(n == 1) { 
        cout<<"0"; 
        return; 
    } 

    int prod = 1; 
    int p[n]; 

    /* Initialize the product array p[] as 1 */
    for(int j=0; j<n; j++) 
        p[j] = 1; 

    /* prod variable contains product of 
       elements on left side excluding a[i] */
    for(int i=0; i<n; i++) { 
        p[i] = prod; 
        prod *= a[i]; 
    } 

    /* Initialize prod to 1 for product on right side */
    prod = 1; 

    /* prod variable contains product of 
       elements on right side excluding a[i] */
    for(int i=n-1; i>=0; i--) { 
        p[i] *= prod; 
        prod *= a[i]; 
    } 
    for(int i=0; i<n; i++) 
        cout<<p[i]<<" ";

    return; 
}

int main() {
  int a[] = {4, 6, 1, 2};
  int n = sizeof(a)/sizeof(a[0]);
  prodArray(a,n);
  return 0;
}
12 8 48 24

Java פּראָגראַם פֿאַר פּראָדוקט פון מענגע אַחוץ זיך

class product{
    
    void prodArray(int a[], int n){
        
        if(n == 1) { 
            System.out.print("0"); 
            return; 
        } 
  
        int prod = 1; 
        int p[] = new int[n]; 
  
        /* Initialize the product array p[] as 1 */
        for(int j=0; j<n; j++) 
            p[j] = 1; 
  
        /* prod variable contains product of 
           elements on left side excluding a[i] */
        for(int i=0; i<n; i++) { 
            p[i] = prod; 
            prod *= a[i]; 
        } 
  
        /* Initialize prod to 1 for product on right side */
        prod = 1; 
  
        /* prod variable contains product of 
           elements on right side excluding a[i] */
        for(int i=n-1; i>=0; i--) { 
            p[i] *= prod; 
            prod *= a[i]; 
        } 
        for(int i=0; i<n; i++) 
            System.out.print(p[i] + " ");
  
        return; 
    }
    
    public static void main(String[] args){
        product pro = new product();
    	int a[] = {4, 6, 1, 2};
    	int n = a.length;
    	pro.prodArray(a,n);
    }
}
12 8 48 24

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

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

אָ (N), ווייַל דאָ מיר דורכגעגאנגען דורך די מענגע מיט גרייס N.

זע אויך
פּלוס איין לעעטקאָדע סאַלושאַן

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

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