ప్లస్ వన్ లీట్‌కోడ్ సొల్యూషన్


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe అమెజాన్ ఆపిల్ కాపిటల్ వన్ <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> గూగుల్ మైక్రోసాఫ్ట్
అర్రే

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

”ప్లస్ వన్” సమస్యలో మనకు శ్రేణి ఇవ్వబడుతుంది, ఇక్కడ శ్రేణిలోని ప్రతి మూలకం సంఖ్య యొక్క అంకెను సూచిస్తుంది. పూర్తి శ్రేణి సంఖ్యను సూచిస్తుంది. సున్నా సూచిక సూచిస్తుంది ఎంఎస్‌బి సంఖ్య యొక్క. ఈ సంఖ్యలో సున్నా లేదు అని మనం అనుకోవచ్చు.

ఇచ్చిన పని సంఖ్యను ప్లస్ వన్ చేసి, ఫలితాన్ని శ్రేణి రూపంలో తిరిగి ఇవ్వడం మా పని.

ఉదాహరణ

digits =[4,3,2,1]
[4,3,2,2]

వివరణ:

ప్లస్ వన్ లీట్‌కోడ్ సొల్యూషన్

ఇచ్చిన ఉదాహరణలో వలె, శ్రేణి 4321 ను సూచిస్తుంది మరియు 4321 + 1 4322 అవుతుంది. కాబట్టి మేము 4322 ను తిరిగి ఇచ్చాము.

ప్లస్ వన్ లీట్‌కోడ్ సొల్యూషన్ కోసం అప్రోచ్

ప్రతి ఒక్కరి మనస్సులోకి వచ్చే మొదటి ఆలోచన ఏమిటంటే, ఇచ్చిన శ్రేణిని సంఖ్యగా మార్చడం, అదనంగా ఆపరేషన్ చేయడం, ఆపై ఫలితాన్ని శ్రేణి రూపంలో తిరిగి ఇవ్వడం.

కానీ ఈ ఆలోచన పెద్ద పరిమాణ శ్రేణికి విఫలమవుతుంది ఎందుకంటే ఇది ఏ డేటా రకానికి సరిపోదు.

కాబట్టి, మేము ప్రతి అంకెను ఒక్కొక్కటిగా ప్రాసెస్ చేయాలి.

  1. LSB నుండి ప్రారంభించి, ఆపై MSB వరకు ప్రతి అంకెను ప్రాసెస్ చేయండి.
  2. ప్రస్తుత అంకె 9 కన్నా తక్కువగా ఉంటే, ప్రస్తుత అంకెకు ఒకదాన్ని జోడించి, శ్రేణిని తిరిగి ఇవ్వండి, లేకపోతే ప్రస్తుత అంకెకు సున్నా కేటాయించండి.
  3. చివరి మూలకం ప్రాసెస్ చేయబడి, అది 9 కి సమానంగా ఉంటే, అన్ని అంకెలు 9 అని అర్ధం. కాబట్టి, మేము శ్రేణి యొక్క పరిమాణాన్ని ఒకదానితో పెంచుతాము మరియు MSB కి 1 ని కేటాయిస్తాము.
  4. శ్రేణిని తిరిగి ఇవ్వండి

అమలు

ప్లస్ వన్ కోసం సి ++ కోడ్

#include <bits/stdc++.h> 
using namespace std; 
    vector<int> plusOne(vector<int>& digits) {
        int n=digits.size();
        for(int i=n-1;i>=0;i--)
        {
            if(digits[i]<9)
            {digits[i]++ ; return digits;} 
            else
                digits[i]=0;
        }
        vector<int>newnumber(n+1,0);
        newnumber[0]=1;
        return newnumber;
    }
int main() 
{ 
 vector<int> arr = {4,3,2,1}; 
  vector<int>ans= plusOne(arr); 
 for(int i=0;i<arr.size();i++)
 cout<<ans[i]<<" ";
 cout<<endl;
 return 0;
}
[4,3,2,2]

ప్లస్ వన్ కోసం జావా కోడ్

import java.util.Arrays; 
public class Tutorialcup {
public static int[] plusOne(int[] digits) {
        
    int n = digits.length;
    for(int i=n-1; i>=0; i--) {
        if(digits[i] < 9) {
            digits[i]++; return digits;
        }
        digits[i] = 0;
    }
    
    int[] newNumber = new int [n+1];
    newNumber[0] = 1;
    return newNumber;
}
  public static void main(String[] args) {
        int [] arr = {4,3,2,1}; 
        int[]ans=plusOne(arr); 
        System.out.println(Arrays.toString(ans));
  }
}
[4,3,2,2]

ప్లస్ వన్ లీట్‌కోడ్ సొల్యూషన్ యొక్క సంక్లిష్టత విశ్లేషణ

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

పై కోడ్ యొక్క సమయం సంక్లిష్టత పై) ఎందుకంటే మేము అంకెల శ్రేణిని ఒక్కసారి మాత్రమే ప్రయాణిస్తున్నాము. ఇక్కడ n అనేది అంకెల శ్రేణి యొక్క పొడవు.

స్థల సంక్లిష్టత

పై కోడ్ యొక్క స్థల సంక్లిష్టత O (1)  ఒకవేళ శ్రేణి కనీసం 9 కంటే చిన్న అంకెను కలిగి ఉంటుంది, లేకపోతే పై).

ప్రస్తావనలు