Ayron Matos

mas eu acredito que o problema tá no arquivo mp3 com uma interrogação, tá diferente do que o professor fez na vídeo-aula, como resolvo?

Eu estou fazendo o curso de python no site curso em vídeo e em uns dos exercícios é pedido pra tocar uma música usando o módulo pygame. executei as etapas como a aula mais o arquivo mp3 aderido no meu pycham ficou com uma interrogação. como faço para o código ser executado com a música?

 

Quando executado aparece isso aqui:

mas n sai som e já testei tá saindo normal tô assistindo vídeo no youtube e tudo.

 

 

 

valor := 10,128 

Parte Inteira ---------------> 10

Parte Flutuante ---------->  0,128

 

10 = 1 x 2³ + 0 x 2² + 1 x 2 + 0 x 1 logo, 1010

//2^-3 = 0,125 2^-7 =0,003(90625 - vai ser desprezada)

0,128 = 0 x 2 ^ -1 + 0 x 2 ^ -2 + 1 x 2 ^ -3 + 0 x 2 ^-4 + 0 x 2 ^ -5 + 0 x 2 ^ -6 + 1 x 2 ^ -7 logo, .0010001

 

Então: 1010.0010001 

Ponto Flutuante: 10100010001.2^4

//Acho que era isso que ele queria 

 

ah tá kk sou burro 

Agora, esquecendo o problema que terei que resolver com meu professor. Com relação a terceira etapa do "LINK" que foi passado minha dúvida é com relação a uma parte particular dela:

por que o número 4 + 127 + 131 resultou em 10000011?

de onde surgiu o valor 131?

 

Etapa 1º

 

10.128/2 = 5,064

5,064/2 = 2,532

2,532/2 = 1,266

-------------------------

1,266 x 2³

 

Etapa 2º

 

1,266 --------parte flutuante-----------> 0,266

 

0,266 x 2 = 0,532

0,532 x 2 = 1,064

0,064 x 2 = 0,128                              

0,128 x 2 = 0,256

0,256 x 2 = 0,512

0,512 x 2 = 1,024

0,024 x 2 = 0,048

0,048 x 2 = 0,096 

0,096 x 2 = 0,192

0,192 x 2 = 0,384

0,384 x 2 = 0,768

0,768 x 2 = 1,536

0,536 x 2 = 0,072

0,072 x 2 = 0,144

0,144 x 2 = 0,288

0,288 x 2 = 0,576

0,576 x 2 = 1,152

0,152 x 2 = 0,304

0,304 x 2 = 0,608

0,608 x 2 = 1,216

0,216 x 2 = 0,432

0,432 x 2 = 0,864

0,864 x 2 = 1,728

0,728 x 2 = 1,456

0,456 x 2 = 0,912

0,912 x 2 = 1,824

0,824 x 2 = 0,648

0,648 x 2 = 1,296

0,296 x 2 = 0,592

0,592 x 2 = 0,184

0,184 x 2 = 0,368

0,368 x 2 = 0,736

0,736 x 2 = 1,472

0,472 x 2 = 0,944
0,944 x 2 = 1,888
0,888 x 2 = 1,776
0,776 x 2 = 1,552
0,552 x 2 = 0,104
0,104 x 2 = 0,208
0,208 x 2 = 0,416
0,416 x 2 = 0,832
0.832 x 2 = 1,664
0,664 x 2 = 1,328
0,328 x 2 = 0,656
0,656 x 2 = 1,312
      ...          0.624
                   1.248
                   0.496
                   0.992
                   1.984
                   1.968
                   1.936
                   1.872
                   1.744
                   1.488
                   0.976
                   1.952
                   1.904
                   1.808
                   1.616
                   1.232
                   0.464
                   0.928
                   1.856
                   1.712
                   1.424
                   0.848
                   1.696
                   1.392
                   0.784
                   1.568
                   1.136
                   0.272
                   0.544
                   1.088
                   0.176
                   0.352
                   0.704
                   1.408
                   0.816
                   1.632
                   1.264
                   0.528
                   1.056
                   0.112
                   0.224
                   0.448
                   0.896
                   1.792
                   1.584
                   1.168
                   0.336
                   0.672
                   1.344
                   0.688
                   1.376
                   0.750
                   1.500
                   1.000 (Acabou)

 

Problema: primeiro eu tentei fazer manualmente, depois vi que não tinha jeito. Depois fui usar o visualg porque tô acostumado daí chega uma hora que ele arredonda loucamente como na parte que eu deixei em vermelho deveria dar 0,752. O que faço?

algoritmo "numero binário"
// Função :
// Autor :
// Data : 13/07/2018
// Seção de Declarações 
var
   res,contador: Real
inicio
res <- 0.266
Enquanto res<>0 faca
res <- res*2
EscrevaL(res:5:3)
Se res >= 1 então
res <- res - 1
FimSe
FimEnquanto
fimalgoritmo

 

10.128/2 = 5,064

5.064/2 = 2,532

2,532/2 = 1,266

-------------------------

1,266 x 2³

como eu coloco na base 2?

Exercício 1 - Seja o número real x = 10.128 (representação decimal). Escreva sua representação em ponto flutuante, com cinco dígitos, na base 2.

haha nem lembrava mais, mas essa era parte mais difícil me ajuda em um tópico novo que postei por favor

Este é o desafio. Meu problema é com o comando Repita do Visualg, pois quando tento executar o código aparece as seguintes notificações:

 

o código segue abaixo

algoritmo "QUADRADO MÁGICO"
// Função :criador de quadrado mágico de ordem 7
// Autor : Ayron Gabryew Dias da Costa Matos
// Data : 10/07/2018
// Seção de Declarações 
procedimento MOSTRARPAINEL()
inicio
             EscrevaL(" =============================")
             EscrevaL("| CRIADOR DE QUADRADO MÁGICO  |")
             EscrevaL("| [ 1 ] inverta a matriz      |")
             EscrevaL("| [ 2 ] rotac. a matriz       |")
             EscrevaL("| [ 3 ] sair                  |")
             EscrevaL(" =============================")
fimprocedimento
procedimento INVERSOR()
inicio
      LimpaTela
      Para i := 1 ate 4 faca
           Para j := 1 ate 7 faca
                 c <-8-i
                 Se (i=j) então
                    aux <- m[i,j]
                    m[i,j] <- m[c,c]
                    m[c,c] <- aux
                 FimSe
                 Se (j=c) então
                     aux <- m[i,j]
                     m[i,j] <- m[j,i]
                     m[j,i] <- aux
                 FimSe
           FimPara
      FimPara
      Para i := 1 ate 7 faca
           Para j := 1 ate 7 faca
                Escreva(m[i,j]:4)
           FimPara
           EscrevaL()
      FimPara
fimprocedimento
procedimento ROTACIONADOR()
inicio
      LimpaTela
      Para j := 1 ate 6 faca
           c <- j+1
           m[1,c] <- m[1,j]
      FimPara
      Para i := 7 ate 2 passo -1 faca
           c <- i-1
           m[c,1] <- m[i,1]
      FimPara
      Para j:= 7 ate 2 passo -1 faca
           c <- j-1
           m[7,c] <- m[7,j]
      FimPara
      Para i := 3 ate 6 faca
           c <- i+1
           m[c,7] <- m[i,7]
      FimPara
      m[3,7] <- 14
      Para i := 1 ate 7 faca
           Para j:= 1 ate 7 faca
                Escreva(m[i,j]:4)
           FimPara
           EscrevaL()
      FimPara
fimprocedimento
var
   m: vetor[1..7, 1..7] de inteiro
   i,j,c,aux,somador, opcao,resp: inteiro
inicio
      Para i := 1 ate 7 faca
           Para j := 1 ate 7 faca
                somador <- somador + 1
                m[i,j] <- somador
           FimPara
      FimPara
      LimpaTela
      Repita
            MOSTRARPAINEL()
            Escolha opcao
            CASO 1
                 INVERSOR()
            CASO 2
                 ROTACIONADOR()
            CASO 3
                 Escreva("Programa finalizado com sucesso!")
            Outrocaso
                 Escreva("opcao inválida")
      ATE opcao=3
fimalgoritmo

 

Código finalizado 

algoritmo "triangulador"
// Função : divide uma matriz em setores
// Autor : Ayron Gabryew Dias da Costa Matos
// Data : 10/07/2018
// Seção de Declarações 
var
   m: vetor[1..6, 1..6] de inteiro
   c,d,i,j: inteiro
inicio
      Para i := 1 ate 6 faca
           Para j := 1 ate 6 faca
                Leia(m[i,j])
           FimPara
      FimPara
      LimpaTela
      Para i := 2 ate 3 faca
           Para j := 1 ate 6 faca
                c <- 7-i
                d <- i-1
                Se (j>c) ou (j<=d) então
                   Escreva(m[i,j]:5)
                senao
                   Escreva("     ")
                FimSe
           FimPara
           EscrevaL()
      FimPara
      Para i := 4 ate 5 faca
           Para j := 1 ate 6 faca
                c <- 7-i
                Se (j<c) ou (j>i) então
                   Escreva(m[i,j]:5)
                senao
                   Escreva("     ")
                FimSe
           FimPara
           EscrevaL()
      FimPara

 

Exercício 6

Escrever um algoritmo que lê uma matriz M(6,6) e calcula as somas das partes hachuradas. Escrever
a matriz M e as somas calculadas.

 

(uma série de imagens para criar no algoritmo)

 

uma em especial que eu chamei de TrianguloOesteLeste (que é a que eu estou com dúvida).

imagem segue em anexo.

 

 

 

 

 

 

 

 

 

Não sei se essa é a forma mais eficiente. O que eu pensei foi em dividir em duas condicionais simétricas: a parte superior e a parte inferior. O que eu fiz foi apenas iniciar mas estou com dúvida em como deixar o espaço correto e como fazer ele escrever do lado leste.

 

o que eu fiz segue abaixo:

procedimento TrianguloLesteOeste()
var t: inteiro
inicio
      Para i <- 2 ate 5 faca
        Para j <- 1 ate 6 faca
          Se (j < 4) e (i > j) então
            Escreva(M[i,j]:20)
          FimSe
        FimPara
          EscrevaL()
      FimPara
fimprocedimento

 

 

Algoritmo de número primo específico:

algoritmo "Primo"

var
   n, i, divisor: inteiro
inicio
      Leia(n)
      LimpaTela
      Para i <-1 ate n faca
       Se (n%i=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
      Se (divisor=2) então
         Escreva(n, " é um número primo.")
      SeNao
         Escreva(n, " não é um número primo.")
      FimSe
fimalgoritmo

 

Algoritmo dos números primos de 100 a 200:

algoritmo "Primosde100a200"

var
   i,j, divisor: inteiro
inicio
     Para i <- 100 ate 200 faca
        divisor <- 0
      Para j <-1 ate i faca
       Se (i%j=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
       Se (divisor=2) então
         Escreva(i)
       FimSe
     FimPara

fimalgoritmo

 

Consegui!

algoritmo "10PrimeirosPrimosDepoisde100"

var
   primo: vetor[1..10] de inteiro
   c, i, j, divisor: inteiro
inicio
     i <- 100
     c <- 0
     Repita
     i <- i + 1
        divisor <- 0
      Para j <-1 ate i faca
       Se (i%j=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
       Se (divisor=2) então
         c <- c + 1
         primo[c] <- i
         Escreva(primo[c])
       FimSe
     Ate (c = 10)

Muito obrigado!

@Simon Viegas eu acho que não fiz exatamente como a questão queria mas pelo menos consegui chegar no mesmo resultado. A sintaxe segue abaixo:

algoritmo "10PrimeirosPrimosDepoisde100"
 
var
   primo: vetor[101..149] de inteiro
   c, divisor: inteiro
inicio
      Para c <- 101 ate 149 faca
        divisor <- 0
        Se (c%2=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%3=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%5=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%11=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%12=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%c=0) então
          divisor <- divisor + 1
        FimSe
        Se (divisor=1) então
          primo[c] <- c
          Escreva(primo[c]:4)
        FimSe
      FimPara

fimalgoritmo

 

Exercício 6

Escreva um algoritmo que gera os 10 primeiros números primos acima de 100 e os armazena em um

vetor X(10) escrevendo, no final, o vetor X.

algoritmo "10PrimeirosPrimos"

var
   primo: vetor[1..10] de inteiro
   c, div, i, j: inteiro
inicio
    Para j <- 1 ate 10 faca
      Para c <- 1 ate 149 faca
          div <- 0
        Para i <- 1 ate 149 faca
          Se (c%i=0) então
            div <- div + 1
          FimSe
        FimPara
          Se (div = 2) e (c > 100) então
            primo[j] <- c
          FimSe
      FimPara
    FimPara
      
      Para j <- 1 ate 10 faca
        Escreva(primo[j]:4)

fimalgoritmo

O visualg não informa qual o problema mas eu suponho que seja as variaveis..

Entendi perfeitamente, muito obrigado!

4) Faça um algoritmo que gere uma tabela com os números de 1 a 10 e mostre o seu quadrado, cubo,
    fatorial, número de divisores e uma mensagem dizendo se o número é primo ou não. A cada 20 linhas
    deve ser escrito o cabeçalho novamente:

algoritmo "Tabelade1ate10"
var
   i, r, x, j: inteiro
   q, c: real
funcao fatorial(b:inteiro):inteiro
var f, t: inteiro
inicio
      f <- 1
      Se (b = 1) então
        Retorne 1
      SeNao
        Para t <- 1 ate b-1 faca
          f <- f*t
        FimPara
        Retorne f
      FimSe
fimfuncao
funcao divisores(b:inteiro):inteiro
var div, l: inteiro
inicio
        Para l <- 1 ate b faca
          Se (b%l=0) então
           div <- div + 1
          FimSe
        FimPara
        Retorne div
fimfuncao
funcao primo(b:inteiro):inteiro
var div, l: inteiro
inicio
      Para l <-1 ate b faca
        Se (b%l=0) então
          div <- div + 1
        FimSe
      FimPara
        Se (div = 2) então
        Retorne "sim"
        SeNao
        Retorne "nao"
        FimSe
fimfuncao
inicio
      Escreva("Número   Quadrado   Cubo   Fatorial   Divisores   Primo")
      Para i <- 1 ate 10 faca
        q <- i^2
        c <- i^3
         r <- fatorial()
         x <- divisores()
         z <- primo()
        Escreva(i, q:7, c:8, r:4, x:6, z:10)
      FimPara
fimalgoritmo

 

Ele finaliza no início da função <fatorial()> e eu não sei por quê... gostaria de entender onde estou errando.

obs: desconsiderei a repetição a cada 20 linhas. Achei desnecessário.