शब्दांमध्ये लीटकोड सोल्यूशनच्या रिक्त स्थानांची पुनर्रचना करा


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

समस्या विधान

या समस्येमध्ये, आम्हाला एक मजकूर दिला आहे स्ट्रिंग मोकळ्या जागेत शब्द असलेले बरेच शब्द आहेत. शब्दांमध्ये फक्त लोअरकेस इंग्रजी अक्षरे असू शकतात. अर्थात प्रत्येक शब्द कमीतकमी एका जागेसह विभक्त केला जाईल. मजकूरामध्ये कमीतकमी एक शब्द आहे.
उदा. मजकूर = "सराव परिपूर्ण करते"
आपण बघू शकतो की मोकळी जागा आहेत.
आपल्याला टेक्स्टला अशा फॉरमॅटमध्ये रूपांतरित करावे लागेल ज्यात प्रत्येक शब्दाच्या दरम्यान समान संख्येने स्पेस असतील आणि जर कोणतीही जागा शिल्लक राहिली तर ती शेवटच्या शब्दानंतर जमा होईल.
आम्हाला एकूण जागांची संख्या बदलण्याची गरज नाही. तसेच शब्दांचा क्रम बदलला जाऊ नये.

उदाहरण

text = " practice makes perfect"
"practice makes perfect "

स्पष्टीकरण:

शब्दांमध्ये लीटकोड सोल्यूशनच्या रिक्त स्थानांची पुनर्रचना करा

यात 7 मोकळी जागा आणि 3 शब्द आहेत.
शब्दांमधील 7-3 = 1 अंतर बसविण्यासाठी आम्ही 2 स्पेस समान प्रमाणात विभाजित करू. अशा प्रकारे आपल्या आउटपुटमध्ये शब्दांमधील 7/2 = 3 स्पेस असतील आणि शेवटच्या शब्दानंतर 7-6 = 1 शिल्लक जागा जमा होईल.
म्हणून आउटपुट "प्रॅक्टिस परिपूर्ण करते" होईल.

text = " this is a sentence "
"this is a sentence"

स्पष्टीकरण:

एकूण 9 मोकळी जागा आणि 4 शब्द आहेत. आम्ही 9 स्पेस शब्दांमधील समान रीतीने विभाजित करू शकतो: 9 / (4-1) = 3 स्पेसेस.

दृष्टीकोन

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

तर, आपल्याला इनपुट स्ट्रिंगमधील रिक्त स्थान आणि शब्द मिळतील. आता आपल्याला शब्दांमधील जागा समान प्रमाणात विभाजित कराव्या लागतील. परंतु आम्हाला एक धार लक्षात घ्यावी लागेल की इनपुट स्ट्रिंगमध्ये फक्त एकच शब्द असू शकतो, म्हणून आपल्याला फक्त एक स्ट्रिंग परत करावी लागेल ज्यामध्ये सर्व शब्दांनंतर हा शब्द आहे. अन्यथा, शब्दांच्या यादीमध्ये आपल्याला ही जागा समान प्रमाणात विभागली पाहिजे.

समजा जर एन शब्द असतील तर शब्दांमधील स्थान एन -1 असेल.
अशाप्रकारे, आम्हाला या एन -1 ठिकाणी जागा (मोजू द्या) विभाजित कराव्या लागतील
म्हणून मजला (गणना / एन -1) रिक्त स्थानांची रुंदी असेल जे सर्व शब्द विभक्त करेल.
आणि उर्वरित रिक्त स्थान शेवटच्या शब्दानंतर जोडली जाईल.
म्हणजेच गणना% (एन -1) उर्वरित रिक्त स्थानांची संख्या असेल.

शेवटी, आम्ही प्रत्येक शब्द आणि मजला (संख्या / एन -1) जोडण्यासाठी शब्दांच्या जोडी दरम्यान आणि शेवटच्या शब्दानंतर% (एन -1) रिक्त स्थानांची गणना आणि अंतिम स्ट्रिंग परत ठेवू.

अंमलबजावणी

सी ++ प्रोग्राम लीटकोड सोल्यूशनमधील शब्दांमधील रिक्त स्थान

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

string reorderSpaces(string text) 
{
        int count=0;
        stringstream ss;
        vector<string> list;
        for(int i=0;i<text.length();i++){
            if(text[i]==' '){
                if(ss.str().size()>0)list.push_back(ss.str());//if there is some character present, only then 
                // insert into list
                count++;
                ss.str("");//empties the stringstream object
            }else{
                ss<<text[i];
            }
        }
        if(ss.str().size()>0)list.push_back(ss.str());//in case if any string is after the last space, that is not inserted into list.
        
        
        int wid=0,rem=0,l=0;
        if(list.size()==1){
            wid=0;
            rem=count;
        }else{
        /*number of positions between n words is n-1. thus l = list.size()-1*/
        l=list.size()-1;
        /*distributing the spaces equally in l places*/
        wid=count/l;
        /*and the remaining spaces will be appended at last*/
        rem=count%l;
        }
        ss.str("");
        for(int i=0;i<list.size();i++){
            ss<<list[i];//appending a word
            int w=wid;
            if(i<list.size()-1)
            while(w--!=0)ss<<' ';//appending spaces which is width we calculated above
        }
        while(rem--!=0)ss<<' ';//finally appending all the remaining spaces
        return ss.str();
}

int main()
{
    cout << reorderSpaces("  this   is  a sentence ");
}
this   is   a   sentence

शब्दांमध्ये लीटकोड सोल्यूशन दरम्यान रिक्त स्थान पुनर्संचयित करण्यासाठी जावा प्रोग्राम

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

class Rextester
{  
    public static void main(String args[])
    {
        System.out.println(reorderSpaces("  this   is  a sentence "));
    }
    
    public static String reorderSpaces(String text) 
    {
        int count=0;
        StringBuilder sb=new StringBuilder();
        List<String> list=new ArrayList<String>();
        for(int i=0;i<text.length();i++){
            if(text.charAt(i)==' '){
                if(sb.length()>0)list.add(sb.toString());//if there is some non-space character also present, only then 
                // insert into list
                count++;//counting spaces
                sb=new StringBuilder();//empties the stringstream object
            }else{
                sb.append(text.charAt(i));
            }
        }
        if(sb.length()>0)list.add(sb.toString());//in case if any string is after the last space, that is not inserted into list.
        
        
        int wid=0,rem=0,l=0;
        if(list.size()==1){
            wid=0;
            rem=count;
        }else{
       /*number of positions between n words is n-1. thus l = list.size()-1*/
        l=list.size()-1;
      /*distributing the spaces equally in l places*/
        wid=count/l;
       /*and the remaining spaces will be appended at last*/
        rem=count%l;
        }
        sb=new StringBuilder();
        for(int i=0;i<list.size();i++){
            sb.append(list.get(i));//appending a word
            int w=wid;
            if(i<list.size()-1)
            while(w--!=0)sb.append(' ');//appending spaces which is width we calculated above
        }
        while(rem--!=0)sb.append(' ');//finally appending all the remaining spaces
        return sb.toString();
    }
}
this   is   a   sentence

शब्दांमधील लीटकोड सोल्यूशनमधील रिक्त स्थानासाठी जटिलता विश्लेषण

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

ओ (एन): प्रथम, आम्ही आमची इनपुट स्ट्रिंग लांबीने फिरत आहोत आणि स्पेस विभक्त शब्द आमच्या यादीमध्ये संचयित करत आहोत. रेषीय वेळेत आपली आउटपुट स्ट्रिंग तयार करत आहोत. अशा प्रकारे, वेळ जटिलता ओ (एन) असेल.

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

ओ (एन): आम्ही शब्दांची यादी आणि स्ट्रिंग बिल्डर (सीपीपीच्या बाबतीत स्ट्रिंग स्ट्रीम) च्या रूपात रेषात्मक अतिरिक्त जागा वापरली आहे.