తక్కువ కేసు లీట్‌కోడ్ పరిష్కారానికి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe ఆపిల్ గూగుల్
స్ట్రింగ్

లోయర్ కేస్ లీట్‌కోడ్ సొల్యూషన్ సమస్య మాకు ఒక స్ట్రింగ్‌ను అందిస్తుంది మరియు అన్ని అప్పర్ కేస్ వర్ణమాలలను లోయర్ కేస్ వర్ణమాలలుగా మార్చమని అడుగుతుంది. మేము అన్ని అప్పర్ కేస్ లేదా లోయర్ కేస్ వర్ణమాలను లోయర్ కేస్ అక్షరాలుగా మార్చాల్సిన అవసరం ఉంది. కాబట్టి, సమస్య సరళంగా అనిపిస్తుంది కాని ద్రావణంలో మునిగిపోయే ముందు. మేము కొన్ని ఉదాహరణలను పరిశీలిస్తాము.

తక్కువ కేసు లీట్‌కోడ్ పరిష్కారానికి

"Hello"
"hello"

వివరణ: ఇన్‌పుట్‌లో అప్పర్ కేస్ వర్ణమాల 'H' ఉంది, ఇది లోయర్-కేస్ వర్ణమాల 'h' గా మార్చబడుతుంది. ఇతర పాత్రలు “ఎల్లో” అలాగే ఉంటాయి మరియు మేము వాటిని మార్చాల్సిన అవసరం లేదు.

"here"
"here"

వివరణ: ఇన్‌పుట్‌లోని అన్ని వర్ణమాలలు లోయర్ కేస్ అక్షరాలు కాబట్టి. మేము ఏ అక్షరాలను మార్చాల్సిన అవసరం లేదు మరియు ఎటువంటి మార్పు లేకుండా ఇన్పుట్ను తిరిగి ఇవ్వగలము.

అంతర్నిర్మిత ఫంక్షన్లను ఉపయోగించి అప్రోచ్

లోయర్ కేస్ లీట్‌కోడ్ సొల్యూషన్‌కు ఉన్న సమస్య అప్పర్ కేస్ క్యారెక్టర్‌ను లోయర్ కేస్ క్యారెక్టర్‌గా మార్చమని కోరింది. ప్రోగ్రామింగ్ భాషలలో అంతర్నిర్మిత ఫంక్షన్లను ఉపయోగించి ఈ ఆపరేషన్ సులభంగా చేయవచ్చు. కాబట్టి, మేము C ++ లో టోలవర్ () ను లేదా జావాలో toLowerCase () ను ఉపయోగించవచ్చు. ఈ ఫంక్షన్లను ఉపయోగించి, మేము ఇచ్చిన వాటిని మాత్రమే పాస్ చేయాలి స్ట్రింగ్ ఇన్‌పుట్‌గా. అప్పుడు మేము చిన్న అక్షరాలతో అన్ని అక్షరాలతో స్ట్రింగ్ పొందుతాము.

కోడ్

లోయర్ కేస్ లీట్‌కోడ్ సొల్యూషన్ కోసం సి ++ కోడ్

#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

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై), ఇక్కడ N అనేది ఇచ్చిన స్ట్రింగ్ యొక్క పరిమాణం. మేము మొత్తం ఇ స్ట్రింగ్‌లో ప్రయాణించాల్సిన అవసరం ఉన్నందున, సమయ సంక్లిష్టత ఇన్‌పుట్ పరిమాణంపై ఆధారపడి ఉంటుంది.

అంతరిక్ష సంక్లిష్టత

C ++ లో O (1), ఎందుకంటే ఆపరేషన్ స్థానంలో ఉంది. మొత్తం అల్గోరిథం యొక్క స్థల సంక్లిష్టత స్థిరంగా ఉంటుంది. కానీ అది పడుతుంది జావాలో ఓ (ఎన్) ఎందుకంటే జావాలో తీగలను మార్చలేనివి మరియు ఫలితాన్ని నిల్వ చేయడానికి మేము క్రొత్త స్ట్రింగ్‌ను సృష్టించాలి.