પ્લસ વન લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એડોબ એમેઝોન સફરજન કેપિટલ વન ફેસબુક Google માઈક્રોસોફ્ટ
અરે

સમસ્યા નિવેદન

સમસ્યા "પ્લસ વન" માં આપણને એરે આપવામાં આવે છે જ્યાં એરેમાં દરેક એલિમેન્ટ એક નંબરનો અંકો રજૂ કરે છે. સંપૂર્ણ એરે સંખ્યાને રજૂ કરે છે. ઝીરોથ ઇન્ડેક્સ એમ.એસ.બી. સંખ્યા છે. આપણે ધારી શકીએ કે સંખ્યામાં કોઈ અગ્રણી શૂન્ય નથી.

આપણું કાર્ય એ આપેલ નંબરને વત્તા એક કરવાનું છે અને તે પછી પરિણામને એરેના રૂપમાં પાછું આપે છે.

ઉદાહરણ

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

સમજૂતી:

પ્લસ વન લીટકોડ સોલ્યુશન

આપેલ ઉદાહરણ મુજબ, એરે 4321 રજૂ કરે છે અને 4321 + 1 4322 બને છે. તેથી અમે 4322 પરત ફર્યા.

પ્લસ વન લીટકોડ સોલ્યુશન માટે અભિગમ

દરેકના મનમાં પ્રથમ વિચાર એ છે કે આપેલ એરેને સંખ્યામાં રૂપાંતરિત કરવું, એક operationપરેશન .પરેશન કરવું અને પછી પરિણામને એરેના રૂપમાં પાછું આપવું.

પરંતુ આ વિચાર મોટા કદના એરે માટે નિષ્ફળ જશે કારણ કે તે કોઈપણ ડેટા પ્રકારમાં બંધ બેસશે નહીં.

તેથી, આપણે દરેક અંકો પર એક પછી એક પ્રક્રિયા કરવાની જરૂર છે.

  1. એલએસબીથી પ્રારંભ કરો અને પછી એમએસબી સુધી દરેક અંકો પર પ્રક્રિયા કરો.
  2. જો વર્તમાન અંક 9 કરતા નાનો હોય તો વર્તમાન અંકમાં એક ઉમેરો અને એરે પાછા ફરો અન્યથા વર્તમાન અંકને શૂન્ય સોંપો.
  3. જો છેલ્લા તત્વ પર પ્રક્રિયા કરવામાં આવે અને તે પણ 9 ની બરાબર હોય, તો તેનો અર્થ એ કે બધા અંકો 9 હતા. તેથી, આપણે એરેનું કદ એક દ્વારા વધારીશું અને 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 એ અંકની એરેની લંબાઈ છે.

જગ્યાની જટિલતા

ઉપરોક્ત કોડની અવકાશ જટિલતા છે ઓ (1)  કિસ્સામાં, એરેમાં ઓછામાં ઓછો એક અંક 9 કરતા ઓછો હોય છે, નહીં તો ઓ (એન).

સંદર્ભ