Programma Python per convertire i caratteri di una stringa nel caso opposto
In questo problema, attiveremo/disattiveremo il caso di ogni carattere di stringa. Il modo più semplice per attivare/disattivare il carattere di ogni stringa è utilizzare il metodo integrato swapcase().
Inoltre, possiamo utilizzare i valori ASCII dei caratteri per invertire il loro caso. Python contiene anche i metodi isUpper() e isLower() per verificare il carattere del carattere e il metodo lower() e upper() per modificare il caso.
Qui impareremo diversi approcci per risolvere il problema.
Dichiarazione del problema - Abbiamo fornito una stringa alfabetica. Dobbiamo attivare/disattivare il caso dei caratteri stringa. Significa convertire i caratteri maiuscoli in minuscoli e i caratteri minuscoli in maiuscoli.
Esempi di esempio
Inserimento
alpha = "TutorialsPoint"
Uscita
'tUTORIALSpOINT'
Spiegazione: qui abbiamo invertito il caso di ciascun carattere.
Inserimento
alpha = “AAAA”
Uscita
'aaaa'
Inserimento
alpha = '12qwER@'
Uscita
'12QWer@'
Spiegazione: abbiamo modificato il caso di ciascun carattere alfabetico e mantenuto i caratteri speciali così come sono.
Approccio 1
In questo approccio, aggiungiamo 32 al valore ASCII del carattere se il carattere è in maiuscolo. Altrimenti sottraiamo 32 dal valore ASCII del carattere per convertire il carattere in maiuscolo.
Algoritmo
Passaggio 1: converti la stringa nell'elenco di caratteri.
Passaggio 2: attraversa l'elenco dei caratteri.
Passaggio 3 - Se il carattere è compreso tra "A" e "Z", aggiungi 32 al valore ASCII del carattere e aggiorna il carattere nell'elenco.
Passaggio 4 - Se il carattere è compreso tra "a" e "z", sottrai 32 dal valore ASCII del carattere e aggiorna il carattere nell'elenco.
Passaggio 5 - Utilizza il metodo join() per convertire tutti i caratteri dell'elenco nella stringa.
Passaggio 6: restituisce la stringa risultante.
Esempio
def changeCase(alpha):
alpha_list = list(alpha) # String to list
# Traverse list of string characters
for p in range(len(alpha_list)):
if alpha_list[p] >= 'A' and alpha_list[p] <= 'Z':
alpha_list[p] = chr(ord(alpha_list[p]) + 32) # Change to lowercase
elif alpha_list[p] >= 'a' and alpha_list[p] <= 'z':
alpha_list[p] = chr(ord(alpha_list[p]) - 32) # Change to uppercase
alpha = ''.join(alpha_list) # List to string
return alpha
alpha = "TutorialsPoint"
alpha = changeCase(alpha)
print("The string after flipping the case of each character is -", alpha)
Produzione
The string after flipping the case of each character is - tUTORIALSpOINT
Complessità temporale: O(N) per attraversare i caratteri della stringa.
Complessità dello spazio: O(N) per memorizzare la stringa nell'elenco dei caratteri.
Approccio 2
In questo approccio, utilizziamo il metodo isUpper() per verificare se il carattere è in maiuscolo. Inoltre, utilizziamo i metodi upper() e lower() per convertire il carattere rispettivamente in maiuscolo e minuscolo.
Algoritmo
Passaggio 1 - Inizializza 'temp' con una stringa vuota per memorizzare la stringa risultante.
Passaggio 2: esegue l'iterazione della stringa.
Passaggio 3 - Se un carattere è in maiuscolo, utilizza il metodo lower() per convertire il carattere in minuscolo e aggiungerlo alla stringa temporanea.
Passaggio 4 - Altrimenti, utilizza il metodo upper() per convertire il carattere in maiuscolo e aggiungerlo alla stringa temporanea.
Passaggio 5 - Restituisci la stringa 'temp'.
Esempio
def changeCase(alpha):
temp = ""
for ch in alpha:
# Using the isupper() method to check if the character is uppercase or not
if (ch.isupper()):
# Converting a character to lowercase
temp += ch.lower()
else:
temp += ch.upper() # Converting a character to uppercase
return temp
alpha = "TutorialsPoint"
alpha = changeCase(alpha)
print("The string after flipping the case of each character is -", alpha)
Produzione
The string after flipping the case of each character is - tUTORIALSpOINT
Complessità temporale - O(N) per attraversare la stringa.
Complessità dello spazio - O(N) per memorizzare la stringa risultante.
Approccio 3
In questo approccio, utilizziamo il metodo swapcase() per attivare/disattivare il carattere del carattere. Abbiamo memorizzato la stringa alfabetica su se stessa dopo aver commutato tra maiuscole e minuscole per ciascun carattere.
Esempio
def changeCase(alpha):
# Using the swapcase() function to toggle the case of characters of the string
alpha = alpha.swapcase()
return alpha
alpha = "AbcSDe"
alpha = changeCase(alpha)
print("The string after flipping the case of each character is -", alpha)
Produzione
The string after flipping the case of each character is - aBCsdE
Complessità temporale - O(N)
Complessità spaziale - O(1)
Approccio 4
In questo approccio, utilizzeremo l'espressione regolare e la funzione lambda per attivare/disattivare il caso di ciascun carattere della stringa.
Algoritmo
Passaggio 1 - Inizializza 'patt' per cercare i caratteri alfabetici minuscoli e maiuscoli.
Passaggio 2 - Successivamente, utilizza il metodo re.sub() per sostituire tutti i caratteri alfabetici con il loro caso opposto.
Passaggio 3 - Utilizza 'patt' come primo parametro del metodo sub(), la funzione lambda per attivare/disattivare il carattere come secondo parametro e la stringa originale come terzo parametro.
Passaggio 4 - Restituisci la stringa alfabetica.
Esempio
import re
def changeCase(alpha):
# Regular expression
patt = r'[a-zA-Z]'
# Toggle case of each character
alpha = re.sub(patt, lambda ch: ch.group().lower()
if ch.group().isupper() else ch.group().upper(), alpha)
return alpha
alpha = "TutorialsPoint"
alpha = changeCase(alpha)
print("The string after flipping the case of each character is -", alpha)
Produzione
The string after flipping the case of each character is - tUTORIALSpOINT
Complessità temporale - O(N)
Complessità spaziale - O(1)
Avvicinamento 5
In questo approccio, eseguiremo l'operazione XOR del valore ASCII del carattere con 32 per alternare maiuscole e minuscole.
Quando prendiamo XOR di 32 con qualsiasi carattere alfabetico, attiva/disattiva il 6° bit della rappresentazione binaria del valore ASCII.
Capiamolo tramite l'esempio qui sotto.
65='A'=1.000.001
97='a'=1100001
32=0100000
Quindi, quando prendiamo lo XOR di 65 e 32, diventa 97 quando il sesto bit viene invertito e, analogamente, lo XOR di 97 e 32 diventa 32.
Funzionerà per tutti i valori ASCII dei caratteri alfabetici.
Algoritmo
Passaggio 1: inizia ad attraversare la stringa.
Passaggio 2: esegui la funzione isAlphabeticChar() per verificare se il carattere corrente è alfabetico.
Passaggio 3 - Nella funzione isAlphabeticChar(), restituisci true se il valore ASCII è compreso tra 65 e 90 o 97 e 122. Altrimenti, restituisci false.
Passaggio 4 - Se il carattere corrente è un carattere alfabetico, prendi il suo XOR con 32 e aggiungi il carattere aggiornato alla stringa 'temp'.
Passaggio 5 - Altrimenti, aggiungi il carattere originale alla stringa temporanea.
Passaggio 6: restituisci la stringa temporanea.
Esempio
def isAlphbeticChar(char):
Ascii = ord(char[0])
# Using ASCII values to validate character
if((Ascii >= 65 and Ascii <= 90) or (Ascii >= 97 and Ascii <= 122)):
return True
else:
return False
def changeCase(alpha):
temp = ""
for ch in range(len(alpha)):
if(isAlphbeticChar(alpha[ch])):
temp += chr(ord(alpha[ch]) ^ (1 << 5))
else:
temp += alpha[ch]
return temp
alpha = "TutorialsPoint"
alpha = changeCase(alpha)
print("The string after flipping the case of each character is -", alpha)
Produzione
The string after flipping the case of each character is - tUTORIALSpOINT
Complessità temporale - O(N)
Complessità spaziale - O(N)
Abbiamo imparato 5 approcci per alternare ciascun carattere della stringa. Il primo approccio utilizza il valore ASCII e il secondo approccio utilizza i metodi isUpper(), upper() e lower().
Inoltre, il terzo approccio utilizza il metodo swapcase(), il quarto approccio utilizza l'espressione regolare e l'ultimo approccio utilizza l'operatore XOR.