1d అర్రే లీట్‌కోడ్ సొల్యూషన్ మొత్తం నడుస్తోంది


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe అమెజాన్ ఆపిల్ బ్లూమ్బెర్గ్ ఉబెర్
అర్రే

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

1d మొత్తం నడుస్తున్నప్పుడు అమరిక సమస్య మనకు శ్రేణి సంఖ్యలు ఇవ్వబడ్డాయి, దీని కోసం మేము శ్రేణిని తిరిగి ఇవ్వాలి, ఇక్కడ ప్రతి సూచిక i ఫలిత శ్రేణి అర్ [i] = మొత్తం (సంఖ్యలు [0]… సంఖ్యలు [i]).

ఉదాహరణ

 nums = [1,2,3,4]
[1,3,6,10]

వివరణ:

నడుస్తున్న మొత్తం: [1, 1 + 2, 1 + 2 + 3, 1 + 2 + 3 + 4] = [1, 3, 6, 10]

nums = [1,1,1,1,1]
[1,2,3,4,5]

వివరణ:

నడుస్తున్న మొత్తం: [1, 1 + 1, 1 + 1 + 1, 1 + 1 + 1 + 1, 1 + 1 + 1 + 1 + 1] = [1, 2, 3, 4, 5]

అప్రోచ్

ఈ సమస్యలో మనం ఒక శ్రేణిని సృష్టించాలి, ఇక్కడ ఇండెక్స్ i లోని మూలకం యొక్క విలువ 1 వ శ్రేణి నుండి ఇచ్చిన శ్రేణిలోని ith ఇండెక్స్డ్ ఎలిమెంట్ వరకు ఉన్న మూలకాల మొత్తానికి సమానంగా ఉంటుంది.
దీని కోసం మనం ఇచ్చిన శ్రేణి పరిమాణానికి సమానమైన పరిమాణ శ్రేణిని సృష్టించవచ్చు. ఒక ఫర్ లూప్‌లోని ప్రతి మూలకం కోసం మనం లూప్ కోసం మరొకదాన్ని ఉపయోగించి అసలు శ్రేణిలో ఇండెక్స్ 0 నుండి ఇండెక్స్ i కి మూలకాన్ని జోడించవచ్చు. ఈ అల్గోరిథం యొక్క సమయ సంక్లిష్టత O (n ^ 2) అవుతుంది.

సింగిల్‌ను మాత్రమే ఉపయోగించడం ద్వారా ఈ సమస్యకు సమయం సంక్లిష్టతను తగ్గించవచ్చు లూప్.
సంఖ్యలు ఇచ్చిన శ్రేణిగా ఉండండి మరియు రెస్ మేము నడుస్తున్న మొత్తాన్ని నిల్వ చేస్తున్న శ్రేణిగా ఉండనివ్వండి, అప్పుడు మేము res [i] ను ఈ క్రింది విధంగా లెక్కించవచ్చు:

res [i] = res [i-1] + nums [i].

ఉదాహరణ: సంఖ్యలు = [1,2,3,4] క్రింద ఉన్న చిత్రంలో చూపబడింది,

1d అర్రే లీట్‌కోడ్ సొల్యూషన్ మొత్తం నడుస్తోంది

అందువల్ల ఉపసర్గ మొత్తాన్ని మళ్లీ లెక్కించడానికి మనం లూప్ కోసం రన్ చేయనవసరం లేదు, ఎందుకంటే మునుపటి సూచిక రెస్ అర్రేలో నేను నిల్వ చేసిన ఇండెక్స్ వరకు మనకు ఇప్పటికే మొత్తం ఉంది.

అమలు

1 డి అర్రే లీట్‌కోడ్ సొల్యూషన్ మొత్తాన్ని అమలు చేయడానికి సి ++ ప్రోగ్రామ్

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

vector<int> runningSum(vector<int>& nums) 
{
    vector<int> res(nums.size());
    if(nums.size()==0) return res;

    res[0]=nums[0];
    for(int i=1;i<nums.size();i++)
    {
        res[i]=res[i-1]+ nums[i];
    }

    return res;

}

int main() 
{
  vector<int> nums={1,2,3,4};
  vector<int> res= runningSum(nums);
  
  cout<<"[";
  
  for(int i=0;i<res.size()-1;i++) cout<<res[i]<<",";
  
  cout<<res.back()<<"]"<<endl;

  return 0; 
}
[1,3,6,10]

1 డి అర్రే లీట్‌కోడ్ సొల్యూషన్ మొత్తాన్ని అమలు చేయడానికి జావా ప్రోగ్రామ్

import java.lang.*;

class Rextester
{  
    public static int[] runningSum(int[] nums) 
    {
        int[] res= new int[nums.length];
        if(nums.length==0) return res;

        res[0]=nums[0];
        for(int i=1;i<nums.length;i++)
        {
            res[i]=res[i-1]+ nums[i];
        }

        return res;
    }
    
    public static void main(String args[])
    {
        int nums[]={1,2,3,4};
        int res[]= runningSum(nums);

        System.out.print("[");

        for(int i=0;i<res.length-1;i++) System.out.print(res[i]+",");

        System.out.println( res[res.length-1] + "]");
        
    }
}
[1,3,6,10]

1 డి అర్రే లీట్‌కోడ్ సొల్యూషన్ మొత్తాన్ని అమలు చేయడానికి సంక్లిష్టత విశ్లేషణ

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

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

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

పై) : ఇక్కడ మనం n యొక్క పరిమాణ శ్రేణి ఫలిత శ్రేణిని సృష్టిస్తున్నాము. అందువల్ల స్థల సంక్లిష్టత కూడా సరళంగా ఉంటుంది.