"""0.

Desenha um algoritmo que dado um número inteiro menor que 100, inserido pelo
utilizador,
calcula e imprime a soma dos numeros de 1 ao número inserido.
Por exe.: se for inserido um 5, o programa imprimirá: 15, pois 15 = 1 + 2 + 3 + 4 +
5.
Deves implementar um método – menorQue100(numero), que teste se número inserido é
ou não menor que 100
Nota: Estes cálculos podem ser repetidos (utilizados) pelo utilizador um número
infinito de vezes!
Implementa em PYTHON o algoritmo desenhado e que seja solução do problema."""

def soma(A:int):
"""função soma(A) calcula a soma dos numeros naturais até A, recursivamente"""
if A==1:
return 1
else:
return A+soma(A-1)
def somar(A:int):
"""função soma(A) calcula a soma dos numeros naturais até A, formula Gaus"""
return (A*(A+1)//2)

def somados(A:int):
"""função soma(A) calcula a soma dos numeros naturais até A, com ciclo for"""
s=0
for i in range(A):
s+=(i+1)
return s

def somados2(A:int):
"""função soma(A) calcula a soma dos numeros naturais até A, recursivamente"""
s=0
while A>0:
s+=A
A-=1
return s
def menorQue100(A:int):
return A<100

resposta=True
while resposta:
a=0
while a<=0 or not menorQue100(a):#a>100:
a = int(input('Enter 1st number: '))

print(f'a soma dos numeros naturais ate {a} is {soma(a)} ou {somar(a)} ou

{somados(a)} ou {somados2(a)}')
r=''
while r.lower()!='s' and r.lower()!='n':
r=input('Continuas? s/n')
if r.lower()=='n':
resposta =False

"""1. Desenha um algoritmo que dado um número inteiro menor que 100, inserido pelo
utilizador,
calcula e imprime a soma dos quadrados de 1 ao número inserido.
Por exe.: se for inserido um 5, o programa imprimirá: 55, pois 55 = 1**2 + 2**2 +
3**2 + 4**2 + 5**2.
Deves implementar um método – menorQue100(numero), que teste se número inserido é
ou não menor que 100
Nota: Estes cálculos podem ser repetidos (utilizados) pelo utilizador um número
infinito de vezes!
Implementa em PYTHON o algoritmo desenhado e que seja solução do problema."""

def soma(A:int):
if A==1:
return 1
else:
return A**2+soma(A-1)

def somados(A:int):

s=0
for i in range(A):
s+=((i+1)**2)
return s

def somados2(A:int):

s=0
while A>0:
s+=A**2
A-=1
return s
def menorQue100(A:int):
return A<100

resposta=True
while resposta:
a=0
while a<=0 or not menorQue100(a):#a>100:
a = int(input('Enter 1st number: '))

print(f'a soma dos numeros naturais ate {a} is {soma(a)} ou {somados(a)} ou

{somados2(a)}')
r=''
while r.lower()!='s' and r.lower()!='n':
r=input('Continuas? s/n')
if r.lower()=='n':
resposta =False

"""2. Escreve um algoritmo, para depois implementar em PYTHON, de um programa que,

dado dois números inseridos pelo utilizador (primeiro e segundo),
calcula e imprime a soma dos quadrados entre eles.
(NOTA: Deve existir um método – troca(p, s), que, caso seja necessário,
faça a troca dos números introduzidos!)
Por exe., para: primeiro = 5 segundo = 7,
o programa imprimirá: 110 = 52 + 62 + 72.
Nota: A solução anterior pode ser repetida (utilizada) pelo operador um número
infinito de vezes!"""

def soma(A:int,B:int):
if B==A:
return B**2
else:
 return B**2+soma(A,B-1)

def somados(A:int,B:int):

s=0
for i in range(A,B+1,1):
s+=((i)**2)
return s

def somados2(A:int,B:int):

s=0
while B>=A:
s+=A**2
A+=1
return s
def menorQue100(A:int):
return A<100

def troca(A:int,B:int):
if A>B:
A,B=B,A
return A,B

resposta=True
while resposta:
a=0
while a<=0:
a = int(input('Enter 1st number: '))
b=0
while b<=0:
b = int(input('Enter 2st number: '))
a,b=troca(a,b)

print(f'a soma dos quadrados de {a} ate {b} is {soma(a,b)} ou {somados(a,b)}

ou {somados2(a,b)}')
r=''
while r.lower()!='s' and r.lower()!='n':
r=input('Continuas? s/n')
if r.lower()=='n':
resposta =False

"""3. Sabendo que a área dum trapézio é dada por A= (B* b)* h/2
Onde B = base maior, b = base menor e h = altura.
Utilizando um método: areaTrapezio(bMaior, bMenor, alt),
escreve e testa um programa em PYTHON que permita calcular a área de vários
trapézios."""

def areaTrapezio(bMaior,bMenor,alt):
return (bMaior+bMenor)*alt/2

def troca(A:int,B:int):
if A>B:
A,B=B,A
return A,B
resposta=True
while resposta:
Bmaior=0
while Bmaior<=0:
Bmaior = int(input('Enter base maior B number: '))
bmenor=0
while bmenor<=0:
bmenor = int(input('Enter base menor b number: '))
bmenor,Bmaior=troca(bmenor,Bmaior)
h=0
while h<=0:
h = int(input('Enter altura h number: '))

print(f'a area do trapezio de base menor {bmenor}, base maior {Bmaior} e altura
{h} is {areaTrapezio(Bmaior,bmenor,h)} ')
r=''
while r.lower()!='s' and r.lower()!='n':
r=input('Continuas? s/n')
if r.lower()=='n':
resposta =False

"""4. Escreve e testa/executa um programa em PYTHON,

que calcule a média final de uma disciplina para n alunos duma turma,
sabendo que a média depende de três momentos de avaliação distintos e com pesos
diferentes.
Quer dizer: notafinal = primeiroteste*30% + segundoteste*30% + trabalho*40%.
Deve ser utilizado um método que calcula a nota final para cada aluno
com a seguinte assinatura: mediaFinal(notaUm, notaDois, notaTres)"""

def mediaFinal(notaUm,notaDois,notaTres):
return notaTres*0.4+notaDois*0.3+notaUm*0.3

resposta=True
while resposta:

n=0
while n<=0:
n = int(input('Enter numero alunos turma : '))
for i in range(n):
nota1=0
while nota1<=0 or nota1 >20:
nota1 = int(input('Enter nota 1: '))
nota2=0
while nota2<=0 or nota2 >20:
nota2 = int(input('Enter nota 2: '))
nota3=0
while nota3<=0 or nota3 >20:
nota3 = int(input('Enter nota 3: '))
print(f'a nota do aluno {i+1} is {round(mediaFinal(nota1,nota2,nota3),1)}
')

r=''
while r.lower()!='s' and r.lower()!='n':
 r=input('Continuas? s/n')
if r.lower()=='n':
resposta =False

#Ex05 - sistema equações

import math as m

def solucaoX(coefA, coefB, coefC, coefD, coefE, coefF):

delta=coefA*coefE-coefB*coefD
if delta !=0:
return (coefC*coefE-coefB*coefF)/delta

def solucaoY(coefA, coefB, coefC, coefD, coefE, coefF):

delta=coefA*coefE-coefB*coefD
if delta !=0:
return (coefA*coefF-coefC*coefD)/delta
x=0
y=0
i=1
resposta = True

while resposta:
a = float(input(" para a 1 equação Qual é o valor do coeficiente a: "))
b = float(input(" para a 1 equação Qual é o valor do coeficiente b: "))
c = float(input(" para a 1 equação Qual é o valor do coeficiente c: "))
d = float(input(" para a 2 equação Qual é o valor do coeficiente d: "))
e = float(input(" para a 2 equação Qual é o valor do coeficiente e: "))
f = float(input(" para a 2 equação Qual é o valor do coeficiente f: "))
""" delta=(a*e-b*d)

if delta==0:
print(" sistema INVALIDO\n")
else:
x= (c*e-b*f)/delta
y= (a*f -c*d)/delta
"""
print(" a solução do",i," sistema x:" ,round(solucaoX,2)," e
y:",round(solucaoY,2),"\n")

resposta=(input("\nPretende continuar? s/n"))

if resposta.lower()== "s":
i +=1
else:
resposta = False

"""
6. Desenha um algoritmo em PYTHON que leia vários conjuntos de três lados dum
triângulo (lado1, lado2, lado3)
e determine de que tipo é o triângulo baseado nos seguintes casos:
se A >= B + C Não existe qualquer triângulo.
se A2 = B2 + C2 Existe um triângulo rectângulo.
se A2 > B2 + C2 Existe um triângulo obtuso.
se A2 < B2 + C2 Existe um triângulo agudo.
Nota: o lado A é o maior dos três lados: lado1, lado2 e lado3, sendo B e C os
outros dois.
A determinação do maior dos três lados do triângulo deve utilizar correctamente o
método max(...)
"""
#Ex06 - triangulos
import math as m
def maior(a,b):# função que determina o maior de dois numeros
return ( a+b+ abs(a-b))/2

def ladosTriangulos(a,b,c):
#A=maior(a,maior(b,c))
A=max(a,b,c)
if A==a:
B=b
C=c
elif A==b:
B=a
C=c
else: #A==b
B=a
C=b
return A, B, C
tipos=['INVALIDO','rectângulo','obtuso','agudo']
def tipoTriangulo(a,b,c):
if a>=b+c:
return 0
elif a**2==b**2+c**2:
return 1
elif a**2>=b**2+c**2:
return 2
elif a**2<=b**2+c**2:
return 3
i=1
resposta = True
while resposta:
i1 = int(input("Qual é o valor do lado 1: "))
i2 = int(input("Qual é o valor do lado 2: "))
i3 = int(input("Qual é o valor do lado 3: "))
A,B,C=ladosTriangulos(i1,i2,i3)

print(f'triangulo {tipos[tipoTriangulo(A,B,C)]}')
print(" lado maior:",A, " soma dos outros:",B+C,"\n")
if A>=B+C :
print(" triangulo INVALIDO\n")
else:
p=(i1+i2+i3)/2
areaTotal= m.sqrt(p*(p-i1)*(p-i2)*(p-i3))
print(" a area total do ",i,".o triangulo =" ,round(areaTotal,2),"\n")
resposta=(input("\nPretende continuar? s/n"))
if resposta.lower()== "s":
i +=1
else:

resposta = False
"""
15. (100 Exercícios … exe-47) Desenha uma função – controlaMaiusculas(frase: str)
– que tem como parâmetro uma frase e testa se a frase introduzida tem ou não pelo
menos um carácter maiúsculo.
Se isso acontecer o resultado deve ser True. Caso contrário deve ser False.
Implementa em Python um programa que teste a função desenhada.
"""
def controlaMaiusculas(frase: str) -> bool:
"""Verifica se a frase contém pelo menos uma letra maiúscula."""
for char in frase:
if char.isupper():
return True
return False

# Testes da função
frases_teste = [
"ola mundo",
"Olá Mundo",
"tudo minúsculo",
"MAIÚSCULAS",
"12345",
"com número e Maiúscula 1"
]

for frase in frases_teste:

resultado = controlaMaiusculas(frase)
print(f"Frase: '{frase}' → Contém maiúscula? {resultado}")

"""
16. (CodingForK, p.41-2) Desenha uma função – contaVogais(frase: str)
– que permita contar e retorna quantas são as vogais de existente numa frase na
totalidade.
Implementa em Python um programa que teste a função desenhada.
"""
def contaVogais(frase: str) -> int:
"""Conta o número total de vogais (a, e, i, o, u) presentes na frase."""
vogais = "aeiouAEIOU"
contador = 0

for char in frase:

if char in vogais:
contador += 1

return contador

# Testes da função
frases_teste = [
"Olá Mundo",
"Python é incrível!",
"123456",
"Só consoantes...",
"AEIOU aeiou"
]

for frase in frases_teste:

resultado = contaVogais(frase)
print(f"Frase: '{frase}' → Número de vogais: {resultado}")

"""17. Desenha uma função – palavrasNegativas(frase: str)

– que percorra uma frase e substitua as “palavras negativas” por asteriscos.
Deve ser criada uma variável global (palavrasNegativas)
onde se guardarão as palavras a eliminar/substituir (“palavras negativas”) para
obter a frase final.
Métodos/Funções do tipo string em Python que são importantes para utilizar:
frase.split() + frase.replace() + len(frase)
Todas as palavras negativas devem ser substituídas por asteriscos.
Exemplo: palavrasNegativas = “mau medo falhar”
textoEntrada = O teste metia medo e foi mau!
textoSaida = O teste metia **** e foi ***!
primeiro lugar a divida em palavras utilizando frase.split()
"""

# Variável global com as palavras negativas

palavrasNegativas = ["mau", "medo", "falhar"]

def palavrasNegativasSubstituir(frase: str) -> str:

"""Substitui palavras negativas por asteriscos."""
palavras = frase.split() # Divide a frase em palavras
nova_frase = []

for palavra in palavras:

# Remove pontuação para comparar corretamente
palavra_limpa = palavra.strip(".,!?")

if palavra_limpa in palavrasNegativas:
# Substitui por asteriscos do mesmo tamanho da palavra
palavra_substituida = "*" * len(palavra_limpa)
# Mantém a pontuação original, se houver
palavra_substituida += palavra[len(palavra_limpa):]
nova_frase.append(palavra_substituida)
else:
nova_frase.append(palavra)

return " ".join(nova_frase) # Recria a frase

# Teste da função
textoEntrada = "O teste metia medo e foi mau!"
textoSaida = palavrasNegativasSubstituir(textoEntrada)

print(f"Texto original: {textoEntrada}")

print(f"Texto modificado: {textoSaida}")