sexta-feira, 10 de março de 2017

Sequencia Fibonacci - Algoritmo Simples no Visualg


A sequencia fibonacci (0 1 1 2 3 5 8 13 21 34 55 89 144 233 ...) é uma sequencia onde pode se observar que o novo numero é resultado da soma dos dois anteriores. A implementação desse algoritmo é muito cobrada no inicio da disciplina de algoritmos  e como quase sempre o software e a linguagem usada nesse contexto é o visualg. Esta é uma das varias maneiras de codificar a sequencia Fibonacci na linguagem de pseudocódigo do visualg, porém acredito que esta é bem simples, pois há algumas que usam recursividade ou um método para calcular. Enfim:

algoritmo "Fibonacci1"
// Função :Calcular os 10 primeiros termos da sequencia Fibonacci
// Autor : Eliel
// Data : 18/08/2016
// Seção de Declarações
var
anterior, atual, proximo, i :inteiro

inicio
// Seção de Comandos
anterior <- 0
atual <- 0
proximo <- 1

escreval("Sequencia de Fibonacci com 10 primeiros numeros:")
escreva(atual)      //exibindo o primeiro termo ( o zero)
para i de 1 ate 9 faca        //exibindo os noves termos restantes
     escreva(proximo)
     anterior := atual
     atual := proximo
     proximo := atual + anterior

fimpara
fimalgoritmo


Algoritmo Numero Primo (Visualg)

Na lista de exercícios da disciplina de algoritmo tem a seguinte questão:
Fazer um programa que leia um numero digitado pelo usuário e exibir uma mensagem informando se o numero digitado é primo ou não.
Bem, números primos são aqueles que são divisíveis somente por ele mesmo e por um, a partir dessa afirmação já podemos formular algumas perguntas para montar a lógica da questão: Como saber se um numero é divisível por ele mesmo e por um? Como saber se ele não divisível pelos demais números? Uma das formas de se responder a essas perguntas seria pegar esse numero e dividi-lo por ele mesmo e depois por todos os números antecessores a ele até chegar a um (ou começar do um até chegar ao numero). Dessa forma podemos ver todos os divisores desse numero (aqueles números os quais a divisão não deixa resto) e depois contá los, como o numero primo só tem como divisor ele mesmo e um, então se o numero tiver somente dois divisores ele é primo, se tiver mais de dois, não é primo. No visualg ficou assim:

algoritmo "NumerosPrimos"
// Função : Verificar se um numero é primo ou não.
// Autor : Eliel
// Data : 09/03/2017
// Seção de Declarações
var
numero, i, cont :inteiro
inicio
escreval("digite um numero: ")
leia(numero)

para i de 1 ate numero faca
     se numero mod  i = 0 entao
        cont <- cont+1
     fimse
     i <- i+1
fimpara

se cont = 2 entao
   escreval("o numero", numero," e primo!")
senao
   escreval("o numero", numero," NAO e primo!")
fimse
fimalgoritmo

Nesse algoritmo foi usada a variável 'i' para representar os números antecessores do numero digitado e a variavel 'cont' para contar o numero de divisores do numero digitado. Esse algoritmo pode ser melhorado, de forma que mostre quais são os divisores do numero digitado:

algoritmo "NumerosPrimos"
// Função : Verificar se um numero é primo ou não.
// Autor : Eliel
// Data : 09/03/2017
// Seção de Declarações
var
numero, i, cont :inteiro
inicio
escreval("digite um numero: ")
leia(numero)

escreval("os divisores do numero ",numero," sao: ") // apresentar os divisores

para i de 1 ate numero faca
     se numero mod i = 0 entao
        escreva(" ",i)            // exibir na tela os divisores
        cont <- cont+1
     fimse
     i <- i+1
fimpara

escreval()   // pular
se cont = 2 entao
   escreval("o numero", numero," e primo!")
senao
   escreval("o numero", numero," NAO e primo!")
fimse
fimalgoritmo

Esse algoritmo roda bem com números não muito grandes, porém se o usuário digitar, por exemplo, 12000 ou um numero maior o visualg já demora um pouco para executar, isso por que no loop (comando para) vai ser executado um numero maior de passos, um custo maior de processamento. Então um possível solução seria diminuir o numero de antecessores, pois se o usuário digitar 12000, será feita 12000 divisões, mas dentro do intervalo de 1 a 10 podemos dividir todos o números "grande" por todos os números do intervalo para encontrar alguns divisores, mas se for encontrado apenas um divisor, o numero 1, então esse numero "grande" é um numero primo, mas isso é só um "jeitinho" que funcionou com alguns números:

algoritmo "NumerosPrimos"
// Função : Verificar se um numero é primo ou não.
// Autor : Eliel
// Data : 09/03/2017
// Seção de Declarações
var
numero, i, cont :inteiro
inicio
escreval("digite um numero: ")
leia(numero)
se numero = 1 entao
   escreval("o numero ",numero," NAO e primo!")
senao
    escreval("os divisores do numero ",numero," sao: ")
    se numero <= 10 entao  // se o numero for ate 10 divide pelos antecessores:
       para i de 1 ate numero faca
          se numero mod i = 0 entao
             escreva(" ",i)
             cont <- cont+1
          fimse
          i <- i+1
       fimpara
    senao      // sefor maior que 10 divide pelos antecessores de 1 a 10:
       para i de 1 ate 10 faca
          se numero mod i = 0 entao
             escreva(" ",i)   // só deve achar um divisor: o numero 1
             cont <- cont+1    // cont vai ter valor 1
          fimse
          i <- i+1
       fimpara
       cont <- cont+1    // aumentar para poder exibir a mensagem
       escreva(numero)   // para exibir o próprio numero depois do 1
    fimse
    escreval()      // pula um linha

    se cont = 2 entao
       escreval("o numero", numero," e primo!")
    senao
       escreval("o numero", numero," NAO e primo!")
    fimse
fimse
fimalgoritmo

terça-feira, 11 de março de 2014

Instalando Netbeans (7.4) no Linux Ubuntu

Entre na página do Netbeans e faça o download da versão que melhor se enquadra a seu caso: netbeans.org/downloads/

Após ter feito o download do arquivo abra uma janela do terminal no Ubuntu, mas você precisa estar logado como administrador para prosseguir; lembre se de que se você não tiver privilegios de administrador (root) deverá usar o comando "sudo" antes de cada comando;

Para poder executar o arquivo do netbeans que vocẽ baixou é preciso estar com o terminal aberto dentro da pasta onde está localizado este arquivo, no meu caso está na pasta "downloads" mesmo;

Então você pode digitar um "ls" no terminal para listar as pastas e ver se a pasta que você baixou o arquivo está em uma delas, caso positivo digite "cd" mais o nome da pasta. No meu caso foi simples: cd Downloads;

confira na imagem abaixo:


Agora temos que "autorizar" para que se torne executavel o arquivo, digitamos o comando "chmod" mais o comando "+x" mais o nome do arquivo baixado no meu caso foi o "netbeans-7.4-linux.sh" e a linha de comando eu digitei:
"chmod +x netbeans-7.4-linux.sh"

 

Já autorizado é só executar, digitando "./" junto com o nome do arquivo, no meu caso:
"./netbeans-7.4-linux.sh"

A partir daí a instalação já é automatica, e assim como no windows é so ir clicando em next até completar o processo. Pronto é isso!


Claro que assim como no windows antes de instalar qualquer compilador para programar em java você precisa instalar o JDK.

sábado, 21 de maio de 2011

Algoritmo Fibonacci no Visualg

Encontrei na internet outras formas de fazer esse algoritmo, mas nenhum no visualg que fosse simples de entender, então fiz esse usando estruturas bem básicas:


algoritmo "AlgoritmoFibonacci"
// Função :Exibir na tela os n primeiros numeros da cadeia Fibonacci
// Autor : Bentes
// Data : 21/5/2011
// Seção de Declarações
var
cont, n, num, atual, ant : inteiro
inicio
// Seção de Comandos


cont <- 0       //atribuindo valor ao contador

escreval ("Quantos numeros da cadeia fibonacci deseja ver?")
escreval ("Digite um numero maior que zero!")
leia (n)

se n <=0 entao

escreval ("Numero Inválido!!!")
senao

   se (n=1) entao

      escreval ("")  //linha em branco
      escreval ("O primeiro numero da cadeia Fibonacci: ") //o primeiro n° da cadeia
      escreval ("0 ")
   senao
      escreval ("")  //linha em branco
      escreval ("Os",n," primeiros numeros da cadeia Fibonacci: ")
      se n=2 entao

      escreval ("0 - 1 ")   // os dois primeiros n°s da cadeia!

      senao


         escreva ("0 - 1  ")

         atual <- 1
         ant <- 0
         repita
            num <- atual + ant  // o numero da vez é igual ao atual + o anterior!
            escreva ("- ", num, "  ")
            ant <- atual
            atual <- num
            cont <- cont + 1
         ate (cont = n-2)  // os dois primeiros n°s já foram impressos!
      fimse
   fimse
fimse
escreval ("")    //linha em branco
fimalgoritmo