[box class=windowbg1]
Índice das aulas básicas
- Aula 1 - Introdução (http://centrorpg.com/index.php?topic=198.0)
- Aula 2 - Objetos (http://centrorpg.com/index.php?topic=205.0)
- Aula 3 - Operações (http://centrorpg.com/index.php?topic=1218.0)
- Aula 4 - Condições (http://centrorpg.com/index.php?topic=2504.0)
- Aula 5 - Repetição (http://centrorpg.com/index.php?topic=2870.0)
- Aula 6 - Arrays (http://centrorpg.com/index.php?topic=523.0)
- Aula 7 - Hashes (http://centrorpg.com/index.php?topic=589.0)
[/box]
[box class=windowbg1]Índice das aulas avançadas
- Aula 8 - Superclasses e instâncias (http://centrorpg.com/aulas-para-rgss/superclasse-herancas-e-instancias/)
[/box]
[box class=windowbg1]Índice das aulas de algoritmos
- Aula 1 - Sort (http://centrorpg.com/aulas-para-rgss/algoritmo-1-otrs-gt-sort/)
- Aula 2 - Busca (http://centrorpg.com/aulas-para-rgss/algoritmo-2-busca/)
- Aula 3 - Recursividade (http://centrorpg.com/aulas-para-rgss/recursividade/)
[/box]
[box class=windowbg2]Estruturas de Repetição
[/box]
[box class=catbg2]Introdução
[/box]
[box class=information]
Agora aprenderemos sobre os famosos loops! As estruturas de repetição são essenciais na programação, e eles fazem todo o trabalho sujo de justamente, repetir blocos de códigos, mais do que isso, ele permite junto com tudo que foi aprendido, condições, operações, objetos, fazer exatamente o que você deseja que a máquina faça, por isso bom, chega de papo vamos a prática.[/box]
[box class=catbg2]ciclo básico
[/box]
[box class=information]
O loop mais simples possível, ele é simplesmente, faça loop, ou seja loopdo, em que o código entra em um loop infinito, você pode testar o código a seguir, lembrando que o programa entrará em um loop infinito, então esteja preparado para fechar, talvez forçadamente o programa.
loop do
p "5"
end
Se perceberem, o loop não termina, pois o código lê a seguinte forma o código acima.
loop do #inicia o loop
p "5" #executa o código
end #volta ao ínicio do loop
ou seja, ele fará eternamente a execução do p "5", para quebrar um loop, é usado a função break.
Podem testar da seguinte maneira.
a = 0
loop do
p a
a += 1
break if a == 10
end
Testem e reparem no que acontecerá na tela de depuração do RPG Maker!
Bom percebendo que para quebrar um loop é necessário um break, e que praticamente, não todos, porém quase todos os loops criados tem um break point, é ai que entra o while, o loop com break imbutido no código.
[/box]
[box class=catbg2]while
[/box]
[box class=information]
O while é um loop com um break já no próprio código, encurtando e otimizando o programa, ele é usado como se fosse uma condição com a seguinte estrutura.
enquanto código tal faça
bloco de código
fim enquanto
na prática, o código acima que foi feito com o loop do.
a = 0
while a != 10
p a
a += 1
end
Testem e vejam como funciona o while na prática.
[/box]
[box class=catbg2]for
[/box]
[box class=information]
O for, é mais compacto ainda, ele junta o loop, a declaração de variável(normalmente um contador), o break point e a operação de soma, tudo em apenas uma função, como esses 2 últimos passos são muito usado em loops, porque não ter uma função que faça tudo isso, lembrando que o for é presente em praticamente toda linguagem de programação.
Vamos pegar o código anterior e colocar dentro de um for.
a = 0
while a != 10
p a
a += 1
end
colocando em um for.
for a in 0..10
p a
end
veja como ficou bem mais compacto o código do while, uma observação muito importante, muitas vezes já devem ter visto isso. for a in 0..10
e isso
for a in 0...10
A diferença é bem simples, 2 pontos .. não inclui o último valor, 3 pontos, ... inclui o último valor.[/box]
[box class=catbg2]upto, downto
[/box]
[box class=information]Agora vem uma parte mais especifica, veja a partir daqui apenas se já estiver "manjando" de tudo acima, sugiro pular para os exercícios caso ainda precise treinar, já que essa parte da aula é um extra a repetições :D.
Agora vem uma parte mais interessante para os que já estiverem se aprofundando na programação, já que é o uso de blocos, que deixa o código tanto mais rápido quanto esteticamente muito mais bonito. Upto e downto são 2 comandos semelhantes ao for, porém se desejar, nem declarar uma variável é necessário, por exemplo o código acima com o upto.
1.upto(9){|a| p a}
No caso a barra dupla || faz o seguinte, ela pega o valor do argumento no caso o 9, e declara como a, essa barra dupla é desnecessária caso não utilize o argumento, por exemplo.
1.upto(9){ p 1}
E o downto faz exatamente a mesma coisa, porém decrescendo ao invés de aumentando.
9.downto(1){|a| p a}
[/box]
[box class=catbg2]Conclusão + exercicios
[/box]
Bom a aula chega ao fim, ainda faltam alguns loops, como .each e outros, porém nas 2 próximas aulas, Arrays e Hashes que já estão presentes no fórum, tem o restante dos principais blocos e tem tudo que é necessário para programar do melhor modo possível!
exercícios:
fácil:
Fazer um loop que imprima os valores de 2 até 20, porém apenas os números pares.
Fazer um loop que imprima os valores de um múltiplo que possamos modificar em uma constante antes do código começar, exemplo.
Mult = 5...
Ai colocar o código para imprimir apenas os múltiplos de 5, até 5x10 = 50.
médio:
Faça um loop que imprima a soma, multiplicação, divisão e subtração de 2 números iguais até 10, usando a aula de métodos para cada uma das operações.
Faça um código usando o loop, que imprime o menor múltiplo comum de 2 números quaisquer, usando obviamente todas as aulas anteriores.
difícil:
Faça um código que indique se um número é primo, ou não(se é divisível por outro número que não seja 1 ou ele mesmo).
Faça um código que retorne o valor de uma raiz quadrada com 2 casas de precisão, pode funcionar para números apenas maiores que 1.
Raizen, acho que você se confundiu em relação aos pontos aqui
for a in 0..10
Se tem 2 pontos "0..10" inclui o ultimo valor, se tem 3 pontos "0...10" não inclui o ultimo valor.
Spoiler
Tava quebrando a cabeça com isso kkk
Meu exercício Raizen:
Fácil
(sou muito noob, só faço só fáceis).
class Netinho
#Metodo 1, que imprime valores de 0 a 20, mas só os números par.
def exercicio1
for a in 0..20 #loop de 0 a 20.
if a % 2 == 0 #Verifica se o resto da divisao por dois é zero.
p a #mostra o resultado no depurador.
a +=1 #Adiciona 1 a variável a.
end
end
end
#-----------------------------------------------------------------
#Metodo 2, que imprime valores de 0 a 20, mas só os multiplos de 5.
def exercicio2
for b in 0..20 #loop de 0 a 20.
if b % 5 == 0 #Verifica se o resto da divisão por cinco é zero.
p b #mostra o resultado no depurador.
b +=1 #Adiciona 1 a variável b
end
end
end
end
result = Netinho.new
result.exercicio1
result.exercicio2
Ótimas aulas Raizen, só recomendo que explique sobre o Cache e sobre o Bitmap e suas funções, são muito importantes! Optei para os fáceis:
Fácil
1. Fazer um loop que imprima os valores de 2 até 20, porém apenas os números pares.
for loop_number in 2..20 #vai executar o loop
if loop_number % 2 == 0 # este vai checar se o número é par ou não através da função "resto".
p loop_number
end
end
2. Fazer um loop que imprima os valores de um múltiplo que possamos modificar em uma constante antes do código começar, Ai colocar o código para imprimir apenas os múltiplos de 5, até 5x10 = 50.
number = 0 # Declara a variável do número
while number != 50 # Vai checar se a variável tem valor diferente de 50.
number += 5
p number
end
Nossa,essa eu ralei nos exercícios,e ainda não fiz certinho,mas fiz algo perto.
Fácil: Esses eu consegui de boa
Spoiler
De 2 a 20 apenas par:
class Ryugo
par = 2
for par in 2..20
if par % 2 == 1
else
p par
end
end
end
Imprimir múltiplos(tabuada) de X número constante:
class Ryugo
Multi=5
for Multi in 5..50
if Multi % 5 == 0
p Multi
end
end
end
Agora sim vem os que quebrei a cabeça,fiquei mais de duas horas neles e só fiz um do médio(e nem fiz certo) porque não entendi o outro,e um do difícil porque vou ir dormir agora,e amanhã só entro a noite:
Médio
Esse aqui na verdade nem funciona como deveria,tive muitos erros com ele,e até procurei na internet.Mas não consegui fazer :hmm:
class Ryugo
n1 = 4
n2 = 6
m = 1
n3 = 0
n4 = 1
while n3 != n4
n3 = n1 * m
n4 = n2 * m
m += 1
end
p n3
p n4
end
Difícil
Esse saiu quase totalmente certo,só tem um pequeno detalhe errado,que não sei consertar:
class Ryugo_tarefa
def descoprimo(x)
p "Sempre prevalecerá o que dizer que não é primo,a não ser que não diga."
n1 = x
n2 = 2
n3 = n1
while n2 != n3 - 1
if n1 % n2 == 0
p "O número #{n1} não é primo"
break
else
p "O número #{n1} é primo"
end
n2 += 1
end
end
end
primos = Ryugo_tarefa.new
primos.descoprimo(43)
Gostaria de quem puder me ajudar nesses dois últimos,agradeceria muito.Agora que comecei tenho que conseguir terminar :grr:
Provavelmente amanhã tento fazer a outra tarefa dificil. Té :wow:
@Netinho: Ah, está pegando bem o esquema x], err deve estar errado mesmo, depois eu arrumo na aula, vlws :P.
De qualquer modo, não foi exatamente isso que pedi para o segundo exercicio, porém realmente, talvez tenha ficado meio confuso o que foi pedido xD, mas veja bem, tem uma única coisa, no for você está colocando um somador.
b+=1 por exemplo, não precisa :P, teste sem e veja o que acontece, o for ele soma automaticamente já ^^.
De resto está bem legal.
@SuperPig: Sim o segundo exercicio era quase isso que eu queria k, mas está bem legal, o code está certo :D, mas quando for programar tome sempre cuidado com o != e ==, nos loops xD, eles são traiçoeiros rs, nesse caso eu colocaria > (maior que), pois ai com certeza o loop vai fechar. Mas está bem legal boa sorte nos exercicios. Ah sobre Cache e Bitmap, sim sim, apesar que isso são classes do Ruby, ai eu tenho que me organizar melhor para explicar rs, vlws as dicas :D
@Ryugo: No primeiro exercicio está certo, mas esse
if tal
else, ficou estranho era mais fácil mudar a condição para não ter o else, exemplo...
if par % 2 == 0
ou...
unless par % == 1
no segundo está quase perfeito k, menos uma coisa. Era para ficar assim.
class Ryugo
Multi=5
for multi2 in 5..50
if multi2 % Multi == 0
p multi2
end
end
end
Sim vai rachar a cuca ver isso rs, mas tenta entender o que acontece no código, não modifique variáveis com letra maiuscula durante o code, por exemplo.
Multi, para isso use outra variável que seja modificavel, dê uma olhadinha na aula lá atrás de variáveis, dá para usar assim, @multi, ou multi, ou $multi... nesse caso achei melhor com letra minuscula, então coloquei multi2. Letra maiuscula é reservada para constantes, e constantes não são bom modificarmos x].
Do minimo multiplo comum, peguei um pouco pesado rs, vou deixar a resposta aqui, tente estudar a partir dele x].
Spoiler
class Rai
def mmc(x, y)
cont = 1
while cont % x != 0 or cont % y != 0
cont += 1
end
p cont
end
end
objeto = Rai.new
objeto.mmc(5, 7) # teste
coloquei class Math porque já existe, porém pode ser qualquer um que você quiser. E caso não saiba usar or, dá para usar 2 while sem problemas, mas assim, a ideia é, colocar um contador, ir somando um nele, e depois verificar se esse contador quando dividir pelo primeiro número e pelo segundo número, ambos terão resto 0.
O exercicio dificil, bom não preciso dizer que é difícil rs, mas está no caminho certo x], uma dica é que o p, eu não coloco dentro do loop, e tem uns números que dizem ser primo e não são, por exemplo o 51. Tente novamente :D, mas dessa vez tire os p de dentro do while, apenas para falar depois do while se ele é ou não é primo, e eu faria alguma variável ter sempre o mesmo valor por exemplo.
primo = true.
E lá no while, colocar uma condição.
if numero tal % outronumero == 0
primo = false
end
tem 2 modos de fazer isso, um seria dividindo o número até o número 2, e ver se tem divisões com resto 0, ou multiplicando até alcançar o número x]. Programar é quase que recriar a matemática, tem que pensar em um modo lógico de chegar a resposta xD.
Spoiler
Citação de: Raizen online 01/08/2013 às 14:10
@Netinho: Ah, está pegando bem o esquema x], err deve estar errado mesmo, depois eu arrumo na aula, vlws :P.
De qualquer modo, não foi exatamente isso que pedi para o segundo exercicio, porém realmente, talvez tenha ficado meio confuso o que foi pedido xD, mas veja bem, tem uma única coisa, no for você está colocando um somador.
b+=1 por exemplo, não precisa :P, teste sem e veja o que acontece, o for ele soma automaticamente já ^^.
De resto está bem legal.
@SuperPig: Sim o segundo exercicio era quase isso que eu queria k, mas está bem legal, o code está certo :D, mas quando for programar tome sempre cuidado com o != e ==, nos loops xD, eles são traiçoeiros rs, nesse caso eu colocaria > (maior que), pois ai com certeza o loop vai fechar. Mas está bem legal boa sorte nos exercicios. Ah sobre Cache e Bitmap, sim sim, apesar que isso são classes do Ruby, ai eu tenho que me organizar melhor para explicar rs, vlws as dicas :D
@Ryugo: No primeiro exercicio está certo, mas esse
if tal
else, ficou estranho era mais fácil mudar a condição para não ter o else, exemplo...
if par % 2 == 0
ou...
unless par % == 1
no segundo está quase perfeito k, menos uma coisa. Era para ficar assim.
class Ryugo
Multi=5
for multi2 in 5..50
if multi2 % Multi == 0
p multi2
end
end
end
Sim vai rachar a cuca ver isso rs, mas tenta entender o que acontece no código, não modifique variáveis com letra maiuscula durante o code, por exemplo.
Multi, para isso use outra variável que seja modificavel, dê uma olhadinha na aula lá atrás de variáveis, dá para usar assim, @multi, ou multi, ou $multi... nesse caso achei melhor com letra minuscula, então coloquei multi2. Letra maiuscula é reservada para constantes, e constantes não são bom modificarmos x].
Do minimo multiplo comum, peguei um pouco pesado rs, vou deixar a resposta aqui, tente estudar a partir dele x].
Spoiler
class Rai
def mmc(x, y)
cont = 1
while cont % x != 0 or cont % y != 0
cont += 1
end
p cont
end
end
objeto = Rai.new
objeto.mmc(5, 7) # teste
coloquei class Math porque já existe, porém pode ser qualquer um que você quiser. E caso não saiba usar or, dá para usar 2 while sem problemas, mas assim, a ideia é, colocar um contador, ir somando um nele, e depois verificar se esse contador quando dividir pelo primeiro número e pelo segundo número, ambos terão resto 0.
O exercicio dificil, bom não preciso dizer que é difícil rs, mas está no caminho certo x], uma dica é que o p, eu não coloco dentro do loop, e tem uns números que dizem ser primo e não são, por exemplo o 51. Tente novamente :D, mas dessa vez tire os p de dentro do while, apenas para falar depois do while se ele é ou não é primo, e eu faria alguma variável ter sempre o mesmo valor por exemplo.
primo = true.
E lá no while, colocar uma condição.
if numero tal % outronumero == 0
primo = false
end
tem 2 modos de fazer isso, um seria dividindo o número até o número 2, e ver se tem divisões com resto 0, ou multiplicando até alcançar o número x]. Programar é quase que recriar a matemática, tem que pensar em um modo lógico de chegar a resposta xD.
Nossa,muito obrigado pelos dois super comentários que você fez pra me explicar tudo :XD:
Respondendo por etapa:
É,não percebi esse negócio do else no 1º exercicio --'
É,errei ali em vez de colocar a variável coloquei o número.E sobre o negócio da contante,já entendi a diferença das variáveis locais,globais e de instancia.É que no exercício você pediu pra alterar o valor antes com uma constante,aí achei que era pra usar uma contante :ded:
Na verdade,olhando assim agora,nem é tão difícil o de MMC,só faltou eu pensar mais(bem mais).
Peguei o código que você fez e comentei ele inteiro pra entender certinho tudo que você fez.
Spoiler
class Rai #Declara classe
def mmc(x, y) #método mmc
cont = 1 #variavel cont tem valor 1
while cont % x != 0 or cont % y != 0 #Enquanto a var cont dividido por x for diferente de 0 faça:
#Ou enquanto cont dividido por y for diferente de 0 faça:
cont += 1 #Adiciona mais um na var cont
end #Fim do bloco while
p cont #Escreve o valor da var cont
end #Fim do bloco do método
end #Fim do bloco da classe
objeto = Rai.new #Variavel objeto tem valor da classe Rai
objeto.mmc(5, 7) # teste
Agora,esse difícil ta me matando :sad: Tentei fazer como você disse,mas algo não da certo:
Spoiler
class Ryugo_tarefa
def descobrir_primo(x)
n1 = x
n2 = 2
n3 = n1
primo = false
while n2 != n3 - 1 or primo = false
if n1 % n2 == 0
primo = true
end
n2 += 1
end
if primo = true
p "O número #{n1} não é primo!"
else
p "O número #{n1} é primo!"
end
end
end
escolher_primo = Ryugo_tarefa.new
escolher_primo.descobrir_primo(11)
Não entendi o que tem de errado aí :hmm:
E fiz o outro exercício dificil,eu no começo tava tentando de um jeito que ia dar umas 100 linhas.Então fui dar umas pesquisada na net,e aprendi umas coisas bem legais :XD:
Aqui ele:
class Ryugo
p "Qual número você quer calcular a raiz quadrada?" #Pergunta ao usuário
x = gets.to_i #guarda o valor de gets.to_i na var x
raiz = Math.sqrt(x) # guarda o valor de Math.sqrt(x) na var raiz
p raiz #imprimi a var raiz
end
#============================== gets.to_i ======================================
#O comando gets serve para o usuário digitar uma string e o pc ler.Quando estiver
#com o ".to_i" lerá também números(integers,floats,etc)
#===============================================================================
#============================ Math.sqrt ========================================
# É usado para calcular raiz quadrada,"sqrt" é uma abreviação de "Square root"
#(raiz quadrada). E Math é um módulo nativo para funções matemáticas.
#===============================================================================E agora rumo à aula 6,arrays :*-*:
Té :wow:
*Tópico que renace! Estou certo que quero responder e blá blá blá...*
Nem testei, to no trabalho do meu pai... por isso to fazendo só o fácil
eu usei o loop do por que deu preguiça de usar os outros
class Keilo
n = 0
loop do
break if n == 22
p n
n + 2
end
end
end
Voltei de novo e.e dessa vez com os intermediários e avançados ^^ (OBS: Ótima aula, parabéns :D)
Intermediário 1
class LoopMat
def soma(x)
for s in x..10
r = s + s
p r
end
end
def diminuir(x)
for d in x..10
r = d - d
p d
end
end
def multi(x)
for m in x..10
r = m * m
p r
end
end
def quo(x)
for q in x..10
r = q / q
p q
end
end
end
#Testing
test = LoopMat.new
#para evitar desorganização, usar um método por vez
som = false
dim = false
mul = true
quo = false
test.soma(1) if som == true
test.diminuir(1) if dim == true
test.multi(1) if mul == true
test.quo(1) if quo == true
Intermediário 2
def multiple(x,y)
a = 2
b = 2
loop do
if x % a == 0 and y % b == 0
p a
p b
break
else
a += 1 if x % a != 0
b += 1 if y % b != 0
end
end
end
multiple(17,4)
não consegui fazer os avançados, mas tentei, perdão ç-ç
Estou me esforçando ao máximo para tentar aprender, então tá ai mais um.
#-------------------------------------------------------------------------------
# Dever de Repetições
#-------------------------------------------------------------------------------
#Fáceis
for numero in 2..22
if numero % 2 == 0
p numero
end
end
class Links3
multiplo = 5 #Você escolhe o multiplo
for multiplo2 in 5..50 #Em 5..50, os 5 troque para o do multiplo(linha acima)
if multiplo2 % multiplo == 0
p multiplo2
end
end
end
#Intermediários
class Links4
def somar2(x)
for a in x..10
soma2 = a + a
p soma2
end
end
def subtrair2(x)
for b in x..10
subtraçao2 = b - b
p subtraçao2
end
end
def multiplicar2(x)
for c in x..10
multiplicaçao2 = c * c
p multiplicaçao2
end
end
def dividir2(x)
for d in x..10
divisao2 = d / d
p divisao2
end
end
end
resultado4 = Links4.new
resultado4.somar2(1)
resultado4.subtrair2(1)
resultado4.multiplicar2(1)
resultado4.dividir2(1)
class Links5
def mmc(x, y)
variavel = 1
while variavel % x != 0 or variavel % y != 0
variavel += 1
end
p variavel
end
end
resultado5 = Links5.new
resultado5.mmc(9, 7)
Tenho que confessar que o mais difícil foi o primeiro intermediário. O do mmc quando vi o script que você passou entendi rápido, mas o primeiro...
E os avançados é... avançado de mais pra mim. :XD:
Então avante a aula 6 :wow:
Já faz um tempo, mas eu aprendi assim kkkk
Nível iniciante xD
module Valores
VALOR1 = 0
VALOR2 = 20
end
x = Valores::VALOR1
y = Valores::VALOR2
loop do
x += 1
p x if x % y == 0
break if x == 500
end
kk, serve manolo!
Mas tente fazer os outros também, que são os mais utilizados, o while e for :)
Este código funciona?
5.times {print "Hello World!"}
@Raizen
Tive bastante dificuldade no dos números primos e no da raiz quadrada, o do números primos eu não usei repetição, não consegui encontrar um jeito, mas aprendi umas coisas que talvez eu consiga agora, mas já to sem saco de ficar mais um tempo tentando nesse. De qualquer forma, o da raiz quadrada tive uns problemas com arredondamento, já que a soma de "0.01" não é exata, até fiz um tópico pedindo ajuda, se puder avaliar agradeço.FÁCEIS:Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
a = 0
while a != 20
a += 2
p a
end
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
Mult = 10
for a in Mult..Mult * 10
if a % Mult == 0 then p a end
end
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def operações
@a = 2
@b = 2
loop do
soma
subtração
multiplicação
divisão
end
end
def soma
loop do
p @a + @b
break
end
end
def subtração
loop do
p @a - @b
break
end
end
def multiplicação
loop do
p @a * @b
break
end
end
def divisão
loop do
p @a / @b
break
end
end
end
nun = Nunnu.new
nun.operações
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def mmc
a = 6
b = 4
c = 1
while c % a != 0 or c % b != 0
c += 1
end
p c
end
end
nun = Nunnu.new
nun.mmc
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
class Nunnu
def met1(a)
if a == 1
print "Não é um número primo."
return
end
if a == 2 or a == 3
print "É um número primo."
return
end
if a % 2 == 0 or a % 3 == 0 or a % 5 == 0
print "Não é um número primo."
else
print "É um número primo."
end
end
end
nun = Nunnu.new
nun.met1(3)
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
a = 25
b = 1.00
while b * b < a
b += 0.01
b * b
end
p b.round(2)
Fiz meu dever de casa, tentei fazer da forma mais pratica que consegui mas não sei se consegui isso, mas acho que pelo menos fiz certo
por enquanto só fiz os fáceis pois ainda não peguei a pratica pra fazer o resto XD
Spoiler
primeiro exercicio:
a = 0
while a != 20
a += 1
if a%2 ==0
p a
end
end
segundo:
mult = 7
a = 0
for a in 0..10
p a*mult
end
Vou continuar dando uma estudada e quando conseguir fazer os mais difíceis edito isso pra adiciona-los
Edit: quebrei minha cabeça pra fazer os intermediários, saiu do jeito que eu queria que saísse, mas não sei se esta de acordo com o que foi pedido (e acrescentei comentários pra praticar XD)
Spoiler
class Akugam #Declara a classe Akugam
def adi #metodo adição
for a in 1..10 #loop contador para variavel a
p a+a #imprime a soma da variavel a com ela mesma
end #fim do loop
end #fim do metodo
def divi #metodo divisão
for b in 1..10 #loop contador para variavel b
p b/b #imprime a divisão da variavel b por ela mesma
end #fim do loop
end #fim do metodo
def multipli #metodo multiplicação
for c in 1..10 #loop contador para variavel c
p c*c #imprime multiplicação da variavel c por ela mesma
end #fim do loop
end #fim do metodo
def sub #metodo subtração
for d in 1..10 #loop contador para variavel d
p d-d #imprime subtração da varial d com ela mesma
end #fim do loop
end #fim do metodo
end #fim da classe
objeto = Akugam.new #cria variavel objeto contendo classe Akugam
objeto.adi #chama metodo adição
objeto.divi #chama metodo divisão
objeto.multipli #chama metodo multiplicação
objeto.sub #chama metodo subtração
class Akugam #Declara classe Akugam
def met(a, b) #metodo met
mult = 1 #variavel mult com valor 1
while mult%a!=0 or mult%b!=0 #loop while enquanto condição1 ou condição2 não for cumprida faça:
mult += 1 #adiciona 1 a variavel mult
end #fim loop
p mult #imprime variavel mult
end #fim metodo
end #fim class
akugam = Akugam.new #variavel akugam contendo a classe Akugam
akugam.met(5, 6) #chama metodo met
só os intermediários por enquanto, mas ja to tentando fazer os mais difíceis XD
Está tudo certo :clap:
Faça sim os mais difíceis, eles ajudam muito na lógica de programação.
Citação de: Nunnu online 15/07/2016 às 20:10
@Raizen
Tive bastante dificuldade no dos números primos e no da raiz quadrada, o do números primos eu não usei repetição, não consegui encontrar um jeito, mas aprendi umas coisas que talvez eu consiga agora, mas já to sem saco de ficar mais um tempo tentando nesse. De qualquer forma, o da raiz quadrada tive uns problemas com arredondamento, já que a soma de "0.01" não é exata, até fiz um tópico pedindo ajuda, se puder avaliar agradeço.
FÁCEIS:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
a = 0
while a != 20
a += 2
p a
end
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
Mult = 10
for a in Mult..Mult * 10
if a % Mult == 0 then p a end
end
MÉDIO:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def operações
@a = 2
@b = 2
loop do
soma
subtração
multiplicação
divisão
end
end
def soma
loop do
p @a + @b
break
end
end
def subtração
loop do
p @a - @b
break
end
end
def multiplicação
loop do
p @a * @b
break
end
end
def divisão
loop do
p @a / @b
break
end
end
end
nun = Nunnu.new
nun.operações
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def mmc
a = 6
b = 4
c = 1
while c % a != 0 or c % b != 0
c += 1
end
p c
end
end
nun = Nunnu.new
nun.mmc
DIFÍCEIS:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
class Nunnu
def met1(a)
if a == 1
print "Não é um número primo."
return
end
if a == 2 or a == 3
print "É um número primo."
return
end
if a % 2 == 0 or a % 3 == 0 or a % 5 == 0
print "Não é um número primo."
else
print "É um número primo."
end
end
end
nun = Nunnu.new
nun.met1(3)
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
a = 25
b = 1.00
while b * b < a
b += 0.01
b * b
end
p b.round(2)
Eu não consigo pensar em outra forma de fazer o primeiro exercício dos difíceis, o dos números primos, a não ser a forma que o nunnu fez, apenas encontrei um pequeno erro, que é: quando eu coloco o numero 5 a ser testado, ele retorna a resposta de que o numero 5 não é primo, tomei a liberdade de corrigir no próprio código e ficou assim:
Spoiler
class Nunnu
def met1(a)
if a == 1
print "Não é um número primo."
return
end
if a == 2 or a == 3 or a == 5
print "É um número primo."
return
end
if a % 2 == 0 or a % 3 == 0 or a % 5 == 0
print "Não é um número primo."
else
print "É um número primo."
end
end
end
nun = Nunnu.new
nun.met1(5)
não encontrei mais erros, mas não sei se é possível fazer esse exercício com os comandos de repetição (eu pelo menos não consigo pensar em uma forma de fazer isso)
já o segundo exercício sobre raiz quadrada, não consigo nem de longe pensar numa forma de resolver, e não entendi muito bem nem vendo o código do nunnu, se puder me passar a resposta pra eu tentar entender eu agradeço Raizen :*-*:
e tenho uma pequena duvida, o que seria esse comando "return" dentro do if? obrigado :XD:
Citação de: Akugam online 11/01/2017 às 20:15
Spoiler
Citação de: Nunnu online 15/07/2016 às 20:10
@Raizen
Tive bastante dificuldade no dos números primos e no da raiz quadrada, o do números primos eu não usei repetição, não consegui encontrar um jeito, mas aprendi umas coisas que talvez eu consiga agora, mas já to sem saco de ficar mais um tempo tentando nesse. De qualquer forma, o da raiz quadrada tive uns problemas com arredondamento, já que a soma de "0.01" não é exata, até fiz um tópico pedindo ajuda, se puder avaliar agradeço.
FÁCEIS:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
a = 0
while a != 20
a += 2
p a
end
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL FÁCIL
#-------------------------------------------------------------------------------
Mult = 10
for a in Mult..Mult * 10
if a % Mult == 0 then p a end
end
MÉDIO:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def operações
@a = 2
@b = 2
loop do
soma
subtração
multiplicação
divisão
end
end
def soma
loop do
p @a + @b
break
end
end
def subtração
loop do
p @a - @b
break
end
end
def multiplicação
loop do
p @a * @b
break
end
end
def divisão
loop do
p @a / @b
break
end
end
end
nun = Nunnu.new
nun.operações
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL MÉDIO
#-------------------------------------------------------------------------------
class Nunnu
def mmc
a = 6
b = 4
c = 1
while c % a != 0 or c % b != 0
c += 1
end
p c
end
end
nun = Nunnu.new
nun.mmc
DIFÍCEIS:
Spoiler
#-------------------------------------------------------------------------------
# Exercício 1 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
class Nunnu
def met1(a)
if a == 1
print "Não é um número primo."
return
end
if a == 2 or a == 3
print "É um número primo."
return
end
if a % 2 == 0 or a % 3 == 0 or a % 5 == 0
print "Não é um número primo."
else
print "É um número primo."
end
end
end
nun = Nunnu.new
nun.met1(3)
#-------------------------------------------------------------------------------
# Exercício 2 Aula 5 do Raizen RGSS3: NÍVEL DIFÍCIL
#-------------------------------------------------------------------------------
a = 25
b = 1.00
while b * b < a
b += 0.01
b * b
end
p b.round(2)
Eu não consigo pensar em outra forma de fazer o primeiro exercício dos difíceis, o dos números primos, a não ser a forma que o nunnu fez, apenas encontrei um pequeno erro, que é: quando eu coloco o numero 5 a ser testado, ele retorna a resposta de que o numero 5 não é primo, tomei a liberdade de corrigir no próprio código e ficou assim:
Spoiler
class Nunnu
def met1(a)
if a == 1
print "Não é um número primo."
return
end
if a == 2 or a == 3 or a == 5
print "É um número primo."
return
end
if a % 2 == 0 or a % 3 == 0 or a % 5 == 0
print "Não é um número primo."
else
print "É um número primo."
end
end
end
nun = Nunnu.new
nun.met1(5)
não encontrei mais erros, mas não sei se é possível fazer esse exercício com os comandos de repetição (eu pelo menos não consigo pensar em uma forma de fazer isso)
já o segundo exercício sobre raiz quadrada, não consigo nem de longe pensar numa forma de resolver, e não entendi muito bem nem vendo o código do nunnu, se puder me passar a resposta pra eu tentar entender eu agradeço Raizen :*-*:
e tenho uma pequena duvida, o que seria esse comando "return" dentro do if? obrigado :XD:
Então, (me intrometendo aqui, para te responder.) o "return" é um comando utilizado que encerra a função.
Utilizando o return, ao invés da função terminar no end. Ela ignora todos os comandos depois dele, e finaliza.
Como em:
def minha_funcao
for var in 0..10
return if var == 2
end
endNo código acima, a funcao "retorna" quando var for 2, e não chega nos valores 3 ou mais.
obs.: o return tem outras funções, mas o raizen deve falar disso depois.
Entendo... Obrigado pela explicação XD
Deu pra pegar a ideia, parece realmente útil.
class John
def tarefa_parte1
for a in 0..20
if a % 2
p a
a +=1
end
end
end
def tarefa_parte2
for b in 0..20
if b % 5 ==
p b
b +=1
end
end
end
end
resultado = John.new
resultado.tareta_parte1
resultado.tareta_parte2
Citação de: nomefausoJOHN online 27/07/2019 às 02:41
class John
def tarefa_parte1
for a in 0..20
if a % 2
p a
a +=1
end
end
end
def tarefa_parte2
for b in 0..20
if b % 5 ==
p b
b +=1
end
end
end
end
resultado = John.new
resultado.tareta_parte1
resultado.tareta_parte2
Boa! Tente fazer os outros mais complicados também depois! :ok:
A tarefa 2 está faltando algo, a 1 está quase 100% ok, você só não precisa disso
a +=1O for por padrão já soma 1 no ruby, ele é um while que tem essa soma imbutido nele.
De qualquer forma, está de parabéns, você está comendo código haha, umas 2h antes disso estava começando a aprender :o: , se tiver alguma dúvida só chamar!