Exercício Python

Estude pelo nosso site e tire certificado de 40 horas. Curso completo em: www.cursoemvideo.com/curso/python-3-mundo-2/

[@Fabsakae]

pelo site está com erro, vc assiste ate o final da aula e clica em marcar em concluído, ele não marca como visto e não consegui avançar as aulas. então provavelmente não vou conseguir o certificado.

[@vinicius1147]

@@Fabsakae tem q pagar o certificado, mó pala errada

[@mikeiasbarros8780]

nem tenho computador, estudo e escrevo códigos em meu caderno! e, as vezes, uso o Qpython pra programar no Android. E as aulas são excelentes, parabéns prof:

[@niltoncs7739]

Você será um excelente programador utilizando essa técnica. Quando programar direto no computador, você fará o computador fazer tudo que você quiser. Continue fazendo o curso pq didática e o cronograma estão excelentes. Abç

[@mundozero765]

Estudei algoritmo so no caderno. Nao desisti que em breve tudo vai parece mt facil!

[@filhodoarthur8516]

Somos 2 estou sem PC e escrevo tudo o que o professor Guanabara fala e faço meu código s tudo no Android e sempre dá certo. Fora usar minha família como alunos kkkk Encino para todos o que eu aprendo e eu acho que funciona kk

[@JoaoOliveira-fz2nv]

Mikeias Barros kk nem eu;-;

[@BrunoSantos-zy2fu]

Parabéns pelo empenho show!

[@lucianograna5955]

Vou dar um testemunho aqui: antes de fazer o curso de Python eu fiz o Curso de Lógica da Programação, com o Guanabara mesmo, e quando eu comecei eu estava bem enferrujado "intelectualmente", VÁRIOS exercícios quase me fizeram parar de estudar, batia um baita desespero porque eu sempre fui bem ruim em matemática, mas nesse curso de Python eu estou tirando TUDO de letra, parte por eu já ter visto muito dos fundamentos anteriormente mas o mérito maior é por eu estar mais "afiado", as resoluções simplesmente surgem na minha cabeça assim que o Guanabara dá o exercício. Resumo: continuem, mesmo que pareça que algumas coisas não entram na sua cabeça, porque quando entrar você vai ficar cada vez mais lógico, e desafios que pareciam complicados vão se tornando cada vez mais fáceis!

[@josiasberlamino8114]

Pessoal estou aí em 2022 estudando, e não é fácil eu sei. É minha primeira linguagem de programação, e trabalho, sou casado e tenho um filho, e sei que dói as vezes caímos, mas não desista. Vamos pra cima que o curso já está todo pronto e o certificado do mundo 2 é nosso, assim como foi citado lá no primeiro mundo a necessidade de programadores é gigante então faça parte dos 1.600.000. tmj

[@JoaoVitor-pd8fj]

Fala Josias, beleza? Também estou fazendo em 2022. Se quiser trocar ideia sobre e se ajudar chama nós!

[@marechalsuper9005]

tbm 2022

[@brunoalves3192]

Espero que tenha conseguido se formar em python totalmente já!

[@jordanoficial5595]

depressão e o desanimo me consumindo, mas não vou parar. As aulas são muito boas e o professor é incrível

[@claudioaraujo923]

Alguém estudando python em 2021? Cara essa aula foi diferenciada, valew Guanabara! Curso Top!

[@elouzeiro]

Cara eu fiz hoje 05/10/21 - apanhei pra fazer dar certo pq não lembrei de aninhar corretamente os comandos... Sem contar que escrevi um código mais longo que o Guanabara kkkk

[@claudioaraujo923]

@@elouzeiro Próximo exercício (ex044) é muito TOP também cara, tentei resolver mas tive que apelar para o vídeo! @Guanabara realmente possui a dádiva dos ninjas para ensinar!

[@alguemae4517]

eai man kkskskskskskksskk essa aula foi o carai pra conseguir fazer kskkssksks

[@novodreydrey7304]

estou em setembro de 22 kkk, consegui fazer usando exit()

[@garcialoine]

No exercício 039 eu abri um 039B pois ele desafiou embutir o sexo, sendo o feminino não precisar se alistar... Consegui fazer parcialmente e marquei para voltar nele.... Com a resolução desse exercício, o 042, consegui voltar e resolver com clareza! Meu Deus, estou amando o curso! Obrigada por tudoooooo, Guanabara ❤️

[@rell4239]

Cara, eu fiz esse exercício ano passado, e lembro de ter muita dificuldade. Tive que parar os estudos, e retornei esse ano. E hoje parece tão simples. Minha lógica está evoluindo bem. Obrigado professor !!!!

[@magestic_tv]

eu fiz esse exercício um pouco diferente, coloquei a regra dos triângulos associado tanto ao código do escaleno quanto ao código do retângulo, ficou uma linha bem mais longa, mas achei mais seguro e seguiu melhor meu raciocínio fazer dessa forma. muito legal essa outra forma de if dentro de if

[@brunomagalhaes6257]

Fiz um pouquinho diferente, as vezes até esquecer de usar esse if dentro do IF kkk, e também acho melhor estabelecer uma váriavel para coisas constantes como a regra para ser escaleno e tal; p1 = float(input('Primeiro Segmento: ')) p2 = float(input('Segundo Segmento: ')) p3 = float(input('Terceiro Segmento: ')) isosceles = p1 == p2 != p3 or p1 == p3 != p2 or p2 == p3 != p1 escaleno = p1 != p2 != p3 != p1 equilatero = p1 == p2 == p3 triangulo = p1 + p2 > p3 and p1 + p3 > p2 and p2 + p3 > p1 if triangulo == True and triangulo== isosceles: print('Os segmentos acima PODEM FORMAR um triângulo Isosceles') elif triangulo==True and triangulo == escaleno: print('Os segmentos podem formar um triângulo Escaleno.') elif triangulo==True and triangulo == equilatero: print('Os segmentos podem formar um triângulo Equilatero.') else: print('NÃO PODEM FORMAR UM TRIÂNGULO')

[@oimeuchapa6476]

Uma dica, tenha cuidado, ao ficar estabelecendo variáveis desnecessárias. Isso consome memória ram e quanto mais você aderir o hábito de sempre pensar na forma mais prática de escrever o seu código, melhor será seu aprendizado.

[@DuRodoCore]

pior eu pensei nisso quando tava na metade do codigo ai deixei do jeito que tava fazendo mesmo e ficou simplesmente ridiculo kkkkkkkkkkkkk. r1 = float(input('Primeiro segmento: ')) r2 = float(input('Segundo segmento: ')) r3 = float(input('Terceiro segmento: ')) if r1 == r2 == r3: print('Os segmentos podem formar um triangulo EQUILATERO. ') elif r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2 and r1 == r2 == r3: print('Os segmentos podem formar um triangulo Isósceles.') elif r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2 and r1 != r2 and r2 != r3 and r3 != r1: print('Os segmentos podem formar um triangulo Escaleno') else: print('Os segmentos não podem formar um triangulo. ')

[@rafaelalexandre8208]

eu fiz assim também

[@neiribeiroclpta]

Sigo aprendendo. Obrigado por compartilhar. É ensinando que aprendemos mais!! Exercício 42 usando parte do exercicio 35: print('-='*30) print(' Analisador de triângulos v. 2.0 ') print('-='*30) l1=float(input('Digite a medida do lado 1: ')) l2=float(input('Digite a medida do lado 2: ')) l3=float(input('Digite a medida do lado 3: ')) if (l1+l2)

[@Surupembado]

antes de assistir o exercício, eu fiz ele e consegui obter os mesmos resultados. Quando eu assisti o exercício, vi que o professor fez de outra maneira. vou colocar como eu fiz r1 = float(input('Primeiro segmento: ')) r2 = float(input('Segundo segmento: ')) r3 = float(input('Terceiro segmento: ')) if r1 == r2 and r1 == r3: print('Os seguimentos acima PODEM FORMAR um triângulo EQUILÁTERO') elif r1 == r2 or r1 == r3 or r3 == r2: print'(Os segmentos acima PODEM FORMAR um triângulo ISÓSCELES') elif r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2: print('Os segmentos acima PODEM FORMAR triângulo ESCALENO') else: print('Os Segmentos acima NÃO PODEM formar um triângulo')

[@Fx-ct9vj]

nd haver esse código seu

[@lucasemanoel21]

@@Fx-ct9vj calma jovem. Ele só esqueceu de confirmar se forma ou não um triângulo, n tire o mérito do rapaz por ter tentado fazer sem assistir a aula!

[@pat.mp4]

Eu dei uma incrementada extra nesse código. O meu código pergunta ao usuário se ele quer usar centímetros ou metros, a partir daí ele segue o programa perguntando os comprimentos dos segmentos. O código é cheio de cor e eu fiz de uma maneira diferenciada da do Guanabara, adicionei até uma função para ver se ele pode formar um triângulo retângulo. Esse está sendo o primeiro curso que estou fazendo de programação, porém eu pesquisei bastante na internet para resolver algumas coisas anteriormente a esse exercício e isso me ensinou muito. Por incrível que pareça, na versão anterior desse exercício eu já tinha feito igual a essa versão, porém nessa o código ficou muito melhor pq eu aprendi a usar o elif. Meu código ficou assim: from sys import exit from time import sleep quemed = str(input(' Deseja inserir as medidas de comprimento utilizando metros ou centímetros?' ' Digite [ C ] para centímetros e [ M ] para metros. ' ' Sua resposta: ').strip().upper()) med = '' medabr = '' if quemed == 'C': med = 'centímetros' medabr = 'cm' elif quemed == 'M': med = 'metros' medabr = 'm' else: print(' \033[1:31mResposta inválida \033[mPrograma encerrando...') sleep(1) exit() priseg = float(input(' Digite o comprimento do primeiro segmento em {}:'.format(med))) segseg = float(input(' Digte o comprimento do segundo segmento em {}: '.format(med))) terseg = float(input(' Digite o comprimento do terceiro segmento em {}: '.format(med))) catets = [priseg, segseg, terseg] hipot = max(catets) catets.remove(max(catets)) def triangletype(): if priseg == segseg == terseg: print('\033[1:32m=-=' * 10, ' \033[1:32m Este triângulo é \033[4mequilátero\033[m\033[1:32m. ' + '=-=' * 10, '\033[m', ' ') elif priseg == segseg != terseg or priseg == terseg != segseg or segseg == terseg != priseg: print('\033[1:32m=-=' * 9, ' \033[1:32mEste triângulo é \033[4misósceles\033[m\033[1:32m. ' + '=-=' * 9, '\033[m', ' ') else: print('\033[1:32m=-=' * 9, ' \033[1:32mEste triângulo é \033[4mescaleno\033[m\033[1:32m. ' + '=-=' * 9, '\033[m', ' ') def trianglerectangle(): if hipot ** 2 == (catets[0] ** 2) + (catets[1] ** 2): print('\033[1:36m=-=' * 14, ' Este triângulo é um \033[4mtriângulo retângulo\033[m\033[1:36m. ' ' \033[1:36mSua \033[4:30mhipotenusa\033[m\033[1:36m mede \033[4:30m{}\033[m\033[1:36m {}' ' Um dos \033[4:30mcatetos\033[m\033[1:36m mede: \033[4:30m{}\033[m\033[1:36m {}' ' O outro \033[4:30mcateto\033[m\033[1:36m mede: \033[4:30m{}\033[m\033[1:36m {}' .format(hipot, medabr, catets[0], medabr, catets[1], medabr)) print('\033[1:36m=-=' * 14) else: print('\033[1:36m=-=' * 15, '\033[1:36m Este triângulo \033[4mnão é um triângulo retângulo\033[m\033[1:36m. ' '' + '\033[1:36m=-=' * 15) if priseg + segseg > terseg and priseg + terseg > segseg and terseg + segseg > priseg: print('\033[1:35m=-=' * 14, ' Estes segmentos podem formar um triângulo. ' + '=-=' * 14, '\033[m', ' ') triangletype() trianglerectangle() else: print(' \033[1:31mEstes segmentos não formam um triângulo') OBS: Em todos os exercícios eu to procurando dar uma incrementada a mais do que o Guanabara pede kkkk. Curso incrível Guanabara!!!!!!

[@pat.mp4]

Talvez meu código nn funcione adequadamente se copiar e colar pq algumas partes podem aparecer em negrito por causa da dupla "*" ou o código nn seja bem formado na hora de colar.

[@pat.mp4]

No meu eu testei e funcionou, sla se vai ir no seu kkkkkk

[@rafaelnascimento5556]

caraca maluco hahahahha esse foi brabo, quem ficou enrolado igual a mim, refaça exercícios isso ajudará a assimilar vários conteúdos. Não desistam.

[@gabrieldacruzmaia2203]

Melhor professor de Python in the world! Parabéns pelas aulas!

[@carpejany]

a>b or ac or a

[@viniciusmartins9905]

Apenas uma observação: No minuto 8:30 desse vídeo, o professor da o exemplo de diferença que A pode ser diferente de B, que, por sua vez, pode ser diferente de C, mas que C pode também ser IGUAL a B. Ele deu o exemplo do triângulo isósceles que foi reconhecido pelo programa como escaleno. Ele disse que isso acontece porque devemos constar no programa que C também é diferente de A, desta forma: "elif reta1 != reta2 != reta3 != reta1:" Porém, isso apenas aconteceu porque ele não havia programado o reconhecimento do triângulo isósceles. Se, ANTES do reconhecimento do triângulo escaleno houvesse um reconhecimento do triângulos isósceles, o programa funcionaria perfeitamente bem (como ocorreu no meu caso mesmo sem citar que C é diferente de A, o que foi ensinado pelo professor) MAS..... como um programador profissional tem programas com inúmeras linhas de código, é muito fácil de se enroscar em erros mínimos como este, então é sempre bom corrigi-los, cortando assim o mal pela raiz antes que um problema maior se formasse! (Duvido que alguém leia isso, mas tá aí o fato kkkkk)

[@MayconBS]

Boa observação, mas quando estava fazendo também decidi deixar a verificação de isósceles de fora por ser maior. Lógica para verificar isósceles seria a == b != c or a == c != b or b == c != a

[@dann_ml]

Foi o exercício que achei mais difícil até agora... pensei bastante!

[@oimeuchapa6476]

Todos até agora achei bem fácil, por exemplo, assim que termino de ver a aula, já pego e faço todos de uma vez só e bem rápido. Talvez eu esteja ficando doido já. kkkkkkkkk 🤣

[@kaiwang9805]

OLA! sou novo em programação, e já cheguei a esta aula, estou muito feliz pelo meu progresso. consegui criar um programa que calcula investimento, sendo quantidade de investimento inicial + parcelas mensais e juros composto sobre o valor investido. A ferramenta me da a previsão de lucro todos meses o total que lucrei no final em % e diferença do me valor investido. Agora só falta adicionar o calculo da inflação no programa que estou quebrando a cabeça mas logo vou conseguir tambem ^^

[@pedromaraba411]

Boa mano, ta trabalhando na area atualmente?

eu estou a começar a tua serie desde o 1 episódio ! continua com o bom trabalho

[@jodevampiresdearaujo3639]

#Ex042_Analisando triângulos print(44*'-') print('Verificando se as retas formam um triângulo.') print(44*'-') a = float(input('Primeira reta: ')) b = float(input('Segunda reta: ')) c = float(input('Terceira reta: ')) if a >= b + c or b >= a + c or c >= a + b: print('Os retas não formam um triângulo.') elif a == b == c: print('Triângulo Equilátero') elif a == b != c or a == c != b or b == c != a: print('Triângulo Isosceles') else: print('Triângulo Escaleno')

[@Seu0Madruga]

@@jodevampiresdearaujo3639 deixa ele fazer man

[@rogerioanselmo9435]

Olá, professor Guanabara! Tudo bem com você? Quero lhe dá os parabéns pela didática aplicada nos treinamentos. Estou iniciando no mundo da programação e decidi começar pela linguagem Python e com você ministrando as aulas eu fico muito seguro em desenvolver os exercícios ao qual são solicitados. Grande abraço, irmão!

[@thomasvmf3984]

Po eu tinha pego um caminho bem mais longo kkk # refazer o 35 a = float(input('Primeiro segmento: ')) b = float(input('Segundo segmento: ')) c = float(input('Terceiro segmento: ')) if a == b == c: tipo = 'EQUILÁTERO' elif a == b and a != c or a == c and a != b or b == c and b != a: tipo = 'ISÓSCELES' elif a != b != c: tipo = 'ESCALENO' if a < b + c and b < a + c and c < a + b: print('Os segmentos acima PODEM FORMAR um triângulo {}'.format(tipo)) else: print('Os segmentos acima NÃO PODEM FORMAR um tr

[@joaoxavier6704]

por que no isósceles tu preciosa expecificar que a==b e A =! C pq se a foi igual a C ele será equilátero e ficaria na primeira opção então por que tem q especificar isso?

[@renansaraiva4455]

​@@joaoxavier6704 isoceles um lado tem que ser diferente dos outros dois o caso de a == c, sria uma outra hipotese, dai então teria que a != b. é como se tivesse 3 sentenças, cada sentença tem sua hipotese, e o problema da tua pergunta é que tu ta misturando as hipoteses. 1. sentença a == b and a != c (logicamente b != c) - se isso não satisfaz, vá para segunda sentença or 2. sentença a == c and a != b (logicamente c != b) - se isso não satisfaz, vá para terceira senteça or 3. sentença b == c and b != a (logicamente c !=a) recomendo que de uma analisada em portas lógicas de programação, pode te ajudar no entendimento.

[@thecreators7940]

@@renansaraiva4455 porém como no primeiro if ele verifica se os três são iguais logo se um for diferente cairá na segunda posição

[@pedrocamargo278]

@@thecreators7940 pois é, uma solução bem mais simples

[@paulogamelas5125]

Eita Guanabara melhor professor que ja vi.....aprendi mais uma hoje, essa questão de aninhamento de condições vira a chave!

[@leonardocostasantos1321]

""" EXERCÍCIO 042: Refaça o DESAFIO 035 dos triângulos, acrescentado o recurso de mostrar que tipo de triângulo será formado: - Equilátero: todos os lados iguais - Isósceles: dois lados iguais - Escaleno: todos os lados diferentes """ s1 = float(input('Primeiro segmento: ')) s2 = float(input('Segundo segmento: ')) s3 = float(input('Terceiro segmento: ')) if s1 < s2 + s3 and s2 < s1+s3 and s3 < s1+s2: if s1 == s2 and s2 == s3: print('Os segmentos acima PODEM FORMAR um triângulo EQUILÁTERO!') elif s1 == s2 or s1 == s3 or s2 == s3: print('Os segmentos acima PODEM FORMAR um triângulo ISÓSCELES!') else: print('Os segmentos acima PODEM FORMAR um triângulo ESCALENO!') else: print('Os segmentos acima NÃO PODEM FORMAR um triângulo!')

[@PatrickGandolff]

Fiz certo mas não sabia do "if" dentro do "if" usando "elif "e "else" tb! Deu um monte de erro, mas depois de corrigir e usar algumas vezes o TAB, ficou tudo resolvido!!!! Programador ainda em 2024!!!

[@canaldovitao99]

kk tbm deu um monte de erro o meu, até eu atentar para o TAB

[@livesdayrots8584]

Meta de trabalhar na área ainda em 2023!!!! hoje 04/01/23 Estou muito feliz em já começar acertando sozinho! EXERCICIO#42: print('\033[1;35mVejamos se 3 linhas formam um triangolo\033[m') lin1 = int(input('Comprimento da primeira linha: ')) lin2 = int(input('Comprimento da segunda linha: ')) lin3 = int(input('Comprimento da terceira linha: ')) if lin1 != lin2 != lin3 and lin1 + lin2 >= lin3 and lin1 + lin2 >= lin3 and lin1 + lin3 >= lin2: print('Triangolo escaleno') elif lin1 == lin2 == lin3: print('Triangolo equilátero') elif lin1 == lin2 and lin1 + lin2 >= lin3 or lin2 == lin3 and lin1 + lin2 >= lin3 or lin1 == lin3 and lin1 + lin3 >= lin2: print('Triangolo isósceles') else: print('Não pode-se formar um triangulo')

[@miguelrighes3561]

conseguiu trabalho?

[@yoaimo_d32]

@@miguelrighes3561 o cara morreu mn

[@ronyteodoro]

Fiz assim e deu certo tambem! A quantidade de linhas de codigo sao iguais porem usei uma lista pra fazer a validaçao de se é triangulo ou não # Recebe os lados informados pelo usuário l1 = float(input('Digite o primeiro lado: ')) l2 = float(input('Digite o segundo lado: ')) l3 = float(input('Digite o terceiro lado: ')) # Cria uma lista e ordena os lados ls = sorted([l1, l2, l3]) # Crio uma validação que retorna se o triangulo pode ser formado com True ou False validar = ls[0] + ls[1] > ls[2] # Se os 3 lados forem iguais formam um triangulo equilatero if l1 == l2 == l3: print('Suas medidas formam um Triângulo Equilátero.') # Ou se medidas validas e 2 lados forem iguais formam um triangulo Isósceles elif validar is True and ls[0] == ls[1] or ls[0] == ls[2] or ls[1] == ls[2]: print('Suas medidas formam um Triângulo Isosceles.') # Ou se medidas validas e 3 lados diferentes formam um triangulo Escaleno elif validar is True and ls[0] != ls[1] != ls[2]: print('Suas medidas formam um Triângulo Escaleno.') # Se nenhuma condição se encaixar, retorna mensagem negativa else: print('Suas medidas não formam um triângulo')

[@rfelix8095]

O certo seria: if r1 + r2 > r3 and r2 + r3 > r1 and r3 + r1 > r2 Se fizer do jeito que o professor passou: if r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2 # Caso for colocar um valor muito grande comparado com os outros em algum dos input vai dar um erro

[@renansaraiva4455]

vlw... mas acredito que só um é ncessário, digo, somente o r2 + r3 > r1

[@renansaraiva4455]

ei, poderia me dar um exemplo de um possível erro?

[@erikaalves2848]

Quase surtei com esse exercicio achando q minha logica tava errada, mas tava errando na SYNTAX!!! O programa tava dando erro por eu ta colocando & ao invés de 'and' 🥲🥲. Mds esse tipo de erro mata mesmo, isso quando o pycharm n buga😵😵

[@Amanda-qe5lj]

Tive dificuldade pra fazer, também não lembrava que podia usar if dentro de if, achei que o padrão era um if, quantos elifs eu quiser e o else era um ou nenhum, intermediário seg1 = int(input('Primeiro segmento: ')) seg2 = int(input('Segundo segmento: ')) seg3 = int(input('Terceiro segmento: ')) if seg1 < (seg2 + seg3) and seg2 < (seg3 + seg1) and seg3 < (seg1 + seg2): print('Os segmentos acima PODEM FORMAR um triângulo ', end='') if seg1 == seg2 == seg3: print('EQUILÁTERO!') elif seg1 != seg2 != seg3 != seg1: print('ESCALENO!') else: print('ISÓCELES!') else: print('Os segmentos acima NÃO PODEM FORMAR um triângulo')

[@LukeSkywalker-xl5ph]

Eu tbm n lembrava do if dentro do if.. olha a forma q fiz. '''print('-='*20) print("VAMOS FORMAR UM TRIANGULO?") print('-='*20) print('Vamos escolher a medida dos tres lados.') a1=float(input('Digite o primeiro lado: ')) a2=float(input('Digite o segundo lado: ')) a3=float(input('Digite o terceiro lado: ')) if a1+a2>a3 and a1+a3>a2 and a3+a2>a1 and a1==a2==a3: print('Com essas medidas FORMAM um triangulo EQUILATERO!') elif a1+a2>a3 and a1+a3>a2 and a3+a2>a1 and a1!=a2!=a3: print('Com essas medidas FORMAM um triangulo ESCALENO') elif a1+a2>a3 and a1+a3>a2 and a3+a2>a1 and a1==a2 or a1==a3 or a3 == a2: print('Com essas medidas FORMAM um triangulo ESOSCELES') else: print('Com essas medidas NAO SE FORMA um triangulo!')'''

[@RafaelSTeles]

Guanabara, faltou inserir nas condições a premissa de que nenhum lado pode ser igual a ZERO, pois assim não existiria triângulo. Obrigado pelas aulas sensacionais! Sou fã do seu profissionalismo!

[@felipe.toschi]

08:47 Como eu fiz os isósceles antes, não deu esse problema...

[@douglasribeiro2571]

Fiz dessa maneira e deu o mesmo resultado, não sabia a simplificação dos aninhamentos, obrigado cara, você diferente dos iguais! kkkkkkk print("-="*20) print(" Analisador de Triângulos") print("-="*20) r1 = float(input(" Qual o tamanho da primeira reta?")) r2 = float(input(" Qual o tamanho da segunda reta?")) r3 = float(input(" Qual o tamanho da terceira reta?")) if r1 == r2 == r3 and r2 == r1 == r3 and r3 == r2 == r1: print(" As medidas são iguais {},{},{} é possivel formar um triângulo Equilátero!" .format(r1,r2,r3)) elif r1 == r2 != r3 or r2 == r3 != r1 or r3 == r1 != r2: print(" As medidas são {},{},{} tem dois lados iguais e um diferente, é possivel formar um triângulo Isósceles!".format(r1, r2, r3)) elif r1 != r2 != r3 and r3 != r1 != r2 and r2 != r3 != r1: print(" As medidas são {},{},{} todos os lados são diferente, é possivel formar um triângulo Escaleno!".format(r1, r2, r3)) else: print("Nao é possivel formar um triângulo!")

[@highend3952]

Antes de assistir a resolução eu tinha feito assim: r1 = float(input('Primeiro comprimento: ')) r2 = float(input('Segundo comprimento: ')) r3 = float(input('Terceiro comprimento: ')) if r1 + r2 > r3 and r1 + r3 > r2 and r2 + r3 > r1 and r1 == r2 and r1 == r3 and r2 == r3: print('Podem formar um triângulo Equilátero.') elif r1 + r2 > r3 and r1 + r3 > r2 and r2 + r3 > r1 and r1 == r2 or r1 == r3 or r2 == r3: print('Podem formar um triângulo Isósceles.') elif r1 + r2 > r3 and r1 + r3 > r2 and r2 + r3 > r1 and r1 != r2 and r1 != r3 and r2 != r3: print('Podem formar um triângulo Escaleno.') else: print('Não podem formar um triângulo.')

[@guilhermelima192]

Também tinha feito desta forma , só q tinha imaginado a possibilidade de colocar if dentro de if ou melhor condições dentro de condições.

[@nathancintra]

fiz o meu igual...antes de assistir ao video....pensei que poxa sera que esta errado...mais é so uma forma diferente...fico feliz que o estudo esta dando frutos e programar é legal de mais

[@Edu-SanDevIstan]

Eu fiz assim no Isóceles: " elif lado1 == lado2 or lado3 == lado2 or lado1 == lado3: print('Dois lados são iguais, portanto é um triângulo isóceles!') " Mas realemente, essa de fazer um escaleno na condição de todos serem diferentes é uma sacada de gênio!

[@howcas8744]

Para fazer esse exercício, eu não pensei em botar um if dentro de outro if, então eu basicamente fiz o código ao contrário, fiz um if pra ver se o triângulo NÃO existia, e dali, passei por cada tipo de triângulo :) -Código básico: r1 = int(input('Digite o comprimento da primeira reta:')) r2 = int(input('Agora da segunda reta:')) r3 = int(input('E a terceira:')) # Verificar if r1 >= r2 + r3 or r2 >= r1 + r3 or r3 >= r1 + r2: print('Esse triângulo NÃO EXISTE!') # Determinar tipo de triângulo elif r1 == r2 and r1 == r3: print('Esse triângulo existe e ainda por cima é um triângulo EQUILÁTERO!') elif r1 == r2 or r1 == r3: print('Esse triângulo exite e ainda é um ISÓCELES!') else: print('Esse é um triângulo ESCALENO!') -Código inteiro: (eu adicionei cores :3) # Objetivo: Determinar se 3 retas formam um triângulo, e se formam, qual tipo de triângulo c_inv = '\033[7m' c_vml = '\033[31m' c_vrd = '\033[32m' c_azl = '\033[34m' c_lmp = '\033[m' print(c_vml + '-=-' * 8 + c_lmp) print('{}{}ESSE TRIÂNGULO EXISTE?{}.PY{}'.format(c_azl, c_inv, c_vrd, c_lmp)) print(c_vml + '-=-' * 8 + c_lmp) # Coleta de dados r1 = int(input('Digite o comprimento da primeira reta:')) r2 = int(input('Agora da segunda reta:')) r3 = int(input('E a terceira:')) # Verificar if r1 >= r2 + r3 or r2 >= r1 + r3 or r3 >= r1 + r2: print('Esse triângulo {}NÃO EXISTE{}!'.format(c_inv, c_lmp)) # Determinar tipo de triângulo elif r1 == r2 and r1 == r3: print('Esse triângulo existe e ainda por cima é um triângulo {}EQUILÁTERO{}!'.format(c_vml, c_lmp)) elif r1 == r2 or r1 == r3: print('Esse triângulo exite e ainda é um {}ISÓCELES{}!'.format(c_azl, c_lmp)) else: print('Esse é um triângulo {}ESCALENO{}!'.format(c_vrd, c_lmp))

[@boykajunior1]

Caraca, eu nao tinha pensado em colorir dessa forma com .format. Eu sempre coloria diretamente com ''\033'' ou com a biblioteca Fore. Mto bom, vou aderir kkkkk' Obg pelo compartilhamento!

[@wesleysantos6289]

Nessa eu bato palmas pro python, a comparação é muito melhor que a forma tradicional, lembro que eu queria poder fazer exatamente assim nas outras linguagens, mas por já estar acostumado do jeito tradicional terei que praticar bastante nesta etapa!

[@mikaelx9325]

#Verificador de triângulos v2.0 l1 = float(input('Digite o primeiro lado:')) l2 = float(input('Digite o segundo lado:')) l3 = float(input('Digite o terceiro lado:')) if (l2+l3) > l1 and (l1+l3) > l2 and (l1+l2) > l3: if l1 == l2 == l3: print('Os lados podem formar um triângulo equilátero.') elif l1 == l2 or l1 == l3 or l2 == l3: print('Os lados podem formar um triângulo isóscelis.') else: print('Os lados podem formar um triângulo escaleno.') else: print('Os lados não poder fomar um triângulo.')

[@alexalmeida6893]

A condição pra saber se é triângulo segue esse formula "condição = abs(a - b) < a < b + c" Nesse caso não precisa fazer os 3 teste, basta uma vez e sempre vai funcionar.

[@rodrigofelix4728]

Eu resolvi o problema do ISÓSCELES deixando ele por ultimo! O meu ficou assim. r1 = float(input('Digite o primeiro valor do triangulo ')) r2 = float(input('Digite o segundo valor do triangulo ')) r3 = float(input('Digite o terceiro valor do triangulo ')) a = r1 < r2 + r3 b = r2 < r1 + r3 c = r3 < r1 + r2 if a and b and c == True: print('\033[34mEsses valores podem formar um triangulo!\033[m') if r1 == r2 == r3: print('Esse triangulo é Equilátero!') elif r1 == r2 or r1 == r3 or r2 == r3: print('Esse triangulo é Isósseles!') elif r1 != r2 != r3: print('Esse triangulo é Escaleno!') else: print('\033[31mEsses valores não podem formar um triangulo\033[m')

[@cyberneoon]

eu tambem o meu ficopu diferente mas funciona

[@jhonny12399]

Tbm fiz o Isósceles desse jeito R1 == r2 or R1 == r3 or r2 == r3

[@zGrover402]

O princípio matemático está errado, se você apenas diz que dois lados precisam ser iguais logo todo triângulo equilátero seria isósceles já q tem todos os lados iguais. Não sei se funciona, mas procure evitar esse tipo de erro

[@wladimircosta9920]

Meu codigo ficou assim e tambem funcionou, porem if dentro de if é bem mais simples xD # EQUILATERO: TODOS OS LADOS IGUAIS # ISÓCELES: DOIS LADOS IGUAIS # ESCALENO: TODOS OS LADOS DIFERENTES from time import sleep s1 = float(input('Digite o numero do primeiro seguimento:')) s2 = float(input('Digite o numero do segundo seguimento:')) s3 = float(input('Digite o numero do terceiro seguimento:')) print('ANALISANDO ESTRUTURA TRIANGULAR...') sleep(3) if s2 + s3 > s1 == s2 == s3 < s2 + s1 and s2 < s1 + s3: print('Com os seguimentos {}, {} e {} é possivel criar um TRIANGULO EQUILATERO'.format(s1, s2, s2)) elif s2 + s3 > s1 == s2 != s3 < s2 + s1 and s2 < s1 + s3: print('Com os seguimentos {}, {} e {} é possivel formar um TRIANGULO ISÓCELES'.format(s1, s2, s3)) elif s2 + s3 > s1 != s2 != s3 < s2 + s1 and s2 < s1 + s3: print('Com os seguimentos {}, {} e {} é possivel formar um TRIANGULO ESCALENO'.format(s1, s2, s3)) else: print('Com os seguimentos {}, {} e {} não é possivel formar um triangulo'.format(s1, s2, s3))

[@pred4dorexion577]

Você Disse que não dava pra fazer se tivesse elif embaixo do if ! Eu fiz dessa forma e deu! print('-='*20) print('Analisador de Triângulos') print('-='*20) r1 = float(input('Primeiro segmento: ')) r2 = float(input('Segundo segmento: ')) r3 = float(input('Terceiro segmento: ')) triângulo = r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2 Equilátero = r1 == r2 and r3 == r1 Isóceles = r1 == r2 and r3 != r1 and r3 != r2 or r3 == r2 and r3 != r1 or r1 == r3 and r1 != r2 Escaleno = r1 != r2 and r3 != r1 if triângulo and Equilátero: print('Podem Formar Triângulo Classificação: EQUILÁTERO') elif triângulo and Isóceles: print('Podem Formar Triângulo Classificação: ISÓCELES!') elif triângulo and Escaleno: print('Podem Formar Triângulo Classificação: ESCALENO!') else: print('Não podem formar triângulo.') OBRIGADO PELO SEU CURSO EM PYTHON EU NÃO SABIA EXATAMENTE NADA Á 3 DIAS ATRÁS E AGORA OLHA O QUE EU TO FAZENDO! VOCÊ É INCRIVEL! (JÁ ATÉ PEGUEI MEU CERTIFICADO)

[@jacksonmoura9972]

também fiz parecido e deu certo: s1 = float(input('Primeiro segmento: ')) s2 = float(input('Segundo segmento: ')) s3 = float(input('Terceiro segmento: ')) if s1 > s2 + s3 and s2 > s1 + s3 or s3 > s1 + s2: print('Os segmentos não formam um triângulo.') elif s1 == s2 and s1 == s3 and s3 == s2: print('O triângulo é EQUILÁTERO.') elif s1 == s2 != s3 or s1 == s3 != s2 or s3 == s2 != s1: print('O triângulo é ISÓSCELES.') else: print('O triângulo é ESCALENO.')

[@andreoliveira8122]

@@jacksonmoura9972 foda e que pode acontecer de dizer que e um triângulo mas não ser, o certo seria (S1 - s2) < s3

[@odoaco8964]

OBS: Não liga pro nome das variáveis, eu tenho a mentalidade de um aluno da 5° série : ) bu = float(input('Lado 1: ')) ce = float(input('Lado 2: ')) ta = float(input('Lado 3: ')) if bu < ce + ta and ce < bu + ta and ta < ce + bu: vrau = True and print('Essas medidas podem formar um triângulo') else: vrau = False if vrau == False: print('Essas medidas não podem formar um triângulo') elif vrau == True and bu == ce == ta: print('equilátero') elif vrau == True and bu == ce or ta == ce or bu == ta: print('isóceles') elif vrau == True and bu != ce != ta != bu: print('escaleno')

[@none-iw9sg]

l1 = float(input('Infomer o primeiro lado do triangulo em metros: ')) l2 = float(input('Informe o segundo lado do triangulo em metros: ')) l3 = float(input('Informe o terceiro lado do triangulo em metros: ')) if l1 < l2 + l3 and l2 < l1 + l3 and l3 < l1 + l2 and l1 == l2 and l2 == l3: print('Ok, suas medidas formam um triangulo EQUILATERO') elif l1 < l2 + l3 and l2 < l1 + l3 and l3 < l1 + l2 and l1 != l2 and l2 != l3 and l1 != l3: print('Ok, suas medidas formam um triangulo ESCALENO.') elif l1 < l2 + l3 and l2 < l1 + l3 and l3 < l1 + l2 and l1 == l2 and l1 != l3 or l1 == l3 and l1 != l2: print('Ok, suas medidas formam um triangulo ISOCELES.') else: print("Suas medidas nao formam um triangulo.")

[@FabioSantos-jf7wg]

Esse professor é muito bom.

[@alexmagno2]

Pra quem quiser um desafio adicional, tentem dizer se o triângulo é retângulo, obtusângulo ou acutângulo. Eu fiz assim: l1=float(input('Digite um lado do triângulo: ')) l2=float(input('Digite outro lado do triângulo: ')) l3=float(input('Digite o último lado do triângulo: ')) hip=max([l1, l2, l3]) if hip==l1: c1=l2 c2=l3 elif hip==l2: c1=l1 c2=l3 else: c1=l1 c2=l2 if hip>=(c1+c2): print(f'É impossível formar um triângulo de lados {hip}, {c1}, {c2}.') elif hip>(c1*c1+c2*c2)**0.5: angulo='obtusângulo' elif hip==(c1*c1+c2*c2)**0.5: angulo='retângulo' else: angulo = 'acutângulo' if hip>=(c1+c2): c2=1 elif hip==c1 and c1==c2: lado='equilátero' elif hip==c1 or c1==c2 or hip==c2: lado='isósceles' else: lado='escaleno' if hip>=(c1+c2): c2=1 else: print(f'O triângulo é um triângulo {angulo} e {lado}.')

[@lucasraphael2157]

Ótimas auls e curso fantástico! Segue minha resolução, 2020 r1 = float(input('Primeiro segmento: ')) r2 = float(input('Segundo segmento: ')) r3 = float(input('Terceiro segmento: ')) if r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2: print('Os segmentos acima PODEM FORMAR um triângulo') if r1 == r2 == r3: print('Será formado um triângulo EQUILÁTERO!') elif r1 == r2 or r1 == r3 or r2 == r3: print('Será formado um triângulo ISÓSCELES') else: print('Será formado um triângulo ESCALENO') else: print('Os segmentos acima NÃO PODEM formar um triângulo')

[@andersonsoares4348]

2019 print('-=-' * 20) print('ANALISADOR DE TRIÂNGULOS') print('-=-' * 20) r1 = float(input('Primeiro segmento: ')) r2 = float(input('Segundo segmento: ')) r3 = float(input('Terceiro segmento: ')) if r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2: if r1 == r2 and r2 == r3 and r1 == r3: print('Os segmentos podem formar um triângulo e ele é EQUILÁTERO') elif r1 == r2 != r3 and r2 == r3 != r1 or r1 == r3 != r2: print('Os segmentos podem formar um triângulo e ele é ISOCÉLES') elif r1 != r2 and r2 != r3 and r1 != r3: print('Os segmentos pode ser tornar um triângulo e ele é ESCALENO') else: print('Os seguimentos NÃO podem formar um Triângulo!')

[@zainzk9430]

APRENDE PORTUGUES depois programa kkk

[@zainzk9430]

formula errada , pois se digitarmos 3,3,2 não da nada

[@andersonsoares4348]

@@zainzk9430 *PORTUGUÊS* é mais difícil

[@godzyla07]

Nossa realmente eu fiquei estacado na parte do Isósceles porque são muitas comparações a serem feitas, utilizando o else: não tem mais esse problema, faz as duas comparações que são faceis e depois só colocar o else caso não seja as de cima, obrigado professor. ps: fiquei pensando por horas hahaha

[@eliseuantonio6652]

cores = {'limpa': '\033[m', 'negrito': '\033[1m', 'vermelho': '\033[1;31m', 'verde': '\033[1;32m', 'amarelo': '\033[1;33m'} titulo = 'Análise de Triângulo v2.0' print('{:=^35}'.format(titulo)) a = float(input('{}Reta 1: {}'.format(cores['vermelho'], cores['limpa']))) b = float(input('{}Reta 2: {}'.format(cores['verde'], cores['limpa']))) c = float(input('{}Reta 3: {}'.format(cores['amarelo'], cores['limpa']))) if b - c < a < b + c and a - c < b < a + c and b - a < c < a + b: print('{}As Retas Formam Um Triângulo{}'.format(cores['negrito'],cores['limpa'])) if a == b == c: print('{}E este triângulo é EQUILÁTERO{}'.format(cores['verde'],cores['limpa'])) elif a==b or a==c or b==c: print('{}E este triângulo é ISÓSCELES{}'.format(cores['verde'],cores['limpa'])) else: print('{}E este triângulo é ESCALENO{}'.format(cores['verde'], cores['limpa'])) else: print('{}As Retas Não Formam Um Triângulo{}'.format(cores['negrito'], cores['limpa']))

[@kakashioninjaquecopia1379]

TESTEI O SEU PROGRAMA. FICOU BONITO.

[@eliseuantonio6652]

Kakashi O Ninja Que Copia obrigado

[@Diego-lh8sz]

Muito pouco didático

[@eliseuantonio6652]

Diego no KZbin fica meio feio mesmo, ainda mais que eu não coloquei comentários, porém funciona e é colorido

[@Diego-lh8sz]

Eliseu Antonio é SÓ uma crítica construtiva, o program ficou foda, na os comentários ajuda muito os gafanhotos. ABS.

[@luizfelippo1818]

Eu consegui fazer de uma forma diferente mas o problema eh que vai contra os principios do python pq vai ficar complicado e grande demais quando poderia simplificar como esta o do gustavo... fica ate ai um aprendizado pra vcs em exemplo de que um mesmo codigo fazendo a mesma coisa pode ser bem simples ou bem complicado... isso eh muito interessante inclusive.Vou botar o meu codigo aq: r1 = float(input('Tell me the measure of the first line:')) r2 = float(input('Tell me the measure of the second line:')) r3 = float(input('Tell me the measure of the third line:')) if r1 == r2 == r3 and abs(r2 - r3) < r1 < r2 + r3 and abs(r1 - r3) < r2 < r1 + r3 and abs(r1 - r2) < r3 < r1 + r2: print('This triangle is a equilateral triangle.') elif r1 == r2 !=r3 and abs(r2 - r3) < r1 < r2 + r3 and abs(r1 - r3) < r2 < r1 + r3 and abs(r1 - r2) < r3 < r1 + r2 or r1 == r3 != r2 and abs(r2 - r3) < r1 < r2 + r3 and abs(r1 - r3) < r2 < r1 + r3 and abs(r1 - r2) < r3 < r1 + r2 or r2 == r3 != r1 and abs(r2 - r3) < r1 < r2 + r3 and abs(r1 - r3) < r2 < r1 + r3 and abs(r1 - r2) < r3 < r1 + r2: print('This triangle is a isosceles triangle.') elif r1 != r2 != r3 and abs(r2 - r3) < r1 < r2 + r3 and abs(r1 - r3) < r2 < r1 + r3 and abs(r1 - r2) < r3 < r1 + r2: print('This is a scalene triangle.') else: print('This line numbers cannot creat a triangle.')

[@giovane_ps]

Professor, creio que o seu código está errado... É possível sim formar um triângulo com os valores 1, 9 e 8. O erro no seu código é porque ao realizar a primeira verificação se é possível formar um triângulo com os valores, ele pergunta apenas se é menor, fazendo com que caso seja igual (como nos segmentos 1, 9 e 8, que resultam em um valor igual a soma dos outros valores (e não menor, como o seu código pede), e que formam sim um triângulo). O correto seria verificar se é menor ou igual (

[@Andrey-yi1ik]

Olá, ainda bem que você falou sobre esse erro. Fiz a correção no meu código e até fiz um comentário aqui no vídeo sobre isso. Esse é o resultado do meu código: print('\033[1;36m-=-\033[m' * 20) reta1 = float(input('Qual o comprimento da primeira reta?')) reta2 = float(input('Qual o comprimento da segunda reta?')) reta3 = float(input('Qual o comprimento da terceira reta?')) print('\033[1;36m-=-\033[m' * 20) # verificando se é possivel forma um triangulo if reta1

[@MonkeyDLuffy-xp5dg]

1+8= 9. 9 com 9, forma uma linha reta perfeita, não um triângulo.

[@marceloferreira1410]

o que eu me esforcei tentando fazer esse exercício não tá escrito, pelo menos umas 5/6 horinhas tentando. mas deu certo :)

[@Jefferson-zt3im]

Eu fiz assim e funcionou!!! Qualquer falha por favor avisar. print('\033[1:30:47m','*'*12,'FORMAÇÃO DE TRIÂNGULO','*'*12,'\033[m') l1=float(input("Digite o lado 1: ")) l2=float(input("Digite o lado 2: ")) l3=float(input("Digite o lado 3: ")) if l1

[@camilamoura87]

Fiz assim, acho que está certo. a = int(input("informe o primeiro lado do triângulo: ")) b = int(input("informe o segundo lado do triângulo: ")) c = int(input("informe o terceiro do triângulo: ")) if a + b > c and b + c > a and a + c > b: if a == b == c: print("É possível formar um triângulo Equilátero") elif a == b or b == c or a == c: print("É possível formar um triângulo Isóceles") else: print("É possível formar um triângulo escaleno") else: print('Não é possível formar um triângulo')

[@allan5422]

Eu fiz o escalo apenas colocando r1 != r2 != r3 e deu certo, mas eu já tinha incluído o isósceles, então não caiu no erro de dar sempre escaleno quando meu r1 e r3 forem iguais. :D

[@valdnersantos6310]

eu também fiz isso, só entendi que poderia dar errado quando ele mostrou

[@peter1112]

Demorei mais consegui KKKK, é muito gratificante quanto você roda e esta funcionando perfeitamente. aqui o meu: pri = float(input('Primeiro segmento: ')) seg = float(input('Segundo segmento: ')) ter = float(input('terceiro segmento: ')) esca = pri != seg != ter != pri isos = pri == seg != ter or seg == ter != pri or ter == pri != seg equi = pri == seg == ter if pri + seg < ter: print('Não pode formar um triangulo') elif esca: print('Este Triangulo é escaleno') elif isos: print('Este Triangulo é isósceles') elif equi: print('Este Triangulo é equilátero')

[@lulih26]

Adorei essa aula.

[@othonjsantos]

Eita que esse eu quebrei a cabeça, por fim só entendi vendo o vídeo mesmo!

[@ThiagoMoraesFarias]

Nossa... eu havia feito o código, mas não me atentei para a parte do triângulo escaleno, onde só fiz a diferença entre as retas 1, 2 e 3. Vlw Guanabara... Vivendo e aprendendo!

[@vittaday]

Tinha feito esse exercício corretamente mas de um jeito muito mais complexo pois usei o AND ao invés de aninhar um IF no outro (tinha esquecido) Nessas horas a gente vê como os exercícios e as correções são importantes, a gente as vezes ACHA que sabe algo, e aí o professor ensina uma forma muito mais simples de fazer tudo!

[@josiclerlemesilva4062]

Muito bom eu aprendi bastante com esse vídeo aula!!!

[@joserobertovelazquezotto289]

GUANABARA....VOCÊ É DEMAIS CARA!!!!!!

[@brunobitencourt895]

Curto bastante suas aulas, professor! Estão sendo bem interessantes nessa quarentena! Rs Como condição de verificação da existência do triângulo a partir dos segmentos de reta inputados, também seria possível usar de forma rápida, prática e, mantendo a intuitividade, ao invés de "r1 < r2 + r3 and r2 < r1 + r3 and r3 < r2 + r1"; "max(r1, r2, r3) < (r1 + r2 + r3 - max(r1, r2, r3))". Mesmo que você não ache mais prático, é sempre relevante ver diferentes formas de resolução de um mesmo problema e/ou novas funções que podem facilitar muito a vida no Python.

[@balbino4]

Muito obrigado, Gustavo Guanabara.

[@ryangoncalves611]

Eu consegui fazer com essa estrutura sem nem ver nada antes, inclusive colocando o if embaixo de if, você está criando um monstro, Guanabara.

[@ArthurWagner-z2o]

opa fiz um pouco diferente doq no video, mas o importante que deu certo e fiquei mt feliz de ter conseguido de certa forma sem mt esforco seg1 = int(input('primeiro segmento: ')) seg2 = int(input('segundo segmento: ')) seg3 = int(input('terceiro segmento: ')) if seg1 == seg2 == seg3: print('os segmentos acima podem formar um triangulo EQUILATERO') elif seg1 == seg2 or seg1 == seg3 or seg2 == seg3: print('os segmentos acima podem formar um triangulo ISOSCELES') elif seg1 + seg2 > seg3 and seg1 + seg3 > seg2 and seg3 + seg2 > seg1: print('os segmentos acima podem formar um triangulo ESCALENO')

[@victorsilva9000]

Eu dei uma olhadinha na aula de laços rsrsrs from math import sqrt print('Digite 3 lados de um triangulo para saber se esse triangulo pode existir, e como ele e classificado') cont1 = 0 for x in range(0,3): l=float(input('digite um lado do triangulo ')) #if l == 0: procurar um jeito de parar o programa se um lado for == 0 cont1+=1 if cont1 == 1: l1 = l elif cont1 == 2: l2 = l elif cont1 == 3: l3 = l #Condição de existencia de um triangulo if l1 < l2 + l3 and l2 < l1 + l3 and l3 < l2 + l1: ok='existe!' if l1 == l2 or l2 == l3: b='E é isosceles!' if l1 == l2 and l2 == l3: b='E é equilatero!' else: b='E é escaleno!' else: ok='não existe!' b='' print('O triangulo {} {}'.format(ok,b))

[@David73_]

Fiz assim , achei mais prático do que aplicar o exércicio 35 r1=float(input("Digite o comprimento do primeiro lado: ")) r2=float(input("Digite o comprimento do segundo lado: ")) r3=float(input("Digite o comprimento do terceiro lado: ")) if r1 == r2 == r3: print("As retas podem formar um triangulo Equilatero!") elif r1 != r3 != r2 != r1: print("As retas podem formar um triangulo Escaleno!") else: print("As retas podem formar um traingulo Isósceles!")

[@guisilva5454]

Também fiz assim!!!

[@David73_]

@@guisilva5454 boa

[@makalau3865]

Tá ok, mas como tu vai saber se é possível fazer um triângulo? rsrs

[@riper198]

fiz desse jeito pra quem tiver alguma dúvida # leitura dos lados do triângulo a = float(input('Primeiro segmento: ')) b = float(input('Segundo segmento: ')) c = float(input('Terceiro segmento: ')) # verificação se os lados formam um triângulo if a < b + c and b < a + c and c < a + b: print('Os segmentos acima podem formar um triângulo ', end='') # verificação do tipo de triângulo if a == b == c: print('EQUILÁTERO.') elif a == b or a == c or b == c: print('ISÓSCELES.') else: print('ESCALENO.') else: print('Os segmentos acima não podem formar um triângulo.')

[@aritgebraxdaquestao33]

Eu fiz de outra maneira. Meu código ficou maior, mas agora aprendi esses macetes aí do python.

[@brunoas6763]

Oi Gustavo fiz um pouco diferente olha o codigo... Obrigado pela aulas.. print("Vamos ver qual tipo de triangulo pode ser formar") print("ah!! e se forma um triangulo tambem ne >D") a= float(input("Coloque valor de uma reta : ")) b= float(input("Coloque valor de uma reta : ")) c= float(input("Coloque valor de uma reta : ")) if (b-c)

[@lena-fs3rv]

Esse foi o exercício mais difícil q eu já fiz, passei o dia todo tentando resolver Exercício #042: p1 = int(input('Primeiro segmento: ')) p2 = int(input('Segundo segmento: ')) p3 = int(input('Terceiro segmento:')) if p1 < p2 + p3 or p2 < p1 + p3 or p3 < p1 + p2: print('Os segmentos acima podem formar um triângulo. ') if p1 == p2 == p3: print('TRIANGULO: EQUILÁTERO') elif p1!= p2!= p3 and p3!= p1!= p2: print('TRIÂNGULO: ESCALENO') else: print('TRIÂNGULO: ISÓSCELES') else: print('Os segmentos acima não podem formar um triângulo.')

[@mqcastro24]

Eu gosto de ouvir os esporros pq fico me achando dedicada. Se preocupa não , prof Guanabara, eu sei que tô fazendo minha parte

[@sonicgokai4903]

Fazendo o curso em 09/22: Resolvi tudo na base do elif mesmo 😂😂 python 3.10 a = float(input('Primeiro segmento: ')) b = float(input('Segundo segmento: ')) c = float(input('Terceiro segmento: ')) if a + b > c and a + c > b and b + a > a == b == c: print('Os segmentos acima PODEM um triangulo EQUILATERO') elif a + b > c and a + c > b and b + a > a == b != c: print('Os segmentos acima PODEM formar um triangulo ISOCELES') elif a + b > c and a + c > b and b + a > a == c != b: print('Os segmentos acima PODEM formar um triangulo ISOCELES') elif a + b > c and a + c > b and b + a > a != b != c: print('Os segmentos acima PODEM formar um triangulo ESCALENO') else: print('Os segmentos acima NAO PODEM formar um triangulo')

[@otruspars8452]

fiz o meu dessa maneira... meio bagunçado, mas deu certo! O importante é conseguir fazer, a perfeição vem com a prática e o tempo! r1 = float(input('Primeira reta: ')) r2 = float(input('Segunda reta: ')) r3 = float(input('Terceira reta: ')) if r1 == r2 and r1 != r3 or r1 == r3 and r1 != r2: tipo = '\033[1;34mIsósceles\033[m' elif r1 == r2 and r1 == r3: tipo = '\033[1;33mEquilátero\033[m' elif r1 != r2 and r1 != r3 and r2 != r3: tipo = '\033[1;36mEscaleno\033[m' if r1 + r2 > r3 and r2 + r3 > r1 and r3 + r1 > r2: print(f'As retas acima podem formar um triângulo {tipo}') else: print('\033[1;31mAs retas acima não podem formar um triângulo!!!\033[m')

[@Bread-vk8fl]

Gostei da simplificação.

[@tiagkim]

Fiz o isósceles primeiro, deu certo também: a=float(input('Primeiro segmento: ')) b=float(input('Segundo segmento: ')) c=float(input('Terceiro segmento: ')) if a

[@nandogf2219]

Eu fiz o meu assim: a = int(input('Lado A: ')) b = int(input('Lado B: ')) c = int(input('Lado C: ')) if a + b > c and a + c > b and b + c > a: print('Os lados acima podem formar um triângulo ', end='') if a == b == c: print('EQUILÁTERO.') elif a == b != c or a == c != b or b == c != a: print('ISÓSCELES.') elif a != b != c != a: print('ESCALENO.') else: print('Os lados acima não formam um trinângulo.') Mano da muito orgulho fazer sozinho, slk

[@kash6254]

Esse mexeu com minha cabeça

[@pedrobalbino]

eu esqueci do != então fiz assim if a + b > c and a + c > b and b + c > a: print('O triângulo é VERDADEIRO') if a == b and a == c and b == c: print('O Triângulo é Equilátero') elif a < b or a > b and c < b or c > b and a < c or a > c: print('O Triângulo é Escaleno') else: print('O Triângulo é Isósceles') else: print('O triângulo é FALSO')

[@leonardoaguitar]

Fiz diferente porque não sabia do != mas cheguei no resultado e pra mim é mais lógico de se fazer: print('Vamos calcular se 3 retas podem formar um triângulo:') n1 = int(input('\033[1;35mDigite o comprimento da primeira reta: \033[m').strip()) n2 = int(input('\033[1;34mDigite o comprimento da segunda reta: \033[m').strip()) n3 = int(input('\033[1;33mDigite o comprimento da terceira reta: \033[m').strip()) if n1 < (n2 + n3) and n2 < (n1 + n3) and n3 < (n2 + n1): print(f'\033[1;032mSim vai formar um triângulo!\033[m') if n1 == n2 == n3: print('\033[1mO tipo do triângulo é Equilátero, com todos os lados iguais') elif n1 == n2 or n2 == n3 or n1 == n3: print('\033[1mO tipo do triângulo é Isósceles, possui 2 lados iguais') else: print('\033[1mO tipo do triângulo é Escaleno, todos os lados são diferentes') else: print(f'\033[1;31mNão vai formar um triângulo!\033[m')

[@matteus_moreno]

No elif dos isósceles deu certo para todos os tamanhos de segmentos ?

[@leonardoaguitar]

@@matteus_moreno sim, fiz alguns testes e todos deram certo

[@maiconoliveirasouza4485]

Fiz assim e funcionou ! reta_1 = float(input('Primeiro segmento: ')) reta_2 = float(input('Segundo Segmento: ')) reta_3 = float(input('Terceiro Segmento: ')) if reta_1 < reta_2 + reta_3 and reta_2 < reta_1 + reta_3 and reta_3 < reta_1 + reta_2: print('Podem formar um triângulo') if reta_1 == reta_2 == reta_3: print('EQUILÁTERO ele tem todos lados iguais') elif reta_1 == reta_2 != reta_3 or reta_3 == reta_2 != reta_1 or reta_3 == reta_1 != reta_2: print('ISÓSCELES ele tem dois lados iguais, um diferente') elif reta_1 != reta_2 != reta_3: print('ESCALENO: todos os lados diferentes')

[@renatosousa172]

Fiz desse modo, assim indepente da ordem em que for digitado os lados do trinagulo, ele responderá se é possivel formar um triangulo. ladoA = float(input('Informe o primeiro lado: ')) ladoB = float(input('Informe o segundo lado: ')) ladoC = float(input('Informe o terceiro lado: ')) triangulo = bool(True) if abs(ladoB - ladoC) < ladoA < ladoB + ladoC: if abs(ladoA - ladoC) < ladoB < ladoA + ladoC: if abs(ladoA - ladoB) < ladoC < ladoA + ladoB: print("Os valores informados formam um triangulo do tipo ", end='') else: triangulo = False print('Os Valores informados não formam um triangulo.') else: triangulo = False print('Os Valores informados não formam um triangulo.') else: triangulo = False print('Os Valores informados não formam um triangulo.') if triangulo and ladoA != ladoB != ladoC: print('escaleno.') elif triangulo and ladoA == ladoB != ladoC or ladoB == ladoC != ladoA or ladoA == ladoC != ladoB: print('Isósceles.') elif triangulo: print('Equilátero.')

[@anabeatriz8835]

3:42 até 3:46 Nós aprendemos copiando para depois termos ideias dos nossos próprios programas!

[@majestic992]

#RESOLUÇÃO USANDO MEU RACIOCÍNIO ANTES DE VER O VÍDEO DO EXERCÍCIO. a = float(input('Medida da reta A: ')) b = float(input('Medida da reta B: ')) c = float(input('Medida da reta C: ')) if a + b > c and b + c > a and c + a > b and a == b == c: print(f'As três retas FORMAM um triângulo EQUILÁTERO!') elif a + b > c and b + c > a and c + a > b and a == b or b == c or c == a: print(f'As três retas FORMAM um triângulo ISÓSCELES!') elif a + b > c and b + c > a and c + a > b and a != b != c != a: print(f'As três retas FORMAM um triângulo ESCALENO!') else: print(f'As três retas NÃO formam um triângulo')

[@lucasbezerra2144]

Até agora consegui fazer todos de um modo bem parecido com o do Guanabara pórem de modo um pouca mais complicado em alguns aspectos do código. Se encontro dificuldades em algum mundo, refaço o mundo inteiro. Meu objetivo é aprender.

[@GeovaniLopesDias]

Fiz um programa que testa, inclusive, se é retângulo, obtusângulo ou acutângulo: print("""Os triângulos não aceitam qualquer valor de medida para seus lados ao mesmo tempo. Por isso, é necessário testarmos as medidas para saber se elas formam ou não um triângulo.""") r1 = float(input('Digite a medida de um dos lados: ')) r2 = float(input('Digite a medida do segundo lado: ')) r3 = float(input('Digite a medida do terceiro lado: ')) s1 = r3 + r2 s2 = r1 + r3 s3 = r2 + r1 d1 = abs(r3 - r2) d2 = abs(r3 - r1) d3 = abs(r2 - r1) if d1 < r1 < s1 and d2 < r2 < s2 and d3 < r3 < s3: print('Essas medidas podem formar um triângulo ', end='') if r1 != r2 and r1 != r3 and r2 != r3: print('escaleno ', end='') retas = [r1, r2, r3] retas.sort() h = retas[2] a = retas[1] b = retas[0] if h**2 == (a**2+b**2): print('retângulo!') elif h**2 >= (a**2+b**2): print('obtusângulo!') elif h**2 = (2*a ** 2): print('obtusângulo!') elif h ** 2

[@darkarcherbot4142]

Fiz o meu assim, e caso informe valores inválidos o algoritmo solicita novos dados e o mesmo para se não formar um triangulo: while True: try: resul = input("Digite os tres valores separando por espaço: ").strip() n1, n2, n3 = map(float, resul.split()) if n1 < n2 + n3 and n3 < n1 + n2 and n2 < n3 + n1: if n1 == n2 == n3: print("E um equilatero!") break elif n1 == n2 != n3 or n2 == n3 != n1 or n3 == n1 != n2: print("É um isóceles!") break else: print("É um escaleno!") break else: print("Não pode formar um triangulo!") continue except ValueError: print("Erro desconhecido") continue

[@cllausares6546]

Cara eu usei o operador lógico ''or'' para delimitar a afirmação de que os 3 seguimentos podem formar um triângulo. Só que eu não prestei a tenção na análise, de que as 3 afirmações tem que estar corretas para formar um triângulo, que no caso seria usando o ''and'' para delimitar que só haveria um triângulo se estivesse dentro do padrão das 3 afirmações. Como "or" vai retornar apenas uma afirmação verdadeira e ignorar as outras afirmando que são falsas, então verifiquei logicamente que ali estava o erro. Esse é meu programa atualizado: t1 = float(input('Digite o primeiro lado: ')) t2 = float(input('Digite o segundo lado: ')) t3 = float(input('Digite o terceiro lado: ')) if t1 + t3 > t2 and t1 + t2 > t3 and t2 + t3 > t1: print('Estes 3 lados formam um triângulo!') if t1 == t2 and t1 == t3 and t2 == t3: print('Este triângulo é chamado de Equilátero por ter 3 lados iguais.') elif t1 == t2 != t3 or t1 == t3 != t2 or t2 == t3 != t1: print('Este triângulo é chamado de Isóceles por ter 2 lados iguais') elif t1 != t2 and t2 != t3 and t3 != t1: print('Este triângulo é chamado de Escaleno por ter 3 lados diferentes.') else: print('Estes lados não formam um triângulo!')

[@erick.1796]

Foi o exercício mais dificil até o momento pra mim, eu fiz um código FEIO QUE DÓI mas funcional klkkkk no caso eu não lembrava do != e de usar o if dentro do if , precisei escrever todas as possibilidades possiveis: lado1 = int(input('Primeiro lado: ')) lado2 = int(input('Segundo lado: ')) lado3 = int(input('Terceiro lado: ')) if lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado1 == lado2 and lado1 == lado3: tri = 'é um triângulo Equilátero' elif lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado1 == lado2 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado1 == lado3 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado2 == lado3: tri = 'é um triângulo Isósceles' elif lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado1 < lado2 and lado1 > lado3 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado1 > lado2 and lado1 < lado3 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado2 < lado1 and lado2 > lado3 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado2 > lado1 and lado2 < lado3 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado3 < lado1 and lado3 > lado2 or lado1 < lado2+lado3 and lado2 < lado1+lado3 and lado3 < lado1+lado2 and lado3 > lado1 and lado3 < lado2: tri = 'é um triângulo Escaleno' else: tri = 'não forma um triângulo' print('O segmento acima {}'.format(tri))

[@tffighter6805]

Mds😮

[@RUBINHO12321]

a = float(input('Primeiro lado: ')) b = float(input('Segundo lado: ')) c = float(input('Terceiro lado: ')) if a < b + c and b < a + c and c < a + b: print('É possível formar um triângulo com os lados indicados') if a == b == c: print('O triângulo é EQUILÁTERO') elif a != b != c: print('O triângulo é ESCALENO') else: print('O triângulo é ISÓSCELES') else: print('Não é possível formar um triângulo com os lados indicados')

[@UlyssesKosmaliski]

Muito Obrigado!!

[@Lucas-mm5if]

No início, quando me deparei com o exercício achei ele realmente um pouco difícil, mas consegui fazer no dia seguinte. Na semana seguinte (hoje), consegui fazer o exercício de uma forma bem mais limpa e legível (sem olhar a correção ainda). Como eu fiz da primeira vez: r1 = float (input('Valor da primeira reta: ')) r2 = float (input('Valor da segunda reta: ')) r3 = float (input('Valor da terceira reta: ')) if r1+r2>r3 and r2+r3>r1 and r1+r3>r2: print ('O triangulo PODE ser formado.') else: print ('O triangulo NÃO pode ser formado.') if r1==r2==r3: print ('O triangulo será EQUILÁTERO.') if r1==r2!=r3 or r2==r3!=r1 or r1==r3!=r2: print ('O triangulo será ISOSCELES.') if r1!=r2!=r3 and r2!=r3!=r1 and r1!=r3!=r2 and r1+r2>r3 and r2+r3>r1 and r1+r3>r2: print ('O triangulo será ESCALENO.') Como eu fiz da segunda vez: r1 = float (input('Valor da primeira reta: ')) r2 = float (input('Valor da segunda reta: ')) r3 = float (input('Valor da terceira reta: ')) triangulo = r1+r2>r3 and r2+r3>r1 and r1+r3>r2 escaleno = r1!=r2!=r3 and r2!=r3!=r1 and r1!=r3!=r2 equilatero = r1==r2==r3 isosceles = r1==r2!=r3 or r2==r3!=r1 or r1==r3!=r2 if triangulo and escaleno: print ('O triangulo PODE ser formado e será ESCALENO.') elif triangulo and equilatero: print ('O triangulo PODE ser formado e será EQUILATERO.') elif triangulo and isosceles: print ('O triangulo PODE ser formado e será ISOSCELES.') else: print ('O triangulo NÃO pode ser formado.')

[@luizrobertopires]

Deu uma bugada, porém com a resolução esclareceu, Vamos que Vamos! Estudando na quarentena

[@rodolfotomaz7263]

cada aula um breve esporro kkkkkkk muito bom prof

[@DaniloCesarAlvess]

a=float(input("Primeiro lado: ")) b=float(input("Segundo lado: ")) c=float(input("Terceiro lado: ")) if a

[@KlingerSilva]

essa questão foi a unica que eu me enrolei um pouco, e fiz 90%. mas agora coma resolução tudo ficou mais claro, e dificilmente, irei errar esse tipo de questão com aninhamento

[@AndreCarvalhoAntunes]

Esse exercício me travou na matemática. Mas rolou :) print('-='*20) print('Analizador de triangulos') print('-='*20) a = float(input('valor 1: ')) b = float(input('Valor 2: ')) c = float(input('Valor 3: ')) if a < b + c and b < a + c and c < a + b: print('Os segmentos acima PODEM FORMAR triangulo') if a == b and b == c: print('Esse é um triango EQUILATERO') elif a != b and b != c and c != a: print('Esse é um triangulo ESCALENO') else: print('Esse é um triangulo ISÓSCELES') else: print('Os segmentos acima NÃO PODEM FORMAR triangulo')

[@leomdpaz]

a = float(input('Primeiro lado: ')) b = float(input('Segundo lado: ')) c = float(input('Terceiro lado: ')) if a + b < c or a + c < b or b + c < a: print('Impossível formar um triângulo.') else: if a == b == c: print('Triângulo Equilátero.') elif a == b or a == c or c == b: print('Triângulo Isósceles.') else: print('Triângulo Escaleno.') É só por as novas condições dentro do ELSE.