Construa um programa em Python em que o usuário insira a sigla de um estado brasileiro em que uma pessoa nasceu e, em seguida imprima uma das seguintes mensagens: Carioca Paulista Mineiro Outros estados Solução sigla=input(" Informe a sigla de um estado do Brasil: ") if sigla in ['Mg', 'MG','mg']: print(" Mineiro ") elif sigla in ['Rj', 'RJ','rj']: print(" Carioca ") elif sigla in ['Sp', 'SP','sp']: print(" Paulista ") else: print(" Outros estados ") Nota: a palavra-chave elif é uma maneira de dizer "se as condições anteriores não forem verdadeiras, tente esta condição". ------- Leia também ----------- Exercícios resolvidos de Python para iniciantes Principais métodos de strings em Python Exemplos - if/else em Python - Exercícios resolvidos Exemplos - comando for em Python - Exercícios resolvidos Exemplos - comando while em Python - Ex
Escrever uma função recursiva que calcule o valor de a elevado a b.
/*criar o protótipo da função potência, ou seja, declarar a quantidade de parâmetros e os tipos de parâmetros */
float potencia(float base, float expoente); /*A função aceita dois números, ou seja, base(a) e expoente(b) . Ela vai calcular o valor da potência.*/
printf("Informe o valor de 'b' : ");
/*Agora, vamos chamar a função potencia() com os argumentos a e b para fazer o cálculo*/
resultado = potencia(a,b);
printf("%.1f elevado a %.1f = %.2f",a,b,resultado);
setlocale(LC_ALL,"Portuguese");
printf("Informe o valor de 'a' : ");
float potencia(float base, float expoente)
if(expoente == 0) /*Se o expoente for zero, a potência será igual a 1. Essa é uma das regras de potenciação*/
if(expoente>0) /* Se o expoente é positivo, então o potência é = base*potencia(base, - expoente)*/
return (base * potencia(base,expoente - 1));
if(expoente<0) /* Se o expoente é negativo, então o potência é = 1/potencia(base, - expoente)*/
return (1/potencia(base,-expoente));
Mais exercícios sobre recursividade
Esta lista de exercícios resolvidos é um manual para ajudar todo aluno iniciante e não só, a adquirir e aprimorar as habilidades necessárias para se trabalhar com Python, de forma rápida e consistente. Estude e desfrute do conteúdo. 1º Exercício Faça um programa que informe a versão do Python que você está utilizando Solução import sys print ( "Versão do Python" ) print (sys.version) print ( "Informação da versão instalada" ) print (sys.version_info) Atenção : - O módulo sys fornece funções e variáveis usadas para manipular diferentes partes do ambiente de tempo de execução do Python; - Pra quem ainda não está familiarizado com a linguagem, um módulo é um arquivo contendo definições e comandos em Python para serem usados em outros programas. 2º Exercício Faça um programa em linguagem Python que converta metros para centímetros. Solução print ( ' \t ----Conversão de medida---- ' ) metros = int ( input ( 'Informe o valor em metros:
Este é um programa em que o usuário ao digitar uma string, o programa vai imprimir essa string de trás pra frente , ou seja, a string será mostrada ao contrário. Observação : Se você quiser ver esse código em Linguagem Python, veja o 6º exercício desta lista de exercícios Código-fonte #include <stdio.h> /*Arquivo cabeçalho que contém a função printf()*/ #include <string.h> / *Arquivo cabeçalho que contém as funções para manipulação de strings como,strlen,strcmp,etc. */ int main() { char strings[200]; int i, tamanho; printf( "Digite uma string: " ); fgets(strings,200,stdin); tamanho = strlen(strings); printf( "A string invertida : " ); for(i=tamanho; i>=0; i--) { printf ( "%c" ,strings [i] ); } return 0; } Explicações : strlen é uma função que retorna o tamanho da string digitada ; Em char strings[200] ,declaramos uma string de nome strings com 200 caracteres,mas como uma
Escreva um programa para calcular a área de um triângulo, sendo dados a sua base e a sua altura. A = (B*H)/2 Solução #include <stdio.h> int main() { // Variáveis float area,base,altura; // Entrada de Dados printf( "\n Informe a base do triângulo: " ); scanf( "%f" ,&base); printf( "\n Informe a altura do triângulo: " ); scanf( "%f" ,&altura); // Processamento dos dados area=(base*altura)/2; // Exibição do resultado printf( "\n Area do triângulo=%.1f\n" ,area); return 0; }
Dado um número N , a tarefa é encontrar a raiz quadrada do piso do número N sem usar a função interna de raiz quadrada. A raiz quadrada de base de um número é o maior número inteiro menor ou igual à sua raiz quadrada.
Exemplos:
Entrada: N = 25
Saída: 5
Explicação:
Raiz quadrada de 25 = 5. Portanto, 5 é o maior número inteiro menor que igual à raiz quadrada de 25.Entrada: N = 30
Saída: 5
Explicação: Raiz quadrada de 25 = 5,47 Portanto, 5 é o maior número inteiro menor que igual à raiz quadrada de 25 (5,47)
Abordagem ingênua:
Na abordagem básica para encontrar a raiz chão quadrada de um número, encontrar o quadrado de números de 1 a N , até que o quadrado de um número K torna-se maior do que N . Portanto, o valor de (K - 1) será a raiz quadrada do piso de N.
Abaixo está o algoritmo para resolver este problema usando a abordagem ingênua:
- Faça a iteração de um loop dos números 1 a N em K.
- Para qualquer K, se seu quadrado se tornar maior que N, então K-1 é a raiz quadrada de base de N.
Complexidade de tempo: O (√N)
Abordagem eficiente: a
partir da abordagem ingênua, é claro que a raiz quadrada do piso de N ficará na faixa [1, N]. Portanto, em vez de verificar cada número neste intervalo, podemos pesquisar com eficiência o número necessário neste intervalo . Portanto, a idéia é usar a busca binária , a fim de forma eficiente encontrar a raiz quadrada andar do número N no log N .
Abaixo está o algoritmo recursivo para resolver o problema acima usando a pesquisa binária:
- Implemente a pesquisa binária no intervalo de 0 a N.
- Encontre o valor médio do intervalo usando a fórmula:
- Caso Base: A chamada recursiva será executada até que o quadrado do meio seja menor ou igual a N e o quadrado de (mid + 1) seja maior que igual a N.
- Se o caso base não for satisfeito, o intervalo será alterado de acordo.
- Se o quadrado do meio for menor que igual a N, o intervalo será atualizado para [mid + 1, end]
- Se o quadrado do meio for maior do que N, o intervalo será atualizado para [baixo, médio + 1]
Abaixo está a implementação da abordagem acima:
// C++ implementation to find the // square root of the number N // without using sqrt() function #include <bits/stdc++.h> using namespace std; // Function to find the square // root of the number N using BS int sqrtSearch(int low, int high, int N) { // If the range is still valid if (low <= high) { // Find the mid-value of the range int mid = (low + high) / 2; // Base Case if ((mid * mid <= N) && ((mid + 1) * (mid + 1) > N)) { return mid; } // Condition to check if the // left search space is useless else if (mid * mid < N) { return sqrtSearch(mid + 1, high, N); } else { return sqrtSearch(low, mid - 1, N); } } return low; } // Driver Code int main() { int N = 25; cout << sqrtSearch(0, N, N) << endl; return 0; } // Java implementation to find the // square root of the number N // without using sqrt() function class GFG { // Function to find the square // root of the number N using BS static int sqrtSearch(int low, int high, int N) { // If the range is still valid if (low <= high) { // Find the mid-value of the range int mid = (int)(low + high) / 2; // Base Case if ((mid * mid <= N) && ((mid + 1) * (mid + 1) > N)) { return mid; } // Condition to check if the // left search space is useless else if (mid * mid < N) { return sqrtSearch(mid + 1, high, N); } else { return sqrtSearch(low, mid - 1, N); } } return low; } // Driver Code public static void main (String[] args) { int N = 25; System.out.println(sqrtSearch(0, N, N)); } } // This code is contributed by Yash_R # Python3 implementation to find the # square root of the number N # without using sqrt() function # Function to find the square # root of the number N using BS def sqrtSearch(low, high, N) : # If the range is still valid if (low <= high) : # Find the mid-value of the range mid = (low + high) // 2; # Base Case if ((mid * mid <= N) and ((mid + 1) * (mid + 1) > N)) : return mid; # Condition to check if the # left search space is useless elif (mid * mid < N) : return sqrtSearch(mid + 1, high, N); else : return sqrtSearch(low, mid - 1, N); return low; # Driver Code if __name__ == "__main__" : N = 25; print(sqrtSearch(0, N, N)) # This code is contributed by Yash_R // C# implementation to find the // square root of the number N // without using sqrt() function using System; class GFG { // Function to find the square // root of the number N using BS static int sqrtSearch(int low, int high, int N) { // If the range is still valid if (low <= high) { // Find the mid-value of the range int mid = (int)(low + high) / 2; // Base Case if ((mid * mid <= N) && ((mid + 1) * (mid + 1) > N)) { return mid; } // Condition to check if the // left search space is useless else if (mid * mid < N) { return sqrtSearch(mid + 1, high, N); } else { return sqrtSearch(low, mid - 1, N); } } return low; } // Driver Code public static void Main(String[] args) { int N = 25; Console.WriteLine(sqrtSearch(0, N, N)); } } // This code is contributed by PrinciRaj1992 <script> // Javascript implementation to find the // square root of the number N // without using sqrt() function // Function to find the square // root of the number N using BS function sqrtSearch(low, high, N) { // If the range is still valid if (low <= high) { // Find the mid-value of the range var mid = parseInt( (low + high) / 2); // Base Case if ((mid * mid <= N) && ((mid + 1) * (mid + 1) > N)) { return mid; } // Condition to check if the // left search space is useless else if (mid * mid < N) { return sqrtSearch(mid + 1, high, N); } else { return sqrtSearch(low, mid - 1, N); } } return low; } // Driver Code var N = 25; document.write(sqrtSearch(0, N, N)); // This code is contributed by todaysgaurav </script>Análise de desempenho:
- Complexidade de tempo: Como na abordagem acima, há pesquisa binária usada no espaço de pesquisa de 0 a N, que leva tempo O (log N) no pior caso, portanto, a complexidade de tempo será O (log N) .
- Complexidade do espaço: Como na abordagem acima, levando em consideração o espaço da pilha usado nas chamadas recursivas que podem ocupar espaço O (logN) no pior caso, portanto, a complexidade do espaço será O (log N)