Desafio 03: Inverter o case da string

[fvox]

Hi.

Segue um desafio fácil pra galera.

Desafio: Escreva uma função que receba como parâmetro uma string e retorne o contrário do case dela. Por exemplo, se o usuário inserir "FVOX", a função deve devolver "fvox". Se o usuário inserir "FvOx", a função deve devolver "fVoX". Se o usuário inserir "fvOX", a função deve retornar "FVox".


Good lucky!

Minha resposta:

use common::sense;

sub invert_case {
    my $r   = undef;
    $r .= /^[a-z]$/ ? uc : lc for split m{}, shift;
    return $r;
}

say invert_case "fvox";
say invert_case "FVOX";
say invert_case "FVox";
say invert_case "FvOx"; 

[]'s

[Animall]

Feito. Depois com calma posto outro com menos variáveis:

$palavra = AnIMalL;
@letras = split(//, $palavra);
foreach $letra (@letras){
if ($letra eq uc($letra)) {
$ltrocada=lc($letra);
printf "$ltrocada";
}elsif ($letra eq lc($letra)) {$ltrocada=uc($letra); 
printf "$ltrocada";}} 

Ótima iniciativa Fvox, continua sempre postando esses desafios. Abraço.

[acpguedes]

opa, era pra fazer dentro de uma função, ne?!

#!/usr/local/bin/perl

use common::sense;


sub inverter{
    my @result = undef ;
    my $nome = shift;
    my @letr = split (//, $nome);
    foreach my $let (@letr) { 
        if ($let eq uc $let) {
            my $chng = lc $let;
            push (@result, $chng);
        }
        elsif ($let eq lc $let){
            my $chng = uc $let;
            push (@result, $chng);
        }    
    }
    
    print @result, "\n";
    
}
    my $ENT = <STDIN>;
    my $inv = inverter $ENT;
    
    exit 0 ; 

[acpguedes]

foi mals o flood mas so observar, não tem muito pra onde ir
isso so instiga a aprender as funções lc e uc

daria pra fazer de outro modo, um que comecei a fazer e deu preguissa de tão trabalhoso,

no caso tinha criado dois arrais com o alfabeto em maiusculo e minusculo e iria conferir se maiusculo ou minusculo e ia trocar combinando a posição
da letra dentro do array!

[R0Dr1g0.]

Invertendo o valor binário(se 1 então 0/se 0 então 1) do 5º bit do byte que representa 1 char daria pra fazer isso.

[Animall]

Eu pensei desse jeito também com o alfabeto acpguedes huhehe, nem li que era em uma subrotina, mas blz deu pra fazer. Alguém pode deletar o post passado? Flw.

[smiley face]

Em python pra vocês:

f = lambda x : chr(x-1*(2*int(x >= 97)-1)*32*(x in range(97,123)+range(65, 91)))
str = 'AbCdE oL~~~ VeLhO'
str2 = ''.join([f(ord(x)) for x in str])

Onde está seu Deus agora... kkk'

[acpguedes]

por que infernos vocês dois (R0Dr1g0. e smiley) querem trabalhar a nivel binario??

oloco meu

da pra fazer como o R0Dr1g0. disse, e por Python lembra leve e superficialmente Perl o codigo do smiley
da pra facilmente ser transformado, mas como não tenho muito conhecimento de bit e bytes não vou fazer agora
mas acho que depois eu tento pra vocês

[_Guga_]

o nome dessa sub rotina deveria ser toggle_case ao invés de invert_case, soa melhor rs

a idéia do R0Dr1g0. pode ser facilmente implementada com um swap de xor's - vide um antigo tópico da área de C/C++ que explana/utiliza esse método - com a mask do bit 5 e cada caracter da cadeia literal ( string ). =)

eu estava pensando em notações como a Big O, para poder facilitar a analise byte por byte da string - partindo do principio que a string é beeeem grande - para que a complexidade do algorítimo seja O( n/2 ) ao invez de O( n ).


Edit:
-------------------------------------------------------------------------------------------------------------------------
Pra falar a verdade não sei nem se a Notação Big O tornaria o processo mais rápido a nível de linguagem de máquina, e também não sei exatamente se ela se encaixaria com perfeição nessa brincadeira aqui, então deixa quieto, compliquei atoa sahsauhsa =P
-------------------------------------------------------------------------------------------------------------------------

abraços

[smiley face]

Não estou trabalhando a nivel binário.Mas esse é um dos casos onde o uso da matemática é elementar e transforma o código em branchless.
O código é básicamente na forma:

def swap_char_case(char):
    char = ord(char)
    if char >= 97 and char <= 121:
        return chr(char-32)
    if char >= 65 and char <= 90:
        return chr(char+32)
    return chr(char)

def swap_string_case(string):
    ret = ''
    for char in string:
        ret += swap_char_case(char)
    return ret 

Mas o uso de ifs é desnecessário e torna o código mais lento em swap_char_case então:

def swap_char_case(char):
    char = ord(char)
    #Inverte o sinal da expressão quando necessário
    #2*int(char >= 97)-1
    #True: 2*1-1 = 1
    #False: 2*0-1 = -1
    #Ou seja,vai somar 32 quando for menor que 97 e subtrair 32 quando maior.

    #Zera a expressão se o caracter não estiver na range de caracteres que queremos mudar o case (a-z,A-Z).
    #Por uma questão de legibilidade a colocamos por ultimo
    #(char >= 97 and char <= 121) or (char >= 65 and char <= 91)

    return chr(char-1*(2*int(char >= 97)-1)*32*((char >= 97 and char <= 121) or (char >= 65 and char <= 91))) 

O que é equivalente a função acima só que sem estruturas condicionais.Pra manter o código "pequeno" e por preguiça eu tinha trocado:

((char >= 97 and char <= 121) or (char >= 65 and char <= 91)) 

Por básicamente:

valid_char_range = range(97,122)+range(65,92)
//...
(char in valid_char_range) 

O que é bem mais lento mas alcançou meu objetivo.
De forma que o código escrito da "melhor forma" em uma das possiveis notações fica:

def swap_char_case(char):
    char = ord(char)
    return chr(char-1*(2*int(char >= 97)-1)*32*((char >= 97 and char <= 121) or (char >= 65 and char <= 91)))

swap_string_case = lambda string : ''.join(map(swap_char_case, string))

strings = ['~~SmIlEy FaCe~~', 'JoAo', '    ---   ', 'ABCde']

print 'Exemplo:'
print '--', '\n-- '.join(map(swap_string_case, strings))

#Saida
"""
Exemplo:
-- ~~sMiLeY fAcE~~
-- jOaO
--     ---   
-- abcDE
"""