ఉత్పత్తి శ్రేణి పజిల్  


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అకోలైట్ Adobe అమెజాన్ ఆపిల్ asana నలుపు రాయి బ్లూమ్బెర్గ్ ByteDance సిటాడెల్ డిఇ షా eBay Evernote Expedia ద్వారా <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> గోల్డ్మన్ సాచ్స్ గూగుల్ Houzz ఇంటెల్ లింక్డ్ఇన్ లిఫ్ట్ మైక్రోసాఫ్ట్ మోర్గాన్ స్టాన్లీ నూటనిక్స్ ఒపేరా ఒరాకిల్ పేపాల్ Paytm Qualtrics అమ్మకాల బలం SAP ServiceNow Snapchat Splunk పట్టిక <span style="font-family: Mandali; ">ట్విట్టర్</span> ఉబెర్ వీసా VMware వాల్‌మార్ట్ ల్యాబ్స్ యాహూ Yandex
అర్రే Groupon లీట్‌కోడ్

సమస్యల నివేదిక  

ఒక ఉత్పత్తిలో అమరిక పజిల్ సమస్య మనం ఒక శ్రేణిని నిర్మించాల్సిన అవసరం ఉందిth i వద్ద మూలకం మినహా ఇచ్చిన శ్రేణిలోని అన్ని మూలకాల యొక్క మూలకం మూలకంth స్థానం.

ఉదాహరణ  

ఇన్పుట్ 

5

10 3 5 6 2

అవుట్పుట్

180 600 360 300 900

ఉత్పత్తి శ్రేణి సమస్యను పరిష్కరించడానికి అల్గోరిథం  

1 దశ: ఉత్పత్తులను నిల్వ చేయడానికి వెక్టర్ ఉత్పత్తిని తీసుకోండి.
a) వెక్టర్ ఉత్పత్తి ద్వారా దీన్ని ప్రారంభించండి

2 దశ: రెండు శ్రేణులను ఎడమ [] మరియు కుడి [], ఎడమ స్టోర్లలోని అంశాల ఉత్పత్తిని శ్రేణిలోని ith సూచిక యొక్క ఎడమ వైపున నిర్మించండి. ith సూచిక యొక్క కుడి మూలకాల ఉత్పత్తి.

a. ఎడమ యొక్క మొదటి మూలకాన్ని 1 గా మరియు కుడి యొక్క చివరి మూలకాన్ని 1 గా ప్రారంభించండి.
బి. ఎడమ నుండి, ఎడమ శ్రేణి యొక్క మునుపటి మూలకంతో ఇచ్చిన శ్రేణి యొక్క i-1 వ మూలకం యొక్క ఉత్పత్తితో ఎడమ శ్రేణి యొక్క ith మూలకాలను నవీకరించండి. (ఎడమ [i] = ఎడమ [i-1] * శ్రేణి [i-1]). ఇలా చేయడం ద్వారా, ఇది ఇచ్చిన శ్రేణి నుండి ఎడమ శ్రేణిలోని మునుపటి సూచిక వరకు ఉత్పత్తిని నిల్వ చేస్తుంది.
సి. కుడి నుండి, ఇచ్చిన శ్రేణి యొక్క i + 1 వ మూలకం యొక్క ఉత్పత్తితో కుడి శ్రేణి యొక్క ith మూలకాలను కుడి శ్రేణి యొక్క తదుపరి మూలకంతో నవీకరించండి. (కుడి [i] = కుడి [i + 1] * శ్రేణి [i + 1]). ఇలా చేయడం ద్వారా, ఇది ఇచ్చిన శ్రేణి నుండి ఎడమ శ్రేణిలోని మునుపటి సూచిక వరకు ఉత్పత్తిని నిల్వ చేస్తుంది.

ఇది కూడ చూడు
శ్రేణిని జిగ్-జాగ్ ఫ్యాషన్‌గా మార్చండి

3 దశ:  ప్రస్తుత మూలకం మినహా ఉత్పత్తి ఎడమ మరియు కుడి శ్రేణుల మూలకాల ఉత్పత్తికి సమానంగా ఉంటుంది.
a) ఉత్పత్తి శ్రేణి ఉంటుంది, ఉత్పత్తి [i] = ఎడమ [i] * కుడి [i].

ఉత్పత్తి శ్రేణి పజిల్ పరిష్కరించడానికి వివరణ  

మొదట, శ్రేణిని మొదటి నుండి ప్రయాణించి, ప్రతి i కోసం మునుపటి అన్ని మూలకాల ఉత్పత్తిని నిల్వ చేయండి. ఇప్పుడు వెనుక నుండి శ్రేణిని దాటి, మొత్తాన్ని చివరి నుండి నిల్వ చేసి, ఆ మూలకం తర్వాత అన్ని మూలకాల ఉత్పత్తిని నిల్వ చేయండి.

ఎడమ [] = {10, 30, 150, 900, 1800}

కుడి [] = {1800, 180, 60, 12, 2}

ఇప్పుడు ఈ శ్రేణిని ఉపయోగించి i వద్ద మూలకం మినహా ఇచ్చిన శ్రేణిలోని అన్ని మూలకాల ఉత్పత్తిని కనుగొనండిth స్థానం.

ఉత్పత్తి [] = {180, 600, 360, 300, 900}

అమలు  

ఉత్పత్తి శ్రేణి సమస్యను పరిష్కరించడానికి సి ++ ప్రోగ్రామ్

#include <bits/stdc++.h>
using namespace std;
int main()
{
  
  int n;
  cin>>n;
  int arr[n];
  for(int i=0;i<n;i++)
  {
      cin>>arr[i];
  }
  int left[n],right[n];
  vector<int> product;
  left[0] = 1; //initialize the first element as 1
  for(int i=1;i<n;i++)
  {
     left[i]=left[i-1]*arr[i-1]; // store the product till just previous index
  }
  right[n-1]=1;//initialzie the first element as 1
  for(int i=n-2;i>=0;i--)
  {
     right[i]=right[i+1]*arr[i+1]; //store the product till just next index
  } 
  for(int i=0;i<n;i++)
  {
     product.push_back(left[i]*right[i]);
  }
  for(int i=0;i<n;i++)//display the product array
  {
     cout<<product[i]<<"  "; 
  }
  return 0;
}

ఉత్పత్తి శ్రేణి సమస్యను పరిష్కరించడానికి జావా ప్రోగ్రామ్

import java.util.Arrays;
import java.util.Scanner;
import java.util.Vector;
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 left[] = new int [n];
        int right[] = new int [n];
        Vector<Integer> product = new Vector<Integer>(); 
        left[0] = 1; //initialize the first element as 1
        for(int i=1;i<n;i++)
        {
           left[i]=left[i-1]*arr[i-1]; // store the product till just previous index
        }
        right[n-1]=1;//initialzie the first element as 1
        for(int i=n-2;i>=0;i--)
        {
           right[i]=right[i+1]*arr[i+1]; //store the product till just next index
        } 
        for(int i=0;i<n;i++)
        {
           product.add(left[i]*right[i]);
        }
        for(int i=0;i<n;i++)//display the product array
        {
           System.out.print(product.get(i)+"  "); 
        }
    }
}
5
10 3 5 6 2
180  600  360  300  900

సంక్లిష్టత విశ్లేషణ  

సమయం సంక్లిష్టత

ఇది కూడ చూడు
రెండు చెట్లు ఒకేలా ఉన్నాయో లేదో నిర్ణయించడానికి కోడ్ రాయండి

పై) ఇక్కడ n అనేది శ్రేణిలో ఉన్న మూలకాల సంఖ్య. ఇక్కడ మేము 3 సార్లు మాత్రమే ప్రయాణించి ఉత్పత్తి శ్రేణిని కనుగొంటాము.

అంతరిక్ష సంక్లిష్టత

పై) ఎందుకంటే మూలకాల ఉత్పత్తులను నిల్వ చేయడానికి మేము ఎడమ మరియు కుడి శ్రేణులను ఉపయోగిస్తాము.

ప్రస్తావనలు