લાસ્ટ વર્ડ લીટકોડ સોલ્યુશનની લંબાઈ


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે Google
શબ્દમાળા

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

આ સમસ્યામાં મલ્ટિવર્ડ શબ્દમાળા આપવામાં આવે છે અને આપણે તે શબ્દમાળામાં હાજર છેલ્લા શબ્દની લંબાઈ પરત કરવી પડશે. જો ત્યાં કોઈ શબ્દો ન હોય તો આપણે 0 પાછા આપવું પડશે.

ઉદાહરણ

s = "Hello World"
5

સમજૂતી: છેલ્લા શબ્દ "વર્લ્ડ" ની લંબાઈ 5 છે.

s = " "
0

સમજૂતી: કોઈ શબ્દ ન હોવાથી, જવાબ 0 છે.

અભિગમ

આ સમસ્યાને હલ કરવા માટે પહેલા આપણે બંને છેડા પર શબ્દમાળામાં હાજર તમામ ગોરા જગ્યાઓને ટ્રિમ કરવી પડશે. પછી આપણે પહેલા અક્ષરથી છેલ્લા પાત્ર સુધીની શબ્દમાળાને ફરી વળતાં અંતિમ શબ્દની લંબાઈ શોધી શકીએ. આનુષંગિક બાબતો માટે આપણે બે વેરીએબલો 'સ્ટાર્ટ' અને 'એન્ડ' વાપરી શકીએ છીએ જે આપેલ શબ્દમાળામાં અનુક્રમે પ્રથમ અક્ષર અને છેલ્લા અક્ષરની અનુક્રમણિકા સંગ્રહિત કરશે

 

પ્રથમ અક્ષરની અનુક્રમણિકા શોધવા માટે, વેરીએબલ 'પ્રારંભ' = 0 પ્રારંભ કરો.
હવે થોડો લૂપ વાપરો અને વેરીએબલમાં વેલ્યુ વધારવીશું જ્યાં સુધી અમને પહેલું કેરેક્ટર ન મળે.
એ જ રીતે છેલ્લા અક્ષર માટે, એન -1 સાથે વેરીએબલ પ્રારંભ કરો જ્યાં એન આપેલ શબ્દમાળાઓનું કદ છે અને જ્યારે આપણે પ્રથમ અક્ષર (અંતથી) ન મળે ત્યાં સુધી લુપમાં તેનું મૂલ્ય ઘટાડે છે.

જો પ્રારંભ કરો> અંત પછી તેનો અર્થ એ છે કે ઇનપુટ શબ્દમાળામાં કોઈ પાત્ર નથી, તેથી 0 પાછા ફરો.
નહીંતર આપણી પાસે વાસ્તવિક શબ્દમાળા છે.

છેલ્લા શબ્દની લંબાઈ

હવે છેલ્લા શબ્દની લંબાઈ શોધવા માટે, આપણે હવે અંત સુધી વાસ્તવિક શબ્દમાળાને પુનરાવર્તિત કરવા માટે પુનરાવર્તિત વેરીએબલ પોઝ લઈ શકીએ છીએ ત્યાં સુધી કે આપણે કોઈ ગોરાઈ જગ્યાનો સામનો ન કરીએ અથવા શબ્દમાળાના પહેલા પાત્ર સુધી પહોંચીએ નહીં.
હવે આપણે છેલ્લા અક્ષર અનુક્રમણિકા (ચલ અંતમાં સંગ્રહિત) અને વર્તમાન અનુક્રમણિકા વચ્ચેના તફાવતને પરત કરીએ છીએ જે વેરીએબલ પોઝમાં સંગ્રહિત છે.

અમલીકરણ

છેલ્લા શબ્દની લંબાઈ માટે સી ++ પ્રોગ્રામ

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

int lengthOfLastWord(string s) 
{
        
        int n=s.size();
        if(n==0) return 0;
        
        int start,end;
        
        start=0;
        while(start< n && s[start]==' ') start++;      //left trim
        
        end=n-1;
        while(end >=0 && s[end]==' ') end--;         //right trim
        
        if(start>end) return 0;
        
        int pos=end;
        while(pos>=start)
        {
            if(s[pos]==' ') return end-pos;
            else pos--;
        }
        
        return end-pos;
        
}
int main() 
{
    string s="Hello World";
    
    cout<<lengthOfLastWord(s)<<endl;
    
  return 0; 
}
5

લાસ્ટ વર્ડની લંબાઈ માટે જાવા પ્રોગ્રામ

import java.util.*;
import java.lang.*;

class LastWord
{  
    public static int lengthOfLastWord(String s) 
    {
        int n=s.length();
        if(n==0) return 0;
        
        int start,end;
        
        start=0;
        while(start< n && s.charAt(start)==' ') start++;    //left trim
        
        end=n-1;
        while(end >=0 && s.charAt(end)==' ') end--;      //right trim
        
        if(start>end) return 0;
        
        int pos=end;
        while(pos>=start)
        {
            if(s.charAt(pos)==' ') return end-pos;
            else pos--;
        }
        
        return end-pos;
    }
    
    public static void main(String args[])
    {
        String s="Hello World";
        System.out.println(lengthOfLastWord(s));
    }
}
5

છેલ્લા શબ્દની લંબાઈ માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન): જ્યાં n એ ઇનપુટ શબ્દમાળાની લંબાઈ છે. કારણ કે આપણે એક લૂપમાં શબ્દમાળા દ્વારા પુનરાવર્તિત થઈએ છીએ અને ખરાબ કિસ્સામાં તે પ્રથમ પાત્રમાં જઈ શકે છે.

અવકાશ જટિલતા 

ઓ (1): ઇનપુટને ધ્યાનમાં લીધા વિના સતત મેમરીનો વપરાશ થાય છે.