લોઅર કેસ લિટકોડ સોલ્યુશન


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

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

લોઅર કેસ લિટકોડ સોલ્યુશન

"Hello"
"hello"

સમજૂતી: ઇનપુટમાં અપર કેસ મૂળાક્ષર 'એચ' હોય છે જે લોઅર-કેસ મૂળાક્ષર 'એચ' માં રૂપાંતરિત થાય છે. અન્ય અક્ષરો "ઇલો" સમાન રહે છે અને આપણે તેમને કન્વર્ટ કરવાની જરૂર નથી.

"here"
"here"

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

ઇન-બિલ્ટ ફંક્શંસનો ઉપયોગ કરીને અભિગમ

લોઅર કેસ લિટકોડ સોલ્યુશનમાં સમસ્યા એ અમને અપર કેસ કેરેક્ટરને લોઅર કેસ કેરેક્ટરમાં ફેરવવાનું કહ્યું. પ્રોગ્રામિંગ ભાષાઓમાં બિલ્ટ ફંક્શંસનો ઉપયોગ કરીને આ ઓપરેશન સરળતાથી કરી શકાય છે. તેથી, આપણે સી ++ માં ટolલ્વર () અથવા જાવામાં ટLલ્વરકેસ () નો ઉપયોગ કરી શકીએ છીએ. આ વિધેયોનો ઉપયોગ કરીને, આપણે ફક્ત આપેલને પસાર કરવાની જરૂર છે શબ્દમાળા ઇનપુટ તરીકે. પછી આપણે લોઅર કેસમાં બધા અક્ષરો સાથે શબ્દમાળા મેળવીશું.

કોડ

ટુ લોઅર કેસ લિટકોડ સોલ્યુશન માટે સી ++ કોડ

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

string toLowerCase(string str) {
    transform(str.begin(), str.end(), str.begin(), [](unsigned char c){ return std::tolower(c); });
    return str;
}

int main(){
    cout<<toLowerCase("Hello");
}
hello

ટૂ લોઅર કેસ લિટકોડ સોલ્યુશન માટે જાવા કોડ

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

class Main {
    public static String toLowerCase(String str) {
        return str.toLowerCase();
    }
    
    public static void main (String[] args) throws java.lang.Exception
  {
      System.out.print(toLowerCase("Hello"));
  }
}
hello

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન), ઇન-બિલ્ટ મેથડ્સ આપેલ સ્ટ્રિંગને લોઅર કેસ કેરેક્ટરમાં રૂપાંતરિત કરવા માટે સંપૂર્ણ ઇનપુટ સ્ટ્રિંગને પણ પસાર કરે છે.

અવકાશ જટિલતા

ઓ (1), કારણ કે આપણે કંઈપણ સંગ્રહવાની જરૂર નથી. જગ્યાની જટિલતા સતત છે.

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

વૈકલ્પિક અભિગમ કે જેનો આપણે ઉપયોગ કરી શકીએ છીએ, તે છે ASCII નંબર્સ. આપણે ફક્ત એક ફંક્શન બનાવી શકીએ છીએ જે આપેલ ઇનપુટ સ્ટ્રિંગને આગળ ધપાવે છે અને તપાસ કરે છે કે શું અક્ષરનો ASCII એ A થી Z ના ASCII કોડ વચ્ચે છે. અમે ફક્ત ASCII કોડ a અને A વચ્ચેનો તફાવત ઉમેરીશું. તેના સંબંધિત લોઅર કેસ પાત્ર છે. પરંતુ તાર જાવામાં પરિવર્તનશીલ છે તેથી આપણને જોઈએ સ્ટ્રિંગબફર કાર્ય પૂર્ણ કરવા માટે.

વૈકલ્પિક અભિગમ માટેનો કોડ

ટુ લોઅર કેસ લિટકોડ સોલ્યુશન માટે સી ++ કોડ

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

string toLowerCase(string str) {
    for(int i=0;i<str.length();i++)
        if(str[i]>='A' && str[i]<='Z')
            str[i] = str[i] + ('a' - 'A');
    return str;
}

int main(){
    cout<<toLowerCase("Hello");
}
hello

ટૂ લોઅર કેસ લિટકોડ સોલ્યુશન માટે જાવા કોડ

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

class Main {
    public static String toLowerCase(String str) {
    	StringBuffer res = new StringBuffer();
        for(int i=0;i<str.length();i++)
        	if(str.charAt(i)>='A' && str.charAt(i)<='Z')
            	res.append((char)(str.charAt(i) + ('a' - 'A')));
            else
            	res.append(str.charAt(i));
    	return res.toString();
    }
    
    public static void main (String[] args) throws java.lang.Exception
  {
      System.out.print(toLowerCase("Hello"));
  }
}
hello

જટિલતા વિશ્લેષણ

સમય જટિલતા

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

અવકાશ જટિલતા

ઓ (1) સી ++ માં, ઓપરેશન જગ્યાએ છે કારણ કે. સમગ્ર અલ્ગોરિધમનો અવકાશ જટિલતા સતત છે. પરંતુ તે લે છે જાવામાં ઓ (એન) કારણ કે જાવામાં શબ્દમાળાઓ સ્થાવર છે અને પરિણામ સંગ્રહવા માટે અમારે નવું શબ્દમાળા બનાવવાની જરૂર છે.