[Ruby] Aula 5 - Estruturas de Repetição

[Raizen]

[box class=windowbg1]

Índice das aulas básicas

• Aula 1 - Introdução
  
• Aula 2 - Objetos
  
• Aula 3 - Operações
  
• Aula 4 - Condições
  
• Aula 5 - Repetição
  
• Aula 6 - Arrays
  
• Aula 7 - Hashes
  [/box]
  [box class=windowbg1]
  Índice das aulas avançadas
• Aula 8 - Superclasses e instâncias
  [/box]
  [box class=windowbg1]
  Índice das aulas de algoritmos
• Aula 1 - Sort
  
• Aula 2 - Busca
  
• Aula 3 - 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.
  

[NetinhoMaker]

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

[close]

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

[Lincoln]

Ó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

[close]

[Ryugo]

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

[close]

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

[close]

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)

[close]

Gostaria de quem puder me ajudar nesses dois últimos,agradeceria muito.Agora que comecei tenho que conseguir terminar 


Provavelmente amanhã tento fazer a outra tarefa dificil. Té 

[Raizen]

@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

[close]

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.

[Ryugo]

Spoiler

@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

[close]

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.

[close]

Nossa,muito obrigado pelos dois super comentários que você fez pra me explicar tudo 

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 


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

[close]

Agora,esse difícil ta me matando  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:

[close]

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 
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é

[Keilo104]

*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

[Lincoln]

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

[close]

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)

[close]

não consegui fazer os avançados, mas tentei, perdão ç-ç

[Linksplays]

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. 
Então avante a aula 6 

[iJackBoy]

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

[Raizen]

kk, serve manolo!

Mas tente fazer os outros também, que são os mais utilizados, o while e for :)

[RedBit]

Este código funciona?

5.times {print "Hello World!"}

[Nunnu]

@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

[close]

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

[close]

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)

[close]

[Akugam]

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

[close]

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

[close]

só os intermediários por enquanto, mas ja to tentando fazer os mais difíceis XD

[Raizen]

Está tudo certo 

Faça sim os mais difíceis, eles ajudam muito na lógica de programação.