├── Logica e Matematica ├── Calcular Log │ └── README.md ├── Conversor de Segundos │ ├── README.md │ └── conversordesegundos.py ├── Menor e Maior Numero │ ├── README.md │ └── menormaiornumero.py ├── Moeda Falsa │ ├── README.md │ └── moedafalsa.py ├── Numero Feliz │ ├── README.md │ └── numerofeliz.py └── Potencia Por Soma │ ├── README.md │ └── potenciaporsoma.py ├── Problemas └── URI │ ├── Iniciante │ ├── uri1012.py │ ├── uri1013.py │ ├── uri1014.py │ ├── uri1015.py │ ├── uri1016.py │ └── uri1017.py │ └── README.md └── README.md /Logica e Matematica/Calcular Log/README.md: -------------------------------------------------------------------------------- 1 | # Calcular Logaritmo 2 | 3 | #### Dado um número inteiro positivo $n$ calcular o seu logaritmo inteiro na base $b$ inteira 4 | 5 | #### Exemplos: 6 | 7 | **n=100 e b=10 a saída deverá ser:** 8 | ``` 9 | 2 10 | ``` 11 | Isso porque $\log_{10}(100) = 2$ -------------------------------------------------------------------------------- /Logica e Matematica/Conversor de Segundos/README.md: -------------------------------------------------------------------------------- 1 | ## ⏰ Conversor de Segundos 2 | 3 | #### Dado um número inteiro positivo que representa a quantidade de segundos exibir uma mensagem para o usuário com esse valor convertido em dias, horas, minutos e segundos. 4 | 5 | * * * 6 | Sabemos que 1 minuto equivale a 60 segundo e 1 hora é equivalente a 60 minutos. Assim, podemos representar o tempo a partir de multiplos do segundo. 7 | 8 | 1 minuto = 60 s 9 | 1 hora = 60 x 1 minuto = 60 x 60 s = 3600 s 10 | 1 dia = 24 x 1 hora = 24 x 3600 s = 86400 s 11 | 12 | 13 | Sua tarefa é escrever um programa em Python que dado um valor inteiro *n* em segundos converta-o em dias, horas, minutos e segundos. 14 | 15 | Por exemplo, para *n* = 3500 temos 16 | 17 | dias = 3500 // 86400 = 0 18 | resto = 3500 % 86400 = 3500 19 | horas = resto // 3400 = 3500 // 3400 = 1 20 | resto = 3500 % 3400 = 100 21 | minutos = resto // 60 = 100 // 60 = 1 22 | resto = resto % 60 = 100 % 60 = 40 23 | #Saída 24 | 0 dia(s), 1 hora(s), 1 minuto(s) e 40 segundo(s) 25 | 26 | Note que '//' representa a divisão inteira e '%' representa o resto da divisão assim como no Python. Se ficou com dúvida reveja o conceito de [divisão euclidiana](https://pt.wikipedia.org/wiki/Divis%C3%A3o_euclidiana). Uma dica: você pode usar a função interna `divmode` que recebe dois valores e retorna a divisão inteira e o resto da divisão ao mesmo tempo. 27 | ```Python 28 | divisao, resto = divmod(7,4) 29 | print(f"A divisão é {divisao} e o resto é {resto}") 30 | #A divisão é 1 e o resto é 3 31 | ``` 32 | 33 | 34 | #### Exemplos: 35 | 36 | **N:** 37 | ``` 38 | 86400*2 + 2*3600 + 3*60 + 30 39 | ``` 40 | **Saída:** 41 | ``` 42 | 2 dia(s), 2 hora(s), 3 minuto(s) e 30 segundo(s) 43 | ``` 44 | 45 | * * * 46 | 47 | 48 | **N:** 49 | ``` 50 | 97275 51 | ``` 52 | **Saída:** 53 | ``` 54 | 1 dia(s), 3 hora(s), 1 minuto(s) e 15 segundo(s) 55 | ``` 56 | * * * 57 | 58 | **N:** 59 | ``` 60 | 3950 61 | ``` 62 | **Saída:** 63 | ``` 64 | 0 dia(s), 1 hora(s), 5 minuto(s) e 50 segundo(s) 65 | ``` 66 | * * * 67 | 68 | 69 | Dica: acesse o arquivo conversordesegundos.py para ver o código de resolução somemte depois de tentar resolver o exercício.😅 70 | 71 | Vá mais além: quando terminar o desafio tente usar a mesma ideia para converter segundos em semanas, meses e anos. Você também pode tentar converter qualquer umas dessas unidade de tempo em outras. 72 | 73 | Em breve uma explicação mais detalhada do algorítmo em [Conversor de Segundos](#) -------------------------------------------------------------------------------- /Logica e Matematica/Conversor de Segundos/conversordesegundos.py: -------------------------------------------------------------------------------- 1 | #tempo total em segundos ou o valor de n 2 | tempo = 2*86400 + 2*3600 + 0*60 + 30 3 | 4 | segundo = 1 5 | minuto = 60*segundo 6 | hora = 60*minuto 7 | dia = 24*hora 8 | 9 | 10 | dias, tempo = divmod(tempo, dia) 11 | horas, tempo = divmod(tempo, hora) 12 | minutos, tempo = divmod(tempo, minuto) 13 | segundos = tempo 14 | 15 | 16 | msg = "{} dia(s), {} hora(s), {} minuto(s) e {} segundo(s)" 17 | msg = msg.format(dias, horas, minutos, segundos) 18 | print(msg) -------------------------------------------------------------------------------- /Logica e Matematica/Menor e Maior Numero/README.md: -------------------------------------------------------------------------------- 1 | ## Menor e Maior Número 2 | 3 | #### Dado três números inteiros verificar qual o menor e qual o maior dentre esses números. 4 | 5 | * * * 6 | 7 | Neste exercício, você deve escrever um programa que dado três números inteiro *a, b e c* verifique qual é o menor e qual é o maior número. O programa deve receber 3 valores do tipo inteiro e imprimir *n1* e *n2*, com *n1 <= n2*. 8 | 9 | *Obs.: evitar funções internas que já façam isso, como `min` e `min` no Python* 10 | 11 | #### Exemplos: 12 | 13 | **Entrada:** 14 | ``` 15 | 3 16 | 4 17 | 5 18 | ``` 19 | **Saída:** 20 | ``` 21 | 3 5 22 | ``` 23 | 24 | * * * 25 | 26 | 27 | **Entrada:** 28 | ``` 29 | 0 30 | 4 31 | -19 32 | ``` 33 | **Saída:** 34 | ``` 35 | -19 4 36 | ``` 37 | * * * 38 | 39 | Explicação completa do algorítmo em [Menor e Maior Número](https://drive.google.com/file/d/1Md0q_NfYXlNgy3u02bI7mj36HCIWIc8E/view) -------------------------------------------------------------------------------- /Logica e Matematica/Menor e Maior Numero/menormaiornumero.py: -------------------------------------------------------------------------------- 1 | def menor_maior(a, b, c): 2 | menor = (a+b-abs(a-b) + 2*c - abs(a+b-abs(a-b)-2*c))//4 3 | maior = (a+b+abs(a-b) + 2*c + abs(a+b+abs(a-b)-2*c))//4 4 | return menor, maior 5 | n1 , n2 = menor_maior(int(input()),int(input()), int(input())) 6 | print(n1, n2) -------------------------------------------------------------------------------- /Logica e Matematica/Moeda Falsa/README.md: -------------------------------------------------------------------------------- 1 | ## 🪙 Moeda Falsa 2 | 3 | #### Dado um conjunto de moedas, deseja-se encontrar uma moeda falsa, que possui um peso menor que as demais moedas. 4 | 5 | *** 6 | ## Contextualizando 7 | Suponha que você está participando de um programa de TV e 8 | lhe é proposto o desafio de descobrir qual é a moeda falsa dentre 9 | 8 moedas de ouro, sabendo que, a moeda falsa pesa menos que as demais. Para isso, 10 | a equipe de produção forneceu uma balança de dois pratos. Você só terá duas chances. 11 | Se conseguir achar a moeda com menos de 2 pesagens em uma das 12 | chances você ganha as moedas de ouro. Com um pouco de sorte 13 | e de lógica você poderia conseguir isso se pesasse a metade das moedas com a outra metade, 14 | eliminando a metade mais pesada. Você poderia 15 | repetir esse processo até encontrar a moeda mais leve ou a moeda falsa. Mas 16 | e se fossem um número `n` de moedas e você tivesse que escrever um algoritmo pra isso? 17 | 18 | 19 | ## Desafio 20 | Considere uma lista `moedas` com *n* elementos representando as moedas. 21 | Escreva um programa que simule o processo de pesagem de uma balança de dois pratos. 22 | Sua missão é determinar a posição da moeda falsa com a menor quantidade de 23 | pesagens possível. As moedas verdadeiras 24 | podem ser representadas por 2 e a moeda 25 | falsa por 1. 26 | 27 | Exemplo: 28 | ``` 29 | [2, 2, 2, 2, 1] 30 | ``` 31 | Nesse exemplo, a moeda falsa está na última posição (pos=4) 32 | 33 | Além disso, o programa deve informar a 34 | quantidade de pesagens utilizadas 35 | para chegar ao resultado, ou seja, 36 | quantas comparações foram necessárias 37 | para encotrar a moeda falsa. 38 | *** 39 | ### Importante 40 | * Não utilize funções internas para persquisar a moeda falsa. 41 | Exemplo: 42 | ```python 43 | moedas.index(1) 44 | ``` 45 | * Tente fazer com que a quantidade de pesagens seja menor que pelo menos metade da lista de moedas. 46 | 47 | 48 | 49 | ### Exemplos 50 | 51 | **Moedas** 52 | ``` 53 | [1,2,2,2,2] 54 | ``` 55 | **Saída** 56 | ``` 57 | Moedas: [1,2,2,2,2] 58 | Posição da moeda falsa: 0 59 | Pesagens: 2 60 | ``` 61 | 62 | **Moedas** 63 | ``` 64 | [2,2,2,2,2,1,2] 65 | ``` 66 | **Saída** 67 | ``` 68 | Moedas: [2,2,2,2,2,1,2] 69 | Posição da moeda falsa: 5 70 | Pesagens: 2 71 | ``` 72 | **Moedas** 73 | ``` 74 | [2,1,2,2,2] 75 | ``` 76 | **Saída** 77 | ``` 78 | Moedas: [2,1,2,2,2] 79 | Posição da moeda falsa: 1 80 | Pesagens: 2 81 | ``` 82 | **Moedas** 83 | ``` 84 | [2,2,2,1,2,2,2] 85 | ``` 86 | **Saída** 87 | ``` 88 | Moedas: [2,2,2,1,2,2,2] 89 | Posição da moeda falsa: 3 90 | Pesagens: 1 91 | ``` 92 | **Moedas** 93 | ``` 94 | [2,1] 95 | ``` 96 | **Saída** 97 | ``` 98 | Moedas: [2,1] 99 | Posição da moeda falsa: 1 100 | Pesagens: 1 101 | ``` 102 | *** 103 | 104 | Dica: seu programa deve ser capaz de determinar uma moeda falsa em uma posição aleatória de uma lista com n elementos. Use isso para testar diferentes valores. 105 | 106 | Solução disponível em `moedafalsa.py` 107 | A resolução comentada desse exercício sairá em breve! 108 | 109 | 110 | ## Complementar 111 | 112 | [Busca Binária](https://pt.m.wikipedia.org/wiki/Pesquisa_bin%C3%A1ria) 113 | 114 | Obs: a resolução do problema é um pouco diferente da pesquisa binária que conhecemos, já que não podemos verificar diretamente se o elemento é igual a 1, mas sim fazer sucessivas comparações entre os elementos tal qual um balança de dois pratos o faria. 115 | -------------------------------------------------------------------------------- /Logica e Matematica/Moeda Falsa/moedafalsa.py: -------------------------------------------------------------------------------- 1 | from math import log2 2 | from random import randint 3 | 4 | def moeda_falsa(moedas): 5 | posicao = 0 6 | ultima_pesagem = int(log2(len(moedas))) 7 | pesagens = 1 8 | while pesagens <= ultima_pesagem: 9 | tamanho = len(moedas) 10 | metade, resto = divmod(tamanho, 2) 11 | soma = metade + resto 12 | 13 | prato_1 = moedas[:metade] 14 | prato_2 = moedas[metade + resto:] 15 | 16 | peso_prato_1 = sum(prato_1) 17 | peso_prato_2 = sum(prato_2) 18 | 19 | if peso_prato_1 == peso_prato_2: 20 | posicao += metade 21 | break 22 | 23 | if peso_prato_1 > peso_prato_2: 24 | posicao += soma 25 | moedas = prato_2[:] 26 | else: 27 | moedas = prato_1[:] 28 | 29 | if len(prato_1)==1: 30 | break 31 | pesagens += 1 32 | return posicao, pesagens 33 | 34 | quantidade = 7 35 | peso_falso = 1 36 | peso_verdadeiro = 2 37 | moedas = [peso_verdadeiro]*quantidade 38 | moedas[randint(0,quantidade-1)] = peso_falso 39 | posicao, pesagens = moeda_falsa(moedas) 40 | print("Moedas: ", moedas) 41 | print("Posição da moeda falsa: ", posicao) 42 | print("Pesagens: ", pesagens) 43 | -------------------------------------------------------------------------------- /Logica e Matematica/Numero Feliz/README.md: -------------------------------------------------------------------------------- 1 | ## 🧮 Número Feliz 2 | 3 | #### Dado um número inteiro positivo verificar se é um número feliz ou infeliz. 4 | 5 | * * * 6 | Um número inteiro positivo é feliz se quando substituido pela soma do quadrado de cada um de seus dígitos assume eventualmente o valor 1. Por outro lado, se o número eventualmente atinge um dos valores que iniciou a sequência ele é considerado infeliz ou triste. 7 | 8 | Por exemplo, 13 é um número feliz 😁, pois 9 | 10 | n = 13 11 | n = 1^2 + 3^2 = 10 12 | n = 1^2 + 0^2 = 1 (fim) 13 | 14 | Já o 5 é infeliz😢, pois 15 | 16 | n = 5 17 | n = 5^2 = 25 18 | n = 2^2 + 5^2 = 29 19 | n = 2^2 + 9^2 = 85 20 | n = 8^2 + 5^2 = 89 (inicio) 21 | n = 8^2 + 9^2 = 145 22 | n = 1^2 + 4^2 + 5^2 = 42 23 | n = 4^2 + 2^2 = 20 24 | n = 2^2 + 0^2 = 4 25 | n = 4^2 = 16 26 | n = 1^2 + 6^2 = 37 27 | n = 3^2 + 7^2 = 58 28 | n = 5^2 + 8^2 = 89 (fim) 29 | 30 | Note que no último exemplo a sequência termina quando *n* assume um dos valores anteriores, que no caso é o 89. Se continuássemos repetindo esse processo a sequência seria a mesma a partir do número 89, isto é, a sequência seria periódica. 31 | 32 | Assim, sua missão é escrever um programa em Python ou em uma linguagem de sua preferência que receba um inteiro positivo *n* e informe ao usuário se esse número é feliz ou infeliz. 33 | 34 | 35 | #### Exemplos: 36 | 37 | **Entrada:** 38 | ``` 39 | 13 40 | ``` 41 | **Saída:** 42 | ``` 43 | 13 é feliz 44 | ``` 45 | 46 | * * * 47 | 48 | 49 | **Entrada:** 50 | ``` 51 | 4 52 | ``` 53 | **Saída:** 54 | ``` 55 | 4 é infeliz 56 | ``` 57 | * * * 58 | 59 | Dica: acesse o arquivo numerofeliz.py para ver o código de resolução somemte depois de tentar resolver o exercício.😅 60 | 61 | Em breve a explicação completa do algorítmo em [Número Feliz](#) 62 | 63 | Para saber mais sobre os Números Feliz acesse [String Fixer](https://stringfixer.com/pt/Happy_prime) -------------------------------------------------------------------------------- /Logica e Matematica/Numero Feliz/numerofeliz.py: -------------------------------------------------------------------------------- 1 | """ 2 | Esta função realiza a soma de cada digito 3 | elevado ao quadrado de um número inteiro positivo. 4 | Exemplos: 5 | Para n = 13, soma = 1^2 + 3^2 = 10 6 | Para n = 21, soma = 2^2 + 1^2 = 5 7 | """ 8 | def soma_quadrado_digitos(numero): 9 | soma = 0 10 | while numero > 0: 11 | digito = numero % 10 12 | numero = numero // 10 13 | soma += digito ** 2 14 | return soma 15 | """ 16 | Esta função retorna True se um número inteiro positivo 17 | é Feliz e retorna False se o número é Infeliz. 18 | """ 19 | def e_feliz(numero): 20 | sequencia = [] 21 | soma = 0 22 | while soma != 1: 23 | soma = soma_quadrado_digitos(numero) 24 | if soma in sequencia: 25 | return False 26 | sequencia.append(soma) 27 | numero = soma 28 | return True 29 | n = int(input()) 30 | if e_feliz(n): 31 | print("%s é feliz" %n) 32 | else: 33 | print("%s é infeliz" %n) -------------------------------------------------------------------------------- /Logica e Matematica/Potencia Por Soma/README.md: -------------------------------------------------------------------------------- 1 | ## Potência Por Soma 2 | 3 | #### Calcular a potência de dois inteiros 4 | 5 | * * * 6 | 7 | Neste exercício, você deve escrever um programa que dado dois números inteiro *a e c* calcule $a^b$ ( *a* elevado a *b*) utilizando apenas operações de soma e estruturas de repetição (`for` ou `while`). O programa deve receber 2 valores e retornar outro inteiro, como nos exemplos abaixo. 8 | 9 | #### Exemplos: 10 | 11 | **Entrada:** 12 | ``` 13 | 3 14 | 4 15 | ``` 16 | **Saída:** 17 | ``` 18 | 81 19 | ``` 20 | 21 | * * * 22 | 23 | 24 | **Entrada:** 25 | ``` 26 | 4 27 | 2 28 | ``` 29 | **Saída:** 30 | ``` 31 | 16 32 | ``` 33 | * * * 34 | 35 | Explicação completa do algorítmo em [Potência Por Soma](https://drive.google.com/file/d/17z_tmsOd0VG6sDHUGVY9l0CoJgZgJCyW/view) 36 | -------------------------------------------------------------------------------- /Logica e Matematica/Potencia Por Soma/potenciaporsoma.py: -------------------------------------------------------------------------------- 1 | def potencia(a, b): 2 | somatorio = 1 3 | for i in range(b): 4 | soma = 0 5 | for j in range(a): 6 | soma += somatorio 7 | somatorio = soma 8 | return somatorio 9 | print(potencia((int(input())),(int(input())))) -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1012.py: -------------------------------------------------------------------------------- 1 | def strToFloat(list_str): 2 | list_float = [] 3 | for s in list_str: 4 | list_float.append(round(float(s), 2)) 5 | return list_float 6 | PI = 3.14159 7 | a, b, c = strToFloat(input().split()) 8 | print("TRIANGULO: %.3f" %((a*c)/2)) 9 | print("CIRCULO: %.3f" %(PI*(c**2))) 10 | print("TRAPEZIO: %.3f" %(((a+b)*c)/2)) 11 | print("QUADRADO: %.3f" %(b**2)) 12 | print("RETANGULO: %.3f" %(a*b)) -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1013.py: -------------------------------------------------------------------------------- 1 | def strToInt(list_str): 2 | list_int = [] 3 | for s in list_str: 4 | list_int.append(int(s)) 5 | return list_int 6 | 7 | def maior(a, b): 8 | return int(((a+b+abs(a-b))/2)) 9 | 10 | a, b, c = strToInt(input().split()) 11 | aux = maior(a,b) 12 | aux = maior(aux,c) 13 | print("%d eh o maior" %aux) -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1014.py: -------------------------------------------------------------------------------- 1 | X = int(input()) 2 | Y = float(input()) 3 | print("%.3f km/l" %(round((X/Y), 3))) -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1015.py: -------------------------------------------------------------------------------- 1 | def toFloat(m): 2 | n = [] 3 | for x in m: 4 | n.append(float(x)) 5 | return n 6 | def dp(x1, y1, x2, y2): 7 | return ((x2-x1)**2+(y2-y1)**2)**0.5 8 | x1, y1 = toFloat(input().split()) 9 | x2, y2 = toFloat(input().split()) 10 | print("%.4f" %dp(x1, y1, x2, y2)) -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1016.py: -------------------------------------------------------------------------------- 1 | distancia = int(input()) 2 | print("%d minutos" %(2*distancia)) 3 | -------------------------------------------------------------------------------- /Problemas/URI/Iniciante/uri1017.py: -------------------------------------------------------------------------------- 1 | t = int(input()) 2 | v = int(input()) 3 | print("%.3f"%((t*v)/12)) 4 | -------------------------------------------------------------------------------- /Problemas/URI/README.md: -------------------------------------------------------------------------------- 1 | ## Problemas do site [URI Online Judge](https://www.beecrowd.com.br/judge/pt/login?redirect=%2Fpt%2Fruns%2Fadd%2F3174%3Forigem%3D1) 2 | 3 | ### Resoluções de algumas exercício de lógica de programação do URI -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### Este Repositório contém exercícios de lógica de programação e matemática. 2 | 3 | ### Sobre o Projeto 4 | O objetivo desse projeto é ajudar estudantes iniciantes na programação a desenvolver o raciocíneo lógico para resolução de problemas. Para isso, tentaremos organizar esse repositório com alguns exercícios de vários sites de programação especializados no assunto, como o site da [OBI](https://olimpiada.ic.unicamp.br/) e do [URI Online Judge](https://www.beecrowd.com.br/judge/pt/categories). --------------------------------------------------------------------------------