קייפל פון פֿריִערדיקע און ווייַטער  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַקסענטורע אַקקאָליטע אַדאָובי פאַקסעט UHG Optum
מענגע

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

קייפל פון פֿריִערדיקע און ווייַטער: אין דער געגעבן מענגע פאַרבייַטן יעדער עלעמענט מיט די פּראָדוקט פון ווייַטער און פרייַערדיק עלעמענטן. און פֿאַר דער ערשטער עלעמענט (אַ [0]) מיר דאַרפֿן צו פאַרבייַטן עס מיט די פּראָדוקט פון ווייַטער און זיך, פֿאַר די לעצטע עלעמענט (אַ [n-1]) מיר דאַרפֿן צו פאַרבייַטן עס מיט די פּראָדוקט פון פריער און זיך).

בייַשפּיל  

אַרייַנשרייַב

9

4 8 6 9 12 2 43 2 1

רעזולטאַט

32 24 72 72 18 516 4 43 2

אַלגערידאַם פֿאַר קייפל פון פֿריִערדיקע און ווייַטער  

שריט קסנומקס: שאַפֿן אַ בייַטעוודיק צו קראָם די פריערדיקע עלעמענט פון די מענגע. מיר סטאָרד דעם אַזאַ ווי קיין עקסטרע פּלאַץ געוויינט.
a) דער ערשטער עלעמענט איז דער פּראָדוקט פון ערשטער און רגע.
ב) די ווייַטערדיקע עלעמענטן וועלן זיין די פּראָדוקט פון די פריערדיקע און די ווייַטערדיקע.

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

שריט קסנומקס: די לעצטע עלעמענט וועט זיין דער פּראָדוקט פון די לעצטע און פרייַערדיק.

זע אויך
דרוק אַלע סובאַררייַס מיט 0 סומע

שריט קסנומקס: דרוק דעם מענגע צו זען צי עס איז דערהייַנטיקט אָדער נישט.

ימפּלעמענטאַטיאָן  

C ++ פּראָגראַם פֿאַר קייפל פון פֿריִערדיקע און ווייַטער

#include <bits/stdc++.h>
using namespace std;
int main()
{
  
  int n;
  cin>>n;
  int a[n];
  for(int i=0;i<n;i++)
  {
      cin>>a[i];
  }
  int prev=a[0],temp; // previous element to be stored so that no extra space is used.
  a[0]=a[0]*a[1];
  cout<<a[0]<<"  ";
  for(int i=1;i<n-1;i++)
  {
    temp=prev;
    prev=a[i];//set previous to this element
    a[i]=a[i+1]*temp; // multiply prev and forward element
    cout<<a[i]<<"  ";
  }
  a[n-1]=a[n-1]*prev;
  cout<<a[n-1];
  return 0;
}

Java פּראָגראַם פֿאַר קייפל פון פֿריִערדיקע און ווייַטער

import java.util.Arrays;
import java.util.Scanner;
class sum
{
    public static void main(String[] args)  
    { 
        Scanner sr = new Scanner(System.in);
        int n = sr.nextInt();
        int arr[] = new int[n];
        for(int i=0;i<n;i++)
        {
            arr[i] = sr.nextInt();
        }
        int prev=arr[0],temp; // previous element to be stored so that no extra space is used.
        arr[0]=arr[0]*arr[1];
        System.out.print(arr[0]+"  ");
        for(int i=1;i<n-1;i++)
        {
          temp=prev;
          prev=arr[i];//set previous to this element
          arr[i]=arr[i+1]*temp; // multiply prev and forward element
          System.out.print(arr[i]+"  ");
        }
        arr[n-1]=arr[n-1]*prev;
        System.out.println(arr[n-1]);
    }
}
5
1 2 3 4 5
2  3  8  15  20

קאַמפּלעקסיטי אַנאַליסיס פֿאַר קייפל פון פֿריִערדיקע און ווייַטער  

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

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

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

אָ (1) ווייַל מיר נוצן בלויז אַ ביסל וועריאַבאַלז צו קראָם די פריערדיקע ווערט און ענטפֿערן פֿאַר יעדער אינדעקס.

רעפֿערענצן