# Programa que recebe uma lista de temperaturas em Celsius e escreve
# na tela o resultado da conversão dessas temperaturas em Fahrenheit.

def celsius_para_fahrenheit(celsius):
    return (celsius * 9/5) + 32

temperaturas_celsius = [0, 20, 37, 100]
temperaturas_fahrenheit = [celsius_para_fahrenheit(temp) for temp in temperaturas_celsius]

print("Temperaturas em Fahrenheit:")
for i in range(len(temperaturas_celsius)):
    print(f"{temperaturas_celsius[i]}°C = {temperaturas_fahrenheit[i]}°F")
print()

# Tabela de conversão Fahrenheit para Celsius, de 300 para 0

print('Tabela de conversão de Fahrenheit para Celsius')
for fahr in range(300, -1, -20):
    celsius = (5 / 9) * (fahr - 32)
    print('{:>5d} -> {:>5.1f}'.format(fahr, celsius))

# Tabela Fahrenheit para Celsius com validação usando try...except

def fahr_para_celsius(f):
    """Converte temperaturas Fahrenheit para Celsius."""
    return (5 / 9) * (f - 32)

def cria_tabela_celsius(fahr):
    """Cria tabela Celsius a partir de tab Fahr."""
    celsius = [None] * len(fahr)
    for i, temp in enumerate(fahr):
        celsius[i] = fahr_para_celsius(fahr[i])
    return celsius

def main():
    """Programa principal."""
    while True:
        try:
            inicio = int(input('Qual o início das temperaturas Fahrenheit? '))
            fim = int(input('Qual o final das temperaturas Fahrenheit? '))
            passo = int(input('Qual o passo das temperaturas Fahrenheit? '))
            if passo == 0:
                print('O passo não pode ser zero.')
                continue
            break
        except ValueError:
            print('Valor inválido. Digite um número inteiro.')

    fahr = range(inicio, fim + 1, passo)
    celsius = cria_tabela_celsius(fahr)
    print('Tabela de conversão de Fahrenheit para Celsius')
    for i, temp in enumerate(fahr):
        print('{:>5d} -> {:>5.1f}'.format(temp, celsius[i]))

main()

# Tabela de conversão Fahrenheit para Celsius usando while

print('Tabela de conversão de Fahrenheit para Celsius')
fahr = 0
while fahr <= 300:
    celsius = (5 / 9) * (fahr - 32)
    print('{:>5d} -> {:>5.1f}'.format(fahr, celsius))
    fahr += 20

# Lista de ímpares entre 0 e 100, transformando cada um no par subsequente

impares = list(range(1, 100, 2))
print('Ímpares originais:', impares)

for i, valor in enumerate(impares):
    impares[i] = valor + 1

print('Pares subsequentes:', impares)

# Tabela com 10 valores de pi calculados com diferentes números de pontos

import random as r
import math as m

def gera_coordenadas_aleatorias():
    """Gera par de coordenadas aleatórias."""
    x = r.random()
    y = r.random()
    return x, y

def coordenadas_dentro_circulo(x, y):
    """Testa se coordenadas estão dentro do círculo de raio 1."""
    return m.hypot(x, y) < 1

def calcula_pi(n):
    """Calcula pi e o erro associado a partir de n pontos."""
    conta_circulo = 0
    for i in range(n):
        x, y = gera_coordenadas_aleatorias()
        if coordenadas_dentro_circulo(x, y):
            conta_circulo += 1
    pi = 4 * conta_circulo / n
    erro = m.fabs(pi - m.pi)
    return pi, erro

print(f'{"Pontos":>10} {"Pi":>12} {"Erro":>12}')
print('-' * 36)
for n in range(100, 1100, 100):
    pi, erro = calcula_pi(n)
    print(f'{n:>10} {pi:>12.6f} {erro:>12.6f}')

# Lista com o quadrado dos números pares entre 10 e 20 (inclusive)

quadrados = [x**2 for x in range(10, 21) if x % 2 == 0]
print(quadrados)

# Lista com o quadrado dos ímpares de 0 a 9, usando apenas range()

quadrados = [x**2 for x in range(1, 10, 2)]
print(quadrados)

# Lista com o cubo dos números entre 1 e 10 (inclusive)

cubos = [x**3 for x in range(1, 11)]
print(cubos)

# Lista com os 10 primeiros múltiplos de 7

multiplos = [7 * x for x in range(1, 11)]
print(multiplos)

# Dada [0,1,2,3,4,5,6,7,8,9] gera [5,6,7,8,9,0,1,2,3,4]

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
resultado = lista[5:] + lista[:5]
print(resultado)

# Dada [0,1,2,3,4,5,6,7,8,9] gera [1,3,5,7,9,0,2,4,6,8]

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
resultado = lista[1::2] + lista[0::2]
print(resultado)

# Operações de fatiamento sobre a lista dada

lista = [10, 2, 32, 14, 35, 46, 17, 58, 199, 19]

print('1. Elementos de índices pares:', lista[::2])
print('2. Elementos de índices ímpares:', lista[1::2])
print('3. Elementos entre índices 2 (inclusive) e 4 (exclusive):', lista[2:4])
print('4. Elemento de índice 1, depois distantes 3 posições:', lista[1::3])

# Fatiamento com valores negativos em lista de 0 a 99

lista = list(range(100))

print('1. Último elemento e decrescendo de 3 em 3:', lista[-1::-3])
print('2. Índice 87 até 34 (exclusive), decrescente:', lista[87:34:-1])
print('3. Todos exceto os dois últimos:', lista[:-2])

# Inverso de uma lista usando apenas fatiamento

lista = [1, 2, 3, 4, 5, 6, 7]
print(lista[::-1])

# Operações com fatiamento sobre lista de planetas

planetas = ['Mercúrio', 'Vênus', 'Terra', 'Marte', 'Saturno', 'Júpiter', 'Urano', 'Netuno']
print('Original:', planetas)

# 1. Inserir ['Fobos', 'Deimos'] na posição 4
planetas[4:4] = ['Fobos', 'Deimos']
print('Após inserir Fobos e Deimos:', planetas)

# 2. Inserir ['Sol'] na posição 0
planetas[0:0] = ['Sol']
print('Após inserir Sol:', planetas)

# 3. Fatiamento para ['Urano', 'Júpiter', 'Saturno', 'Deimos', 'Fobos', 'Marte', 'Terra', 'Vênus']
print('Invertido do índice 3 ao 10:', planetas[10:2:-1])

# append() com outra lista

primos = [2, 3, 5, 7]
primos.append([23, 29, 31])
print('Lista após append:', primos)
print('primos[4]:', primos[4])
# primos[4] imprime a lista [23, 29, 31], pois append adiciona
# a lista como um único elemento.

# extend() com outra lista

primos = [2, 3, 5, 7]
primos.extend([23, 29, 31])
print('Lista após extend:', primos)
print('primos[4]:', primos[4])
# primos[4] imprime 23, pois extend adiciona cada elemento
# individualmente à lista.

# Fatiamento com passo -1 e diferença para reverse()

lista = [1, 2, 3, 4, 5]

# lista[::-1] cria uma NOVA lista invertida (a original não muda)
invertida = lista[::-1]
print('Original:', lista)
print('Fatiamento [::-1]:', invertida)

# reverse() modifica a lista original, sem criar nova lista
lista.reverse()
print('Após reverse():', lista)

# Inverter uma lista usando lista por compreensão

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
invertida = [lista[i] for i in range(len(lista) - 1, -1, -1)]
print(invertida)

# Primeira metade de uma lista

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
primeira_metade = lista[:len(lista) // 2]
print(primeira_metade)

# Apagar a primeira metade de uma lista

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del lista[:len(lista) // 2]
print(lista)

# Inverter os elementos da primeira metade de uma lista

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
metade = len(lista) // 2
lista[:metade] = lista[:metade][::-1]
print(lista)

# Obter [5,6,7,8,9,4,3,2,1,0] a partir de [0,1,2,3,4,5,6,7,8,9]

lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
metade = len(lista) // 2
resultado = lista[metade:] + lista[:metade][::-1]
print(resultado)

# Números entre 100 e 1000 divisíveis por 7 mas não múltiplos de 3

lista = [x for x in range(100, 1001) if x % 7 == 0 and x % 3 != 0]
print(lista)

# Média de números digitados pelo usuário

numeros = []
while True:
    entrada = input('Digite um número (ou "fim" para encerrar): ')
    if entrada.lower() == 'fim':
        break
    try:
        numeros.append(float(entrada))
    except ValueError:
        print('Valor inválido. Tente novamente.')

if len(numeros) > 0:
    media = sum(numeros) / len(numeros)
    print(f'Média: {media:.2f}')
else:
    print('Nenhum número digitado.')

# Matriz bidimensional usando 2 for encaixados

linhas = 3
colunas = 4

matriz = []
for i in range(linhas):
    linha = []
    for j in range(colunas):
        linha.append(0)
    matriz.append(linha)

print(matriz)

# Matriz tridimensional usando lista por compreensão

x, y, z = 3, 4, 5
matriz = [[[0 for k in range(z)] for j in range(y)] for i in range(x)]
print(matriz)

# Dicionário de estados brasileiros e suas siglas

def busca_sigla(estados, nome):
    if nome in estados:
        return estados[nome]
    return 'Estado não encontrado.'

estados = {
    'Acre': 'AC', 'Alagoas': 'AL', 'Amapá': 'AP', 'Amazonas': 'AM',
    'Bahia': 'BA', 'Ceará': 'CE', 'Distrito Federal': 'DF',
    'Espírito Santo': 'ES', 'Goiás': 'GO', 'Maranhão': 'MA',
    'Mato Grosso': 'MT', 'Mato Grosso do Sul': 'MS', 'Minas Gerais': 'MG',
    'Pará': 'PA', 'Paraíba': 'PB', 'Paraná': 'PR', 'Pernambuco': 'PE',
    'Piauí': 'PI', 'Rio de Janeiro': 'RJ', 'Rio Grande do Norte': 'RN',
    'Rio Grande do Sul': 'RS', 'Rondônia': 'RO', 'Roraima': 'RR',
    'Santa Catarina': 'SC', 'São Paulo': 'SP', 'Sergipe': 'SE',
    'Tocantins': 'TO'
}

nome = input('Digite o nome de um estado: ')
print(busca_sigla(estados, nome))

# Dicionário de estados com busca case-insensitive

def busca_sigla(estados, nome):
    nome_lower = nome.lower()
    for estado, sigla in estados.items():
        if estado.lower() == nome_lower:
            return sigla
    return 'Estado não encontrado.'

estados = {
    'Acre': 'AC', 'Alagoas': 'AL', 'Amapá': 'AP', 'Amazonas': 'AM',
    'Bahia': 'BA', 'Ceará': 'CE', 'Distrito Federal': 'DF',
    'Espírito Santo': 'ES', 'Goiás': 'GO', 'Maranhão': 'MA',
    'Mato Grosso': 'MT', 'Mato Grosso do Sul': 'MS', 'Minas Gerais': 'MG',
    'Pará': 'PA', 'Paraíba': 'PB', 'Paraná': 'PR', 'Pernambuco': 'PE',
    'Piauí': 'PI', 'Rio de Janeiro': 'RJ', 'Rio Grande do Norte': 'RN',
    'Rio Grande do Sul': 'RS', 'Rondônia': 'RO', 'Roraima': 'RR',
    'Santa Catarina': 'SC', 'São Paulo': 'SP', 'Sergipe': 'SE',
    'Tocantins': 'TO'
}

nome = input('Digite o nome de um estado: ')
print(busca_sigla(estados, nome))

# Tupla com números entre 100 e 1000 divisíveis por 7 mas não múltiplos de 3

tupla = tuple(x for x in range(100, 1001) if x % 7 == 0 and x % 3 != 0)
print(tupla)

# Cálculo de pi com coordenadas como lista de tuplas

import random as r
import math as m

def gera_coordenadas_aleatorias(n):
    """Gera lista de n pares de coordenadas aleatórias como tuplas."""
    return [(r.random(), r.random()) for _ in range(n)]

def coordenadas_dentro_circulo(x, y):
    """Testa se coordenadas estão dentro do círculo de raio 1."""
    return m.hypot(x, y) < 1

def calcula_pi(n):
    """Calcula pi e o erro associado a partir de n pontos."""
    coordenadas = gera_coordenadas_aleatorias(n)
    conta_circulo = 0
    for x, y in coordenadas:
        if coordenadas_dentro_circulo(x, y):
            conta_circulo += 1
    pi = 4 * conta_circulo / n
    erro = m.fabs(pi - m.pi)
    return pi, erro

num = int(input('Quantos pontos devem ser sorteados? '))
pi, erro = calcula_pi(num)
print(f'Com {num} pontos, o valor de pi é {pi} com erro {erro}')

# Aeroportos usando apenas tuplas (sem dicionário)

lat_galeao = (22, 48, 34)
long_galeao = (43, 15, 0)
aeroporto_galeao = ('Rio', 'Galeão', lat_galeao, long_galeao)

lat_guarulhos = (23, 26, 6)
long_guarulhos = (46, 28, 22)
aeroporto_guarulhos = ('São Paulo', 'Guarulhos', lat_guarulhos, long_guarulhos)

aeroportos = (aeroporto_galeao, aeroporto_guarulhos)

for aeroporto in aeroportos:
    cidade, nome, lat, lon = aeroporto
    print(f'Aeroporto {cidade}:')
    print(f'\t{nome}')
    print(f'\tLatitude: {lat[0]}º{lat[1]}\'{lat[2]}"')
    print(f'\tLongitude: {lon[0]}º{lon[1]}\'{lon[2]}"')