Exercício Python

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

[@dna1]

O que eu mais tô amando em programar é ver que tem muitíssimas formas de se fazer a mesma coisa, é um programa mais criativo que o outro nos comentários

[@luizfelipefernandesneves1637]

Um dica pra quem se enrola na matemática mais que na programação (como eu): "simule" o laço no papel, como se você fosse o computador executando as operações. Você consegue enxergar melhor o que o código tá fazendo.

[@marcioferreira4899]

vou começar a fazer isso, a sequencia de fibonacci só consegui pensar na lógica quando o guanabara começou a mostrar como funcionava a sequencia, eu já sabia como funcionava, mas ver na tela os números me deu ideia de como resolver

[@eduardoribeiro5573]

eu sempre leio assim o while: while n != 999: Enquanto n for diferente de 999 REPITA:

[@MsWerike]

Gostaria de fazer no Pycharm igual fazia no VISUALG, quem já usou ele sabe; ele tem o PASSO-A-PASSO que executa linha por linha, aí fica melhor pra entender a lógica. se alguém souber como fazer isso no Pycharm, diz aí, prfvr.

[@luscapy]

@@MsWerike cara, no visualg vc estava aprendendo algoritmia, em portugol, isso tem a ver com a linguagem

[@mf19485]

​@@marcioferreira4899 Eu estava sem um "norte" no Fibonacci, mas, foi só por no papel que fluiu bem facilmente! Fiquei espantado!

[@jdbrasilai]

eu fiz diferente e deu certo tambem incluindo apenas uma linha n = total = cont = 0 while n != 999: n = int(input('Digite um número inteiro ou 999 para parar: ')) if n != 999: total += n cont += 1 print('Foram digitados {} números e a soma entre eles foi {}'.format(cont, total))

[@aprendatudo1920]

o problema dessa logica é que ele sempre verifica se é 999, sendo que não é nescessario sempre fazendo isso, funciona mas usa mais processamento, olha ai como eu fiz: tentativas = 0 soma = 0 num = int(input('digite 999: ')) while num != 999: tentativas += 1 soma += num num = int(input('por favor digite 999: ')) if tentativas == 0: print('você é muito bonzinho, digitou 999 de prima!') else: print('você é muito levado, digitou {} numeros antes de digitar 999'.format(tentativas)) print('a soma dos numeros digitados foi de {}'.format(soma)) so faço uma verificação que é no final, e é pra fazer uma brincadeirinha kkssk, tipo quanto menos você obrigar seu processador a trabalhar melhor, é uma dica de ouro quando começarmos a fazer programas complexos essas coisinhas fazem diferença :)

[@aprendatudo1920]

parece que não esta identado mas e pq o youtube remove os tabs

[@aprendatudo1920]

ai fica um espacinho como identação

[@aprendatudo1920]

mas foi top essa forma q voce fez

[@KairyuJr]

Da p fazer assim tbm n=0 c=-1 s=0 while n!=999: c+=1 s+=n n=int(input('Num: ')) print('Quandade: {} Soma: {}'.format(c,s))

[@luanabattaglia1453]

Esse exercício me fez entender pela primeira vez de verdade que a ordem das linhas importa. Demorei pra entender que, tirando a variável do WHILE e colocando acima, porém depois das variáveis zeradas, o núm ali já conta como algo a ser somado e contado.

[@jeff3280]

eu fiz o programa correto, só a ordem das linhas estava errada também e não dava certo kkkk

[@deepmoat9592]

Mais alguém assistindo esse ESPIRRO de abertura em 2020, em plena pandemia do COVID-19? kkk

[@ABCDEF-qx8iw]

EU

[@lucasgoncalves3577]

kkkkkkkkkkk

[@vitoremanoel9177]

puttz, nem me fale, limpei a tela logo em seguida. kkkk

[@deepmoat9592]

@@vitoremanoel9177 kkkkkkkkk

[@vitorianosantos3251]

Eu até me esquivei.

[@bruno.g.s.fagundes]

A aula do cara é tão boa e faz vc se sentir que está em contato com ele, que quando espirrou dei até saúde pra ele!

[@ZeDeath]

eu fiz um pouquinho diferente, ao inves de eu colocar os dois inputs(1 fora e outro dentro do while), eu coloquei um ''if'' pra verificar, aqui: n = dig = total = 0 while n != 999: n = int(input('digite um valor[digite 999 para parar]: ')) if n != 999: total += n dig += 1 print(f'foram digitados \033[31m{dig}\033[m números ' f'e a soma de todos eles é \033[31m{total}\033[m')

[@StroN444]

Fiz o meu +/- assim, mas eu botei um 'else'

[@renatogarcia2343]

fiz a mesma coisa, achei mais simples assim.

[@williammohamed6005]

vim do site para o youtube para colocar exatamente esse mesmo comentário, foi a solução que me veio a cabeça de primeira

[@Tiagogondimg]

Tb fiz igual a esta solução, mas inseri o else

[@joshved]

eu fiz do primeiro jeito com a subtração, mas a sua solução ficou muito mais simples de entender

[@colosra9147]

Hoje é domindo de pascoa e eu aqui firme e forte com o curso de python! numero = contador = acumulador = 0 while numero != 999: numero = int(input('Digite um número [999 para parar] ')) if numero != 999: contador += 1 acumulador += numero print('Você digitou {} números e a soma entre eles é {}.'.format(contador, acumulador))

[@erickpaz4735]

(15/11/2019) Eu fiz diferente, tb deu certo e achei que ficou mais fácil de entender o que está acontecendo. Se existir algo que possa dar um erro ou alguém enchergue uma falha, por favor comenta pra que eu possa entender e corrigir num = cont = soma = 0 while num != 999: num = int(input('Digite um número: [999 pra parar] ')) if num != 999: soma += num cont += 1 print('Você digitou {} números e a soma foi {}'.format(cont, soma))

[@victorrozas4629]

Achei a sua lógica mais intuitiva

[@eduardonascimento7066]

fiz exatamente assim tbm, até com o mesmo nome das variáveis kkkkk o único problema do nosso programa que notei anos depois com mais experiência, é que ele vai verificar se todos os números digitados são != 999 no if, o que faz um uso de memória excessivo

[@erickpaz4735]

@@eduardonascimento7066 sim, mas tratamento de memória não era o foco nessa época, então tá valendo kkkk

[@kagejeferson]

No caso eu usei < pois se digitarmos números maiores o programa iria aceitar tbm

[@marcelohenriquedeoliveira6086]

2022 e tô feliz que consegui alcançar o resultado quase que 100%. Ótimas dicas do Guanabara. O código atualizado é: soma = 0 (ou pode fazer n = soma = cont = 0) cont =0 n = int(input('Digite um número [999 para parar]: ')) while n!= 999: cont +=1 soma += n n = int(input('Digite um número [999 para parar]: ')) print(f'Você digitou {cont} números e a soma entre eles foi {soma} .')

[@joaocosta9485]

A minha solução foi incluindo um ''if'' dentro do while para resolver esse problema do 999. Segue o código: n = c = soma = 0 while n != 999: n = int(input('Digite o número inteiro: ')) if n != 999: c += 1 soma = soma + n print('Foram digitados {} valores e a soma deles eh: {}.'.format(c, soma))

[@igordorth]

Tive essa mesma ideia e funcionou direitinho!

[@wesleygps6454]

Achei muito interessante esse exercicio pq eu notei que a 3 formas diferentes de solucionar o proble e dentro dessas formas a sub formas: 1 gambiara: cont -1 / num -999 1.1 qualquer outro tipo de gambiara pq BR é assim msm kkkk 2 ordem do codigo: seria basicamente pegar a pegunta e a utilizar altomaticamente como forma de parada(o FLAG) ja desconciderando o 'processo logico'(cont += 1 / num += num) 3 fator logico: seria utilizando o if para parar o codigo sem precisar ler o 'processo logico' sem o else 3.1: com o else 4 utilizar a aula 15: LITERALMENTE interomper o codigo Aulas incriveis e muito intuitivas, vlw guanabara vc e 10 o(≧∇≦o)

[@gcbicca]

Depois daquele exercício FUD### o professor vem com essa coisinha aí! HAHAH chega a dar raiva!

[@caiotorres6156]

KKKKKKKKKKKKKKK é bom pra a gente ver que tamo aprendendo

[@PudimAoQuadrado]

Esse realmente foi milhões de vezes mais facil que o ultimo: **tive que editar pq esqueci de colocar a contagem,inclusive vou aderir a essa parada de deixar varias variaveis na mesma linha quando elas valem o mesmo valor,é bem mais simples** tota = cont = num = 0 while num != 999: num = int(input('Digite um numero [999 pra parar]:')) if num != 999: tota += num cont += 1 if num == 999: print('A soma total dos {} numero/s que voce digitou é {}'.format(cont,tota)) print('Se contassemos o 999 teriamos {} numeros'.format(cont + 1)) print('Progama finalizado')

[@eduardonascimento7066]

cara, posso te dar uma sugestão? voce não precisa criar essa condição "if num == 999" e pode colocar todos esses prints fora do while, pois como a condição do seu while é "num != 999", se você digitar 999 automaticamente vai sair do laço e executar os prints

[@celisantos7862]

Parabéns pelas aulas, tem me ajudado bastante, voltei para graduação depois de 10 anos que finalizei o mestrado. Ótima iniciativa

[@robertmacedo013]

0:02 Saúde, mestre!

[@layzaorbit4054]

caramba depois de me confundir com tantos exercicios em while, finalmente conseguir resolver um sozinha. Estou muito feliz!

[@lucasdesouza9674]

Eu gostei, mas tinha feito a gambiarra de ter colocado contador - 1 e soma - 999 kkkkkkkkkkkkkkkkk

[@霞ヶ丘詩羽-v6k]

Haha na primeira vez eu tinha feito isso também, depois eu analisei o código e refiz e consegui sem a gambiarra haha

[@velhoguidsd]

acho que todo mundo fez isso kkkkkkk

[@gabrielribeirorossi3988]

teria dado certo, era só vc ter usado um Trunc para deixar a soma positiva

[@leonardomoreirarocha8821]

eu tmb fiz assim

[@danilodelucio]

caraio... e eu achando q fui um genio ;-;

[@leonanferreira4947]

man eu fiz essa com if e deu muito certo fiquei mo feliz na hora

[@mfC0RD]

Vendo o vídeo, a mudança que eu fiz foi designar as variáveis em uma só linha. Boa ideia! E... É, eu poderia ter feito bem mais simples, sem a condição "if/else". Mas ei, funciona! haha Por isso que é sempre bom, quando possível, comparar o código com o de quem tem mais conhecimento. Sempre tem uma coisa ou outra que a gente deixa passar. num = pool = c = 0 while True: num = int(input("Entre um número (digite '999' para parar): ")) if num != 999: pool += num c += 1 else: print("Ao todo, foram digitados {} números, com somatório igual a {}".format(c, pool)) break

[@luan.sferreira]

Caramba, até que enfim eu consegui resolver sozin, uma lição do While!

[@etnansousa647]

Há uma alternativa para não precisar usar dois input(): basta fazer o contador receber inicialmente (-1). numero = soma = 0 contador = -1 while numero != 999: soma += numero numero = int(input('Digite um número [999 para parar]: ')) contador += 1 print(f'Você digitou {contador} números e a soma entre eles é {soma}')

[@felipebcaalves]

se você somar 998 + 1 o código não encerra??

[@felipebcaalves]

teste aqui, da certo pq teu resultado quem recebe é soma, e não numero. entendi.

[@michaelpaulino7237]

Curti bastante o exercício, usei o metodo aplicado na aula 14 #Minha solução!!! print('===SISTEMA DE CALCULO, PARA PARAR DE CALCULAR, DIGITE 999 ===') numero = soma = contador = 0 while numero != 999: numero = int(input('Digite um número [999 para o programa]: ')) if numero != 999: soma += numero contador += 1 print('O usuário informou números {}x, a soma entre eles é {}.'.format(contador, soma))

[@pablolucena6217]

"Dai mais pra frente você esquece que tem que fazer a tua gambiarra la" kkkk me identifiquei

[@mmrizza]

# elaborado em 01/09/2020 por Marcelo Medeiros. Obrigado professor Guanabara! Eu inacreditavelmente estou apreendendo a programar para mudar de carreira de dar um final diferente para a minha vida profissional! Gratidão! n = 0 contador = 1 soma = 0 while n != 999: n = int(input('Digite um numero [999 para parar]: ')) if n != 999: soma = soma + n else: soma = soma if n != 999: contador = contador + 1 else: contador = contador else: print('Você digitou {} numeros e o somatorio deles é {}.'.format(contador, soma))

[@nicholas_eras]

a = 0 soma = 0 while a != 999: a = int(input("Digite um número. [999 para parar]. ")) soma += a print(soma-999) stonks

[@anadotie6618]

O meu eu fiz de forma diferente!! Usei algumas coisas que já aviamos estudado anteriormente no curso e deu tudo certo!! n = 0 soma = 0 m = 0 while m != 999: n = int(input('Digite um número inteiro qualquer(Digite 999 para encerrar o programa): ')) if n != 999: soma = soma + n else: print('A soma dos números digitados com exceção do flag é: {}!'.format(soma)) print('FIM!!!') m = n

[@elgabridelauthooficial8368]

eu fiz um pouco diferente (dessa forma a variável fica com o valor certo) end = 0 soma = 0 cont = 0 while end != 999: num = int(input('digite um número [digite 999 pra parar]: ')) soma += num cont += 1 if num == 999: end = 999 soma -= 999 cont -= 1 print('fim') print('você digitou {} números a soma dos números foi {}'.format(cont,soma))

[@dinandosa]

Fiz de uma forma diferente professor, fiz o codigo abaixo com if num = 0 cont = 0 soma = 0 while num != 999: num = int(input('Digite um valor : ')) cont = cont + 1 soma = soma + num if num == 999: cont-=1 soma = soma - num print('Você digitou {} números'.format(cont)) print('E a soma de todos os números digitados é {}'.format(soma)) e deu certo o mesmo resultado que o senhor.

[@pedrodecolin4163]

O que eu fiz foi só colocar o print no final do while. Dessa forma não precisou colocar um print antes tambem. Na primeira vez que entra no while, não seria contado um numero digitado pelo usuario, por isso eu comecei com cont = -1, e a contagem ficaria certa. No caso da soma, não faz diferença nenhuma, pois tanto 'soma' como o 'num' começam com 0, entao seria '0 += 0', por isso funcionou : num = soma = 0 cont = -1 while num != 999: soma += num cont += 1 num = int(input('Digite um numero (999 para parar): ')) print(' FIM Soma: {} Numeros digitados: {}'.format(soma, cont))

[@gust7705]

Achei mais lógico doque usar if

[@lucasvilasboas7326]

Fui para o teste de mesa para entender o porque que nao conta o CONT ... muito dahora ! curso 10/10

[@GabrielRibeiro-gy5hk]

EX 64 n = int(input('Digite um número [999 para parar]: ')) cont = 0 soma = 0 if n == 999: print('Programa finalizado.') else: while n != 999: cont += 1 soma += n n = int(input('Digite um número [999 para parar]: ')) print('A soma dos {} números é {}'.format(cont, soma))

[@henriquebonfim9979]

Você pode deixar o if dentro do while assim deixando seu cdg com menos linhas assim. n = cont = soma = 0 while n != 999: n = int(input('Digite um número [999 para parar]:')) if n != 999: cont += 1 soma += n print(f'Você digitou {cont} números. A soma entre eles é {soma}')

[@barbiemichelle8301]

Achei mais prático tentar usar aquelas flags que foram passadas no exercicio 58, fiz assim: fim = False soma = 0 count = 0 while not fim: n = int(input('Digite um valor para somar [999 para finalizar]: ')) if n == 999: fim = True else: soma +=n count += 1 print('Sua repetição acabou, e a soma de todos os {} valores é {}.'.format(count, soma)) Acho que é conteudo da próxima aula, mas analisando a resolução do exercicio 58 e aplicando a mesma lógica nesse, deu certo pra mim !

[@marcosdanieldasilvabezerra1616]

resolução ↓ num = soma = 0 digit = -1 while not num == 999: soma += num digit += 1 num = int(input('Digite um número quaquer [Enter 999 to stop]: ')) print(f'Você digitou {digit} números e a soma entre eles é {soma}')

[@covermusic6016]

Eu fiz um bem parecido.

[@Juniordigital]

ficou idêntico ao meu c=-1 n=s=0 while n!=999: s+=n c+=1 n=int(input('Digite um número: ')) print('Você somou {} vezes e o resultado foi {}.'.format(c,s))

[@DanielRios549]

Eu fiz exatamente igual a vc, eu analisei o loop e percebi que ele só estava pegando o 999 porque o valor que ele tinha era o do loop anterior, assim ele só ficava com o valor 999 no próximo loop, ai eu pensei em colocar o input no final do loop, pra ele já começar com o valor atualizado, deu super certo e foi igual o seu ainda, kkk

[@gustavofranca5661]

Hey hey, Deus tá vendo vc colocar o - 999 ali

[@crowbert4359]

Depois que ele ensinou a colocar "if menor == 0: menor = num " Em uma aula passada, nuncamais coloquei 999, só uma vez que fiz isso.

[@pedroluisgallegossepulveda2587]

esse exercício foi muito maneiro, fiquei meio preso por um tempo pensando e consigui , vim verificar se fiz da maneira mais eficiente

[@Leonardo-go9je]

Melhor exercício ksksksk fiz uma condição caso o usuário não escreva nenhum valor. resp = soma = cont = 0 while resp != 999: resp = int(input('Digite um número: ')) if resp != 999: soma += resp cont += 1 if soma != 0: print(f'A soma dos {cont} valores foi {soma}') else: print('Não tem nenhum valor!')

[@danielbersani]

como a maioria, eu tbm fiz diferente e funcionou n1 = 0 valor = 0 cont = -1 n3 = -999 while n1 != 999: valor += 1 n2 = int(input('Digite o {}º valor (ou 999 para sair): '.format(valor))) cont += 1 n3 += n2 if n2 == 999: break print('Você digitou {} números e a soma é {}'.format(cont, n3))

[@caiopalitot8458]

Não vi o vídeo ainda, mas fiquei orgulhoso porque consegui resolver esse (apesar de ser mais fácil) num = 0 cont = 0 soma = 0 print('~~' * 20) print(' \033[1;31mCONTADOR DE NÚMEROS:\033[m') print('~~' * 20) while num != 999: cont += 1 soma += num num = int(input('Digite um número: ')) print('Para sair, digite: [999]') if num == 999: cont = cont - 1 print('Os {} números somados dá {}'.format(cont, soma))

[@Pedro-dn7bx]

bacana essa solução, não conhecia e fiz um pouquinho diferente coloquei um condição if que so iria somar o numero se ele fosse diferente de 999: # para com 999, quantos numeros digitados e soma deles n = soma = cont = 0 while n != 999: n = int(input("Digite um número inteiro:(999 para parar) ")) cont += 1 if n != 999: soma += n print(f"Você digitou {cont - 1} números, e a soma deles é {soma}")

[@EuVoluindoSurf]

Eu fiz assim... Achei interessante a dica do if com o pass que o pycharm me deu, mesmo que a do gunabara seja mais facil eu achei legal a solução do pycharm tbm kkkk soma = 0 cont = 0 num = 0 while num != 999: num = int(input('Digite um número [999 para parar]: ')) if num == 999: pass else: soma += num cont += 1 print('Você digitou {} números e a soma entre eles foi {}.'.format(cont,soma))

[@raony1194]

Fiz diferente, primeira vez aqui colocando meu código pode ser q seja meio confuso porém deu certo! Segue abaixo : n = 0 c = 0 t = 0 While n != 999: n = int(input(“Digite um número [999 p/ parar]: “)) t += 1 if n - 999: c += n print(f”Foi digitado {t-1} números e a soma foi {c}. “)

[@rodrigo17samuraix]

Resolvido de uma forma bem diferente na verdade, funciona usei If e Else. stop = n2 = cont = 0 while stop != 999: n1 = int(input('digite um numero: 999 para sair') If n1 == 999: stop = n1 Else: n2 = n1 + n2 cont +=1

[@caiomenezesvalois1857]

Curso perfeito. Só gratidão, professor

[@Parsifal1993]

Gambiarra mor: count = -1 n = 0 flag = int('999') n1 = -999 while n < flag: n = int(input('Digite um número[ 999 para parar ]: ')) count += 1 n1 += n print('Você digitou {} números e a soma entre eles foi {}'.format(count, n1))

[@icarodm]

Resolvi usando if como em outros exercícios, se não me engano. num = soma = cont = 0 while num != 999: num = int(input('Digite um número [999 para parar]: ')) if num != 999: soma += num cont +=1 print(f'Você digitou {cont} números e a soma entre eles foi {soma}') Mas vou anotar essa solução (do instrutor) diferente pra abrir a mente.

[@DiabelParra]

Eu fiquei perdida na hora que o professor deu a ideia de colocar o input fora do loop kkkkkkkkk parece que uma parte do meu cérebro foi desbloqueado depois que eu entendi oque ele fez, incrível kkkk acho que agora eu entendi a função do while

[@hugofernando3457]

esse foi o mais facil de todos os exercicios de while sem duvida, fiz em cerca de 5 min

[@marvin1290]

Fiz ele e adicionei a média jkkkk

[@Eujulyan]

é legal ver q o programa funcionou mesmo diferente do dele

[@augustoperescopetti139]

Gostei muito do meu resultado, fiz rapidin count = 0 numero = 0 soma = 0 while numero != 999: numero = int(input('Digite um número [999 para parar]: ')) soma += numero count += 1 print(f'Você digitou {count - 1} números e a soma entre eles é de {soma - 999} ')

[@diogotech]

Seguinte eu nao consegui fazer de primeira e fui pesquisar no google, nao copiei, pesquisei mesmo. E apliquei no codigo e resolvi. Foi diferente e mais avançado que o modulo, mas eu entendi tudo que estava fazendo. Nao sei se fiz corretamente para didática , mas também entendi a forma que ele passou, mas achei meio gambiarra mesmo. Enfim, só de conseguir chegar a uma resolução com pesquisa básica, estou satisfeito.

[@jonatas9405]

Mt feliz de ter conseguido só de ver o enunciado n = 0 cont = -1 variavel = 0 while n != 999: n = int(input('Digite um número [999 para parar]: ')) cont += 1 variavel += n print(f'Você digitou {cont} números e a soma entre eles foi {variavel-999}.')

[@justicandoroleplays1897]

Guanabara, nunca pensei que iria tão longe!!! Resolvi da seguinte forma: tot = 0 cont = 999 soma = 0 num = 0 while num < cont: num = int(input('Digite o numero desejado [para para digite 999]: ')) soma = num + soma tot += 1 fim = soma - cont print('Foram digitados {} números.'.format(tot)) print('A soma dos númros digitados foi {}.'.format(fim))

[@iniciativareddit7921]

Tem que alterar a condição while senão caso a pessoa digite um número maior que 999 o código vai encerrar a repetição.

[@felipebarroso1242]

Eu fiz utilizando o break para sair do loop quando o número digitado for 999: print('Vamos calcular a soma de todos os números digitados. Para sair, digite [999]') n = soma = contador = 0 while n != 999: n2 = int(input('Digite um número: ')) if n2 == 999: break contador += 1 soma += n2 n = n2 print('Você digitou {} números Soma = {}'.format(contador, soma))

[@leofranklinn22]

Interessante esse método do vídeo! Fiz de modo diferente: soma = num = cont = 0 while num != 999: num = int(input('Digite um número [999 para parar]: ')) soma += num cont += 1 if num == 999: soma -= 999 cont -= 1 print('Foram digitados um total de {} números, e a soma deles é {}.'.format(cont, soma))

[@estevaobarbosa4970]

Fiz um pouquinho diferente, com uma linha a menos. Eliminei o input de fora do while começando o contador com -1: cont, soma, num = -1, 0, 0 while num != 999: soma += num cont += 1 num = int(input('Digite um número [999 para parar]: ')) print('Você digitou {} números, que juntos somam {}'.format(cont, soma))

[@tiagodebarso1786]

Bah, curti essa. Bem simples.

[@enzorocha5423]

NAO ACREDITO QUE EU CONSEGUI SOZINHO 😂😂😂 QUE FELICIDADE!!!!

[@sandroaugusto3492]

Esse exercício foi um bom alivio comparados aos outros: soma = 0 num = 0 cont = 0 while num != 999: num = int(input('Digite número(s) Para somar. digite (999) Para parar. ')) soma = soma + num cont = cont + 1 if num == 999: cont = cont - 1 print('O valor total foi: {}'.format(soma - 999)) print('Foram digitados {} números'.format(cont)) print('fim')

[@FabioHenrique-cm5wb]

Finalmente um q fiz sozinho, boa fml n = s = 0 cont = 1 print('Digite 999 caso queira parar.') while not n == 999: n = int(input('Digite um número inteiro: ')) cont+= 1 s += n print(f'Programa finalizado com {cont - 2} números mostrados.') print(f'A soma entre os números mostrados foi de {s - 999}')

[@luquinha_.]

Guanabara, eu fiz de uma maneira bem diferente e deu certo! num = 0 contador = 0 total = 0 while num != 999: num = int(input('Digite um valor \033[1;92m(999 para PARAR)\033[m: ')) if num < 999 or num > 999: contador = contador + 1 total = total + num print('O total de números digitados foi {}'.format(contador)) print('Soma dos números digitados é {}'.format(total))

[@izzy1827]

ate q enfim fiz um exercicio dessa sequencia sozinha, ja tava ate desistindo contador = 0 acumulador = 0 n = 0 while n != 999: n = int(input('Digite um número [999 para parar]: ')) contador = contador + 1 contador1 = contador - 1 acumulador = acumulador + n soma = acumulador - 999 print(f'Você digitou {contador1} números e a soma entre eles é {soma}!')

[@wcsinistro]

Boa mestre Guanabara, depois de levar fumo na fibo e estudar um bocado, esse exercício foi moleza, todavia como ainda não vi a aula 15, e meu conhecimento é limitado ao que estou aprendendo no curso, acho que meu método foi uma gambiarra, para desconsiderar o valor da condição de parada e do contador. contador = 0 numero = 0 soma = 0 while numero != 999: numero = int(input('Informe um número: ')) soma += numero contador += 1 print(f'Soma dos números digitados: {soma - 999}') print(f'Quantidade de números digitados: {contador - 1}')

[@davidlopes5638]

Depois de tanto ex difícil finalmente fiz um tranquilo antes de ver a resolução: num = 0 soma = 0 cont = 0 while num != 999: num = int(input('- ')) soma += num cont += 1 print(f'A soma entre os números é {soma - 999}') print(f'O total de números digitados foi {cont - 1}')

[@unknownman1998]

eu aninhei um If e um While (fiz antes de ver) pra poder fazer esse exercicio, me pareceu mais simples do que ter duas variaveis dentro e fora do while, ficou assim: n=cont=soma=0 while n != 999: n=int(input('Digite um valor [999 para parar] ')) if n!=999: soma+=n cont+=1 print('Voce digitou {} numeros e a soma deles foi {}.'.format(cont, soma))

[@jayrcomi3701]

Eu fiz uma estratégia diferentinha: n = 0 soma = 0 cont = -1 while n != 999: soma += n n = int(input('Digite um valor: [999 para parar] ')) #EU COLOQUEI NO MEIO PRA ELE SÓ SOMAR (SOMA + N) DEPOIS DE VERIFICAR SE N != 999 cont += 1 print(f'A soma de todos os {cont} valores digitados por você é igual a {soma}')

[@albert5a]

Obrigado mais uma vez!!!

[@marcelomeneghin9290]

feliz porque consegui fazer quase sem colar... fiz 95% sozinho... antes de assistir o vídeo... :)

[@ajcs9574]

Consegui !!! Finalmente consegui fazer um sozinho n = int(input('digite um numero [999 para parar]: ')) c = 0 f = n while n != 999: n = int(input('digite um numero [999 para parar]: ')) c = c + 1 f = f+n print(f'o total de numeros digitados foi {c} e a soma entre eles é {f-999} FIM')

[@vitoriacaroline1385]

Sem duvidas o mais fácil até agora ... eu sai do 63 pra esse, pq esse é um sopro de ar frio

[@ezlferreira]

Estudando Python em 2022... haha... fiz diferente, os incrementos eu coloquei antes do print pra ele verificar na condição do while antes de incrementar de novo. print('EX064 - TRATANDO VALORES V1.0') soma = n = 0 c = -1 while n != 999: soma += n c += 1 n = int(input('Digite um número ou digite 999 para sair do programa: ')) print('Foram digitados {} números e a soma entre eles foi de {}.'.format(c, soma))

[@SuperTicao.]

ESSE FOI O MEU: from time import sleep print('='*53) print('DIGITE QUALQUER NÚMERO. E SE QUISER PARAR DIGITE 999') print('='*53) n1 = 0 num = -1 soma = 0 while n1 != 999: n1 = int(input('Digite qualquer número inteiro: ')) print('-'*45) num += 1 if n1 != 999: soma += n1 sleep(0.5) print(f'{num} números foram digitados. E a soma deles foi {soma}')

[@lucianafernandesal]

Eu fiz diferente e funcionou, só não sei dizer se é a melhor maneira haha num = 0 soma = 0 c = 0 while num != 999: num = int(input('Digite um número ou 999 para parar: ')) if num != 999: soma += num c += 1 else: print('Programa finalizado! Calculando...') print('Você digitou {} números e a soma entre eles é igual a {}.'.format(c, soma))

[@ffundefined]

Eu consegui fazer o exercício dessa maneira: #c = n = s = 0 , tambem serveria!!! c = 0 n = 0 s = 0 while n != 999 : n = int(input("Digite qualquer valor exceto 999 : ")) if n != 999 : s += n c += 1 print("Foram digitados {} e a soma entre eles é {}".format(c,s))

[@empire346]

fiz de um jeito simples vou conferi a resposta do gustavo para a melhor forma de fazer usuario = 0 soma = 0 print('Ponto de parada 999:') while usuario != 999: usuario = int(input('Digite numero')) soma += usuario tot = soma - 999 print('A soma do números foi {}'.format(tot))

[@gusang68]

Fiz o meu assim: (fiz antes de ver a aula) fim = False cont = 0 while fim == False: n = int(input('Coloque um número para ver a soma (999 para parar) -> ')) cont += n if n == 999: cont -= 999 print('A soma total deu {}'.format(cont)) fim = True print('Fim')

[@Last669]

JEITO ERRADO DO CÓDIGO num = soma = contador = 0 while num != 999: num = int(input('NUMERO: '))

[@eglthales7754]

cara man, tuuudo isso, brabo

[@miickeypdrp5819]

quando acabar esse curso, você vai procurar por outros cursos e quando perceber a diferença da didática, vai ser tarde demais, já acabei o curso de python e to refazendo todos exercicios. soma = cont = 0; while True: numero = int(input('digite um número [999 para parar]: ')); if numero == 999: break; else: cont += 1; soma += numero; print('você digitou',cont,'números e a soma total é:',soma);

[@MariaRocha-tx8ot]

fiz diferente mas também deu certo! valor = 0 cont = 0 soma = 0 while valor != 999: valor = int(input('Digite um valor [999 para parar]: ')) if valor != 999: cont += 1 soma += valor print(f'Os valores somados é igual a {soma}. Foram digitados {cont} valores.')

[@douglasrosas9078]

Eu fiz assim pq o professor fez algo similar em um exercício passado fim = False cont = soma = 0 while not fim: num = int(input('Escreva um número [999 PARA]: ')) if num != 999: soma = soma + num cont = cont + 1 elif num == 999: fim = True print('Você digitou {} números e a soma entre os numéros digitados é {}.'.format(cont, soma))

[@extremeotakugamer]

Fiz deste jeito: n = 0 soma = 0 count = 0 while n != 999: n = int(input("Digite um número q não seja 999: ")) if n != 999: soma = soma + n count += 1 print("O valor de números digitados é de {} e o total da soma entre eles é {}".format(count, soma))

[@gabrielyujiwakugawa64]

foi tranquilo fiz usando 9 linhas usando if para somar se for difrente de 99: n1 = 0 s = 0 sn = 0 while n1 != 999: n1 = int(input('Digite um número [999/para parar] ')) if n1 != 999: s += n1 sn += 1 print(f'Você digitou {sn} números e a soma entre eles é {s}')

[@1FeiJaoz]

Pelo que vi, existem várias maneiras de resolver, porém a que foi mais coerente para mim foi utilizando o IF, e ficou assim: tot = 0 n = 0 soma = 0 while n != 999: n = int(input('Digite um número [999 para parar]: ')) if n != 999: soma += n tot+=1 print(f'O usuário digitou um total de {tot} números.') print(f'A soma dos números digitados pelo usuário é igual a {soma}.')

[@henrymota8783]

Depois de ser atropelado por vários dos exercicios anteriores, consegui esse de primeira. Eu fiz um pouco diferente: cont = 1 soma = 0 quantos = 0 total = 0 while cont != 999: n = int(input('Digite um número. [999 para parar]: ')) soma += 1 quantos = n total += quantos if n == 999: cont = 999 print('Você digitou {} números e a soma entre eles foi {}. '.format(soma,total-999))

[@elianaluz2126]

Eu fiz desse jeito C = 0 S = 0 Q = -1 While c != 999: S += c Q += 1 C = int(input('Digite um número [999 para parar]: ') Print(' Você digitou { } números e a soma entre eles foi { }'. Format(Q, S)

[@jonathannunes7368]

Fiz assim print('''para encerrar o programa digite 999''') n=int(input('digite um numero:')) soma=0 contador=0 while n

[@jpcardoso387]

essa daí foi bem de boa n = s = c = 0 while n != 999: c += 1 s += n n = int(input('Digite um número [999 para parar]: ')) print(f'Você digitou {c-1} números e a soma entre eles foi {s}')

[@nicolasdesena9530]

Eu fiz assim: n = 0 s = 0 c = 0 while n != 999: n = int(input('Digite os números.')) if n == 999: print('Acabou') else: s = s + n c = c + 1 print('A quantidade de números digitados foi {} e a soma entre eles foi {}'.format(c, s))

[@cassianaoliveira8070]

pra resolver o problema da soma dos numeros e da quantidade eu usei o if print('o programa só vai parar quando vc digitar o numero 999') soma = cont = num = 0 while num != 999: num = int(input('digite um numero:')) if num != 999: cont += 1 soma += num print(f'voce digitou {cont} numeros e a soma deles é {soma}')

[@RossAmaral77]

Muito bom q o guanabara coloca um exercicio anterior dificil pra caralho e do nada um molezinha

[@RamozinBiblical]

Usei como condição de parada o "0", até porque ninguém soma ele. Ficou mais fácil e prático. De qualquer forma, é importante saber desta outra forma.

[@RamozinBiblical]

n = int(input("Digite [999] para parar:")) soma = cont = 0 while n != 999: soma += n cont += 1 n = int(input("Digite [999] para parar:")) print(f"O resultado da soma entre todos os números é {soma} {cont} números foram somados ")

[@heitormacedo1119]

Bem, eu fiz um pouco diferente pois acabei usando ''if'', mas acho que meu código ficou legal pelo fato de utilizar de while com condição aninhada. Segue o código: soma = cont = n = 0 while n != 999: n = int(input('Digite um número [999 para parar] ')) if n != 999: soma += n cont += 1 print('Você digitou {} números e a soma desses números é {}. Programa finalizado!'.format(cont, soma)) Qualquer dúvida só comentar aqui! 👍

[@AmoebaPsAmoeba]

Acho que todo código hoje em dia fica melhor usando f-string, uma sugestão.

[@daniloartur4843]

Dessa maneira abaixo funcionou, sem precisar declarar a variável fora da lógica While soma = 0 num = 0 while num != 999: soma = soma + num num = int(input('Digite um numero [999 para parar]: ')) print(soma)

[@franciscotadeupezzi3431]

Obrigado! n = 0 cont = 0 s = 0 while n != 999: n = int(input('Digite um número: ')) if n != 999: cont += 1 s += n print('Foram digitados {} números e a soma foi {}.'.format(cont, s))

[@renan.calazans]

Fiz de uma maneira diferente. Com o contador já iniciando com -1. Assim ↓ Mas confesso que a do professor é mais sensata. n = 0 soma = 0 contador = -1 while n != 999: soma += n contador += 1 n = int(input('Digite um número (caso deseje parar 999): ')) print(f'Você digitou {contador} valores, cuja a soma é {soma}')

[@lynes.]

Fiz dessa forma: n = qnt = soma = 0 while n != 999: n = float(input("Digite um número [999 finaliza] ")) if n != 999: qnt += 1 soma += n print("Você digitou {} números e a soma entre eles é {:.0f}".format(qnt, soma))

[@umberto_nunes]

Eu solucionei com uma gambiarra diferentes rsrsrs c = -1 l = [] user = 0 while user != 999: user = int(input('Digite um valor: [999 para sair] ')) if user != 999: l.append(user) c += 1 print('Você digitou {} valores. A soma entre eles é {}'.format(c, sum(l))) Aqui, eu coloquei o contador para começar com -1, dai, o flag corrige ele para fechar a contagem certinha. Além disso, coloquei todos os valores dentro de uma lista e usei o sum(lista) para me dar a soma de todos eles :D

[@MrDJMedina30]

Opa, estudando Python aqui em 2022! Curso em Vídeo sempre me ajudando! Segue como ficou minha solução: c = soma = 0 parar = False while parar == False: n = int(input('Entre com um número [999 parada]: ')) if n != 999: soma += n c += 1 else: parar = True print('Parada!') print('Foram digitados {} números e a soma deles é {}.'.format(c, soma))

[@shadow_lofi]

Eu fiz diferente e funcionou também; n = 0 cont = 0 soma = 0 while n != 999: n=int(input('Digite um número [999 para parar]: ')) if n != 999: cont += 1 soma += n print('Foram digitados {} números e a soma entre eles foi {}.'.format(cont, soma))