Bem vindo ao curso de Introdução à Ciência da Computação destinado aos alunos regulares da Universidade de São Paulo e a todos os demais interessados em aprender não só a programar em Python mas também os conceitos básicos da Ciência da Computação! Aqui você irá aprender os principais conceitos introdutórios de Ciência da Computação e também aprenderá a desenvolver pequenos programas na linguagem Python. Este curso não possui pré-requisitos. Não é esperado que você tenha qualquer experiência prévia em programação, no entanto, se supõe que o aluno domine os conceitos básicos de matemática do ensino fundamental. O objetivo principal é desenvolver o raciocínio aplicado à formulação e resolução de problemas computacionais. O ato de programar é uma ferramenta útil para trabalhar esse raciocínio, bem como tornar mais concretos outros conceitos comuns em Ciência da Computação. Ao término do curso, o aluno estará capacitado para escrever pequenos programas em Python e prosseguir para a parte 2 do curso. Bom aprendizado! === Esse curso foi elaborado com o apoio dos Profs. José Coelho de Pina e Carlos Hitoshi Morimoto do Departamento de Ciência da Computação do IME-USP. Nelson Posse Lago, gerente técnico do CCSL-IME-USP, Antonio Abello, Athos Ribeiro e Yorah Bosse têm sido excelentes assistentes de ensino, ajudando a manter a qualidade do curso.
Exercício Resolvido
Loading...
Do curso por Universidade de São Paulo
Introdução à Ciência da Computação com Python Parte 1
2219 classificações
Na lição
Repetições Encaixadas
Existem situações em que precisamos trabalhar com repetições de repetições. Vamos ver como isso funciona?
Conheça os instrutores
Fabio KonProfessor Titular
Departamento de Ciência da Computação - IME
[MÚSICA] Vamos agora fazer,
junto aqui, e raciocinando conjunto,
exercício pouco mais complexo lidando com manipulação de
números e ainda exigindo laços aninhados repetições com "whiles" encaixados.
E o exercício é este que está aqui, que vocês estão vendo.
Dado número inteiro n, sendo que n é maior que 1, positivo maior que 1 imprimir a sua
decomposição fatores primos indicando também a multiplicidade de cada fator.
Então, para relembrar como que é essa decomposição fatores primos,
por exemplo, o número 8 ele é 2 ao cubo 2 * 2 * 2.
Então, o número 8, o único fator dele é o 2 e
a multiplicidade é 3, porque oito é dois ao cubo.
Já o 20 quatro vezes cinco, dois vezes dois vezes cinco.
Então 20 tem dois fatores tem o 2 e tem o 5 sendo que o 2 tem multiplicidade 2,
porque é 2 ao quadrado e o 5 tem multiplicidade 1.
O último exemplo aqui, o mil Mil é
2 * 2 * 2 * 5 * 5 * 5, então o mil tem dois fatores: o
dois que tem multiplicidade 3 e o cinco que tem multiplicidade 3.
Então, eu quero fazer programa, Python, que dado número inteiro ele
vai imprimir quais são os fatores e a multiplicidade de cada fator.
Então, vamos raciocinar conjunto como é que a gente poderia fazer isso.
Então a primeira coisa a gente vai precisar ler número inteiro.
Então eu vou pedir aqui para o usuário digitar: "Digite
número inteiro maior
do que 1".
Então ele vai digitar esse número inteiro, pronto.
Agora a gente tem que descobrir quais são os fatores.
Então os fatores geral são esses fatores primos.
Como que a gente pode calcular isso,
a gente vai começando do 2 e vê se o 2 divide o número n,
e se dividir, a gente vê quantas vezes ele divide o número n.
Depois, que a gente vê que o 2 não divide mais o n, porque nós já fizemos todas as
divisões, a gente pode ir para o 3, e assim por diante, a gente vai indo para os
vários possíveis fatores até que o número a gente vai dividindo o número
por esses fatores, vai chegar momento que o número resultante vai ser 1.
Daí pronto e acabou, já fizemos todas as decomposições.
Toda decomposição fatores primos.
Então eu vou começar pelo fator 2.
E vou dizer que a multiplicidade desse fator
inicialmente vai ser zero, e daí vou calculando e vou somando 1 nessa
multiplicidade à medida que vou conseguindo fazer essas divisões.
Vou fazer o seguinte, enquanto,
vejamos, eu vou precisar de dois "whiles",
o primeiro "while" pra ir percorrendo os vários fatores,
então o fator vai ser 2, 3 e assim por diante, vai ser esse "while"
mais externo e depois o "while" mais interno que ele realmente vai
ver se o fator divide esse número n.
Então para ver se o fator divide o número n,
a gente pode fazer o seguinte, lembra do porcento?
O porcento é o resto da divisão.
Se o resto da divisão de n por fator é igual a zero, isso quer dizer que sim,
o fator divide n, dá uma divisão inteira, divisão exata.
Então, nesse caso, a multiplicidade é igual a multiplicidade mais 1.
Então eu tô somando 1 aqui na multiplicidade quando o fator divide
esse número n.
E, eu preciso agora realmente fazer a divisão, então, por exemplo,
se eu tenho o número 100, começo com n valendo 100, vou ver se o 2 divide 100?
Sim, 2 divide 100, dá uma divisão exata.
Agora então eu somo na multiplicidade ali do 2 e agora preciso
dividir o n por 2 para ter o 50, e daí repetir esse processo.
Então eu vou fazer aqui, o n recebe n dividido pelo fator.
Então o n agora passou para 50, se passou para 50, de novo vou dividir por 2.
Divide por 2, 50 dividido por 2 dá exata?
Sim, dá zero aqui o resto da divisão por 2,
de novo eu vou somar 1 na multiplicidade, a multiplicidade vai para 2.
E daí, eu divido novamente.
O 50 dividido por 2 de novo, dá 25, o n vai para 25.
Daí nesse caso, o 25 é didivido por 2?
Não, não é divisível por 2,
então 25% do fator não é igual a zero, ele vai cair fora desse "while".
Quando ele cai fora desse "while",
daí a gente tem que imprimir o que a gente aprendeu.
O que a gente aprendeu?
A gente aprendeu que o fator,
e aqui eu vou colocar o nome, o valor da variável fator.
Então, por exemplo, nesse caso o fator 2.
Vou dizer a multiplicidade dele é igual,
e daí o valor da variável multiplicidade.
"Multiplicidade".
Então, o fator tal, tem multiplicidade igual a tal.
Já imprimi isso.
Agora, o que eu posso fazer?
Posso ir para o próximo fator, para ir para o próximo fator,
vou fazer fator recebe fator + 1.
Então, saí do dois vou para o três.
Eu vou repetindo isso e qual seria a condição de parada?
A condição de parada, note que eu vou dividindo esse n por fatores,
pelos vários fatores ali.
Vai chegar algum momento que eu já identifiquei todos os fatores.
Quando eu já identifiquei todos os fatores, o n vai tá valendo 1,
porque eu já dividi por todos os fatores.
Então, eu vou repetindo isso aqui enquanto o n for maior que 1,
porque quando o n for igual a 1, é para eu parar e cair fora.
Então quando n for igual a 1,
ele vai sair desse while mais externo e vai terminar a execução do programa.
Então vamos testar ver se está funcionando,
vamos testar para alguns valores.
Vou mandar executar aqui, vou ter que ver se tem algum erro de compilação,
guardar num arquivo e vou chamar de fatores primos.
Tá.
Então compilou, tá executando aqui: "Digite número inteiro maior do que 1".
Eu vou começar digitando 10.
Já vi que erramos alguma coisa, não deu certo.
Porque o 10, ele devia dizer: "fator 2 multiplicidade é igual a 1".
E depois, devia ter só mais o fator 5.
Mas ele continuou dando multiplicidade 1 para todos aqui.
Porque eu cometi algum erro.
Qual foi o erro que eu cometi?
Note que já percebi.
Quando eu tô mudando de fator,
quando eu mudo de fator para o próximo eu devia zerar a multiplicidade porque
a variável multiplicidade calculou a multiplicidade do valor anterior.
Então eu vou aqui "zerar multiplicidade" recebe zero.
Então, quando eu passo para o próximo fator, eu zero a multiplicidade.
Agora eu acho que vai dar certo, vamos ver.
Vamos torcer para dar certo.
Dez, tá certo, tá certo,
mas não está do jeito que eu queria.
Porque ele falou, fator 2 multiplicidade igual a 1.
Tá certo.
Fator 3 multiplicidade igual a 0, tá certo.
Fator 4 igual a zero, fator 5 igual a 1.
O que eu não gostei se a multiplicidade é 0 ele não precisava imprimir.
A gente podia imprimir só os fatores que têm a multiplicidade maior que zero.
Como a gente pode fazer isso?
Talvez com "if", colocando if aqui.
"If multiplicidade é maior que 0",
daí sim, você me imprima isso aqui.
Caso contrário, não precisa imprimir nada.
Vamos ver agora se a saída fica pouco mais limpa.
Eu vou aproveitar e já vou fazer com o número 1000 agora.
Tá, olha, deu certo.
Fator 2 multiplicidade 3, fator 5 multiplicidade 3.
Vou pegar e testar agora com número potência de 2 bem grande.
Vamos ver se dá certo?
Se não me engano, 65536 é potência de dois.
Sim, fator 2 multiplicidade 16 porque 2 elevado a 16 dá 65536.
E você pode na verdade digitar qualquer número aqui.
Pegar número grandão, e ele faz a decomposição ali fatores primos,
particular achamos número primo bem grande aqui.
Será que esse número é primo mesmo?
Eu tenho uma solução, escreva programa que dado número inteiro,
positivo, diz se esse número é primo ou não.
Então, tente fazer isso.
Programa, uma função Python que dado número inteiro positivo,
vai me devolver "True" ou "False",
Verdadeiro ou Falso dizendo se aquele número é inteiro positivo ou não.
Então, isso aí fica de lição de casa e aqui a gente viu mais exemplo de
aplicação de "whiles" encaixados, de repetições encaixadas.
[MÚSICA]
[MÚSICA]
[MÚSICA]
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
