अंतिम शब्द लीटकोड सोल्यूशनची लांबी


अडचण पातळी सोपे
वारंवार विचारले Google
अक्षरमाळा

समस्या विधान

या समस्येमध्ये एक बहु शब्द स्ट्रिंग दिले गेले आहे आणि त्या स्ट्रिंगमध्ये असलेल्या शेवटच्या शब्दाची लांबी आपल्याला परत करावी लागेल. कोणतेही शब्द नसल्यास आम्हाला 0 परत करावे लागेल.

उदाहरण

s = "Hello World"
5

स्पष्टीकरणः “वर्ल्ड” या शेवटच्या शब्दाची लांबी 5 आहे.

s = " "
0

स्पष्टीकरण: शब्द नसल्यामुळे उत्तर 0 आहे.

दृष्टीकोन

या समस्येचे निराकरण करण्यासाठी प्रथम आपल्याला दोन्ही टोकावरील स्ट्रिंगमध्ये उपस्थित सर्व श्वेतक्षेत्र ट्रिम करावे लागतील. नंतर आपण शेवटच्या शब्दाची लांबी पहिल्या अक्षरापासून शेवटच्या अक्षरापर्यंत पुनरावृत्ती करुन शोधू शकतो. ट्रिमिंगसाठी आपण 'स्टार्ट' आणि 'एंड' हे दोन व्हेरिएबल्स वापरू शकतो जे दिलेल्या स्ट्रिंगमध्ये अनुक्रमे पहिले कॅरेक्टर आणि शेवटचे कॅरेक्टरची अनुक्रमणिका संचित करेल.

 

पहिल्या अक्षराची अनुक्रमणिका शोधण्यासाठी व्हेरिएबल प्रारंभ करा = प्रारंभ करा.
आता थोड्या वेळासाठी लूप वापरा आणि व्हेरिएबलमधे व्हेरिएबल वाढवा जोपर्यंत आपल्याला प्रथम कॅरेक्टर मिळत नाही.
त्याचप्रमाणे शेवटच्या अक्षरासाठी एन -१ सह व्हेरिएबल इनिशियलाइझ करा जिथे एन दिलेली स्ट्रिंगचा आकार असेल आणि जेव्हा आपल्याला प्रथम कॅरेक्टर मिळत नाही तोपर्यंत त्याचे मूल्य कमी होते.

जर प्रारंभ> समाप्ती असेल तर याचा अर्थ असा की इनपुट स्ट्रिंगमध्ये कोणतेही वर्ण नाहीत, म्हणून 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

शेवटच्या शब्दाच्या लांबीसाठी गुंतागुंत विश्लेषण

वेळ कॉम्प्लेक्सिटी

ओ (एन): जेथे एन ही इनपुट स्ट्रिंगची लांबी आहे. कारण आपण एकाच लूपमध्ये स्ट्रिंगद्वारे पुनरावृत्ती करत आहोत आणि सर्वात वाईट परिस्थितीत ती पहिल्या पात्राकडे जाऊ शकते.

स्पेस कॉम्प्लेक्सिटी 

ओ (1): इनपुटकडे दुर्लक्ष करून स्थिर मेमरी वापरली जाते.