ഒരു സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിനുള്ള പ്രോഗ്രാം


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു കാപ്ജെമിനിയും വിവരം MAQ ഓക്സിജൻ വാലറ്റ്
സ്ട്രിംഗ്

പ്രശ്നം പ്രസ്താവന

“ഒരു സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിനുള്ള പ്രോഗ്രാം” പ്രശ്‌നത്തിൽ, ഞങ്ങൾ ഒരു സ്‌ട്രിംഗ് നൽകി, തന്നിരിക്കുന്ന എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിന് ഒരു പ്രോഗ്രാം എഴുതുക സ്ട്രിംഗ്. ഇവിടെ ടോഗിൾ എന്നാൽ എല്ലാ വലിയക്ഷരങ്ങളും ചെറിയക്ഷരമായും ചെറിയക്ഷരങ്ങളെ വലിയക്ഷരങ്ങളായും പരിവർത്തനം ചെയ്യുക.

ഇൻപുട്ട് ഫോർമാറ്റ്

സ്ട്രിംഗ് s അടങ്ങിയിരിക്കുന്ന ആദ്യ വരി.

Put ട്ട്‌പുട്ട് ഫോർമാറ്റ്

അവസാന സ്ട്രിംഗ് ഒരു വരിയിൽ അച്ചടിക്കുക.

നിയന്ത്രണങ്ങൾ

  • 1 <= | s | <= 10 ^ 6.
  • s [i] എന്നത് ഏതെങ്കിലും പ്രത്യേക ചാർ അല്ലെങ്കിൽ അപ്പർ, ലോവർ കേസ് അക്ഷരമാലയാണ്.

ഉദാഹരണം

Abcd2#BCDa
aBCD2#bcdA

വിശദീകരണം: ഇവിടെ ഞങ്ങൾ മുഴുവൻ സ്ട്രിംഗ് ചാർജും ചാർജർ ഉപയോഗിച്ച് സഞ്ചരിക്കുന്നു. വലിയ, ചെറിയ അക്ഷരമാല പരിശോധിച്ച് അതിനനുസരിച്ച് മാറ്റുക. അതിനാൽ, എല്ലാ ചാർജുകളും സന്ദർശിച്ചതിനുശേഷമുള്ള അവസാന സ്ട്രിംഗ് “aBCD2 # bcdA” ആണ്.

ഒരു സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിനുള്ള അൽഗോരിതം

  1. തന്നിരിക്കുന്ന സ്ട്രിംഗ് s ഇൻപുട്ട് ചെയ്യുക.
  2. മുഴുവൻ സ്ട്രിംഗും സഞ്ചരിക്കുക.
  3. S [i] ഒരു വലിയ അക്ഷരമാലയാണോയെന്ന് പരിശോധിച്ച് അതിനെ ഒരു ചെറിയ അക്ഷരമാലയായി പരിവർത്തനം ചെയ്യുക.
  4.  S [i] ഒരു ചെറിയ അക്ഷരമാലയാണെങ്കിൽ അതിനെ ഒരു വലിയ അക്ഷരമാലയായി പരിവർത്തനം ചെയ്യുക.
  5. അല്ലെങ്കിൽ ഒന്നും ചെയ്യരുത്, അത് ഉപേക്ഷിക്കുക.

നടപ്പിലാക്കൽ

ഒരു സ്ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിനുള്ള സി ++ പ്രോഗ്രാം

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

int main()
{
   string a;
   cin>>a;
   int n=a.length();
   for(int i=0;i<n;i++)
   {
       if(a[i]>='A' && a[i]<='Z')
       {
           a[i]='a'+(a[i]-'A');
       }
       else if(a[i]>='a' && a[i]<='z')
       {
           a[i]='A'+(a[i]-'a');
       }
   }
   cout<<a<<endl;
   return 0;
}

ഒരു സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുന്നതിനുള്ള ജാവ പ്രോഗ്രാം

import java.util.Scanner;

class sum { 
    public static void main(String[] args) 
    {
        Scanner sr= new Scanner(System.in);
        String s= sr.next();
        int n = s.length(); 
        char ans[] = s.toCharArray();
        for(int i=0;i<n;i++)
        {
            if(ans[i]>='A' && ans[i]<='Z') 
            { 
                ans[i] = (char) (ans[i]+32);
            } 
            else if(ans[i]>='a' && ans[i]<='z') 
            { 
                ans[i] = (char) (ans[i]-32); 
            }
        }
        for(int i=0;i<n;i++)
        {
            System.out.print(ans[i]);
        }
        System.out.println();
    } 
}
AbCd#aB12
aBcD#Ab12

എന്നതിനായുള്ള സങ്കീർണ്ണത വിശകലനം ഒരു സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ടോഗിൾ ചെയ്യുക

സമയ സങ്കീർണ്ണത

O (n) ഇവിടെ n എന്നത് തന്നിരിക്കുന്ന സ്‌ട്രിംഗിന്റെ വലുപ്പമാണ്. ഇവിടെ ഞങ്ങൾ മുഴുവൻ സ്ട്രിംഗിലൂടെ സഞ്ചരിച്ച് സ്ഥിരമായ സമയത്ത് ചില പ്രവർത്തനങ്ങൾ നടത്തുന്നു.

ബഹിരാകാശ സങ്കീർണ്ണത

o (1) കാരണം പ്രവർത്തനം നടത്താൻ ഞങ്ങൾ അധിക സ്ഥലമൊന്നും ഉപയോഗിക്കുന്നില്ല.

അവലംബം