1-criar um algoritmo que leia tres valores que some os dois primeiros e o resultado da soma seja multiplicado pelo terceiro , mostrar o resultado ao usuário

2- Criar um algoritmo que verifique se o numero inserido é positivo se for positivo deverá multiplicar-lo por 3 se não somar com 2.

3- fazer um algoritmo que leia os valores de um cubo e calcule a sua área e no fim mostrar resultado ao usuário.

4- fazer um algoritmo que verifique se o valor inserido pelo usuário é uma letra ou numero multiplicá-lo por 10.

5- fazer um algoritmo que leia dois valores  e verifique se a soma dos dois seja positivo, caso seja devera verificar se a soma é maior que 25, se for devera multiplicá-lo por 5, se não dividir por 10, se o numero for negativo devera checar se foi digitado mais que 3 vezes, se sim o programa deverá fechar se não pedir para digitar novamente.

atividades do dia 16.11.2010

1-

1 - Criar um algoritmo que leia uma variável e verificar se o numero é ímpar ou se o número é par.
2 - Criar o algoritmo que leia 3 valores e verifique se a soma for maior que 20 dividi por 2,se não for maior que 20 multiplique por 5.
3 - Fazer o algoritmo que leia os valores de um circulo e calcule a sua área pelo fim mostrar o resultado ao usuário.
4 - Fazer o algoritmo que leia 4 valores do resultado da soma 6 dividido por 6.

1-Criar algoritmo onde é necessário ler 2 valores serão somados e o terceiro multiplicado no final mostrar resultado.
2 -Fazer um algoritmo onde é necessário calcular a área de uma circunferencia se o resultado for maior que 10 escrever que a circunferencia é grande se não escreva que e é pequena.
3 -Fazer o algoritmo em que o usuário coloque a sua altura em caso ela seja maior que 1,80m escrever que ele é alto se não baixo.
4 -Fazer o algoritmo onde tenha 3 valores em cada um seja multiplicado por 6 no final mostrar o resultado.
5 -Construir o algoritmo onde tenha 5 valores cada um seja dividido por 3 e que no final mostre o resultado.

TAREFA SOBRE ALGORITMOS

TAREFA SOBRE ALGORITMOS

                                                      EXERCICIOS                        26/10/10
1-Construa um algoritmo que leia e escreve dois valores.
2-Faça um algoritmo que some dois valores e mostrem o resultado.
3-construir um algoritmo que some duas notas e multiplique por dois.
4-Criar um algoritmo que calcule a área de um triangulo e mostre o resultado.
5-Criar um algoritmo que o usuario coloque a idade e mostrar qual a idade dele.
                                         Respostas

Tipos De Algoritmos

A noção de algoritmo é central para toda a computação. A criação de algoritmos para resolver os problemas é uma das maiores dificuldades dos iniciantes em programação em computadores. Isto porque não existe um conjunto de regras, ou seja um algoritmo, que nos permita criar algoritmos. Caso isto fosse possível a função de criador de algoritmos desapareceria. Claro que existem linhas mestras e estruturas básicas, a partir das quais podemos criar algoritmos, mas a solução completa depende em grande parte do criador do algoritmo. Geralmente existem diversos algoritmos para resolver o mesmo problema, cada um segundo o ponto de vista do seu criador.
Um algoritmo opera sobre um conjunto de entradas (no caso do bolo, farinha ovos, fermento, etc.) de modo a gerar uma saída que seja útil (ou agradável) para o usuário (o bolo pronto). Um algoritmo tem cinco características importantes:

Finitude:

Um algoritmo deve sempre terminar após um número finito de passos.

Definição:

Cada passo de um algoritmo deve ser precisamente definido. As ações devem ser definidas rigorosamente e sem ambiguidades.

Entradas:

Um algoritmo deve ter zero ou mais entradas, isto é quantidades que são lhe são fornecidas antes do algoritmo iniciar.

Saídas:

Um algoritmo deve ter uma ou mais saídas, isto é quantidades que tem uma relação específica com as entradas.

Efetividade:

Um algoritmo deve ser efetivo. Isto significa que todas as operações devem ser suficientemente básicas de modo que possam ser em princípio executadas com precisão em um tempo finito por um humano usando papel e lápis.

É claro que todos nós sabemos construir algoritmos.
Se isto não fosse verdade, não conseguiríamos sair de casa pela manhã, ir ao trabalho, decidir qual o melhor caminho para chegar a um lugar, voltar para casa, etc. Para que tudo isto seja feito é necessário uma série de entradas do tipo: a que hora acordar, que hora sair de casa, qual o melhor meio de transporte, etc.
Um fator importante é que pode haver mais de um algoritmo para resolver um determinado problema. Por exemplo, para ir de casa até o trabalho, posso escolher diversos meios de transporte em função do preço, conforto, rapidez, etc. A escolha será feita em função do critério que melhor se adequar as nossas necessidades. Um exemplo de algoritmo pode ser as instruções que um professor passa aos seus alunos em uma academia de ginástica.
Um outro exemplo de algoritmo é o que resolve o seguinte problema. Considere cinco rãs estão posicionadas em seis casas.
Representação de Algoritmos
As formas mais comuns de representação de algoritmos são as seguintes: 

Linguagem Natural

Como ilustração de algoritmo em linguagem natural vamos considerar a receita abaixo. Por economia de texto e facilidade a receita não mostra as quantidades dos ingredientes (as entradas). Alguns mais maldosos dizem que o cozinheiro não quis divulgar o seu segredo.

Este algoritmo mais geral poderia ser descrito da seguinte maneira:

• Cálculo da área de um objeto retangular ou quadrado.
  • Medir a largura do objeto e anotar o resultado.
  • Medir o comprimento do objeto e anotar o resultado
  • Multiplicar o comprimento pela largura e anotar o resultado.
  • O valor da área e o resultado anotado no passo anterior.
• Fim do cálculo da área de um objeto retangular ou quadrado.

O algoritmo para cálculo da área da mesa e da toalha poderia ser reescrito de forma mais compacta com as seguintes instruções:

• Calcular a área da mesa usando o algoritmo acima.
• Calcular a área da toalha usando o mesmo algoritmo.

Observe que neste caso um mesmo algoritmo pode ser aplicado a diferentes objetos, reduzindo o número de algoritmos a serem definidos.
A maioria dos algoritmos contém decisões, por exemplo, para atravessar uma rua preciso verificar se o sinal de pedestres está verde e verificar se nenhum carro está avançando o sinal, somente após decidir se estes fatos se confirmaram poderei atravessar a rua.
Para considerar um algoritmo que inclua decisões vamos estudar um algoritmo que nos ajude a decidir o que fazer em um domingo. Um possível algoritmo poderia ser o seguinte:

• Algoritmo de domingo.
  • Acordar.
  • Tomar o café.
  • Se estiver sol vou à praia senão leio o jornal.
  • Almoçar.
  • Ir ao cinema.
  • Fazer uma refeição.
  • Ir dormir.
• Final do domingo.

A possibilidade de tomada de decisões é a característica mais importante de qualquer linguagem de programação. Ela permite que ao computador simular aproximadamente uma característica humana que é a escolha de opções. Sem esta característica o computador seria pouco mais do que uma veloz máquina de calcular.
Vamos agora considerar um exemplo um pouco mais matemático e estudar o algoritmo para calcular as raízes de uma equação do segundo grau da forma.

Fluxogramas

Esta forma de representação de algoritmos emprega várias formas geométricas para descrever cada uma das possíveis açoes durante a execução do algoritmos. Existem algumas formas geométricas que são empregadas normalmente e que estão mostradas na Figura abaixo. Cada uma destas formas se aplica a uma determinada ação como está indicado. Existem outras formas que podem ser aplicadas, no entanto nesta apostila estas formas serão suficientes para os exemplos que serão mostrados.

Como primeiro exemplo de um algoritmo descrito por meio de fluxogramas vamos considerar o exemplo do algoritmo para decidir o que fazer em um dia de domingo. A Figura a seguir mostra o fluxograma equivalente à descrição feita por meio da linguagem natural.

Outro exemplo de um algoritmo descrito por meio de fluxogramas é o problema de calcular a solução da equação de primeiro grau

ax+b=0

que vale

x=-(b/a)

se a for diferente de zero. A Figura abaixo mostra um possível algoritmo para resolver este problema.

 

Expressões

Uma vez que já temos os dados e as variáveis podemos passar ao próximo estágio que seria a criação de expressões. No entanto, para que a expressão possa estar completa precisamos de operadores que possam ser aplicados a estes dados. Os operadores da linguagem a-- são basicamente os mesmos encontrados em outras linguagens de programação.
Na linguagem a-- existem basicamente três tipos de expressões:

• Expressões Aritméticas;
• Expressões Lógicas;
• Expressões Literais.

Cada um deste tipos tem os seus operadores próprios.

---

Expressões Aritméticas

Expressões aritméticas são aquelas que apresentam como resultado um valor numérico que pode ser um número inteiro ou real, dependendo dos operandos e operadores.

Expressões Lógicas

Expressões lógicas são aquelas cujo resultado pode somente assumir os valores verdadeiro ou falso.

Comandos

Agora iremos apresentar uma série de definições informais dos comandos da linguagem a--.

---

• Lista de comandos:
  

  <lista de comandos>

  Uma seqüência de comandos válidos da linguagem. Em cada linha somente pode haver um comando. Veremos que em alguns casos especiais um comando pode se extender por mais de uma linha.

---

• Comando de atribuição:
  

  =

  A expressão do lado direito do operador é calculada e o seu resultado é atribuído à variável do lado esquerdo do sinal.

  Exemplos:

  a = 5.0 b = a + x - 3.0

---

• Leitura dos valores de entrada do algoritmo:
  

  ler <lista de variáveis>

  Uma lista de variáveis é uma lista de nomes de variáveis separadas por vírgula. Valores são lidos do teclado, um de cada vez e atribuídos as variáveis listadas na ordem em que aparecem na lista.

  Exemplos:

  ler nota1, nota2 ler a, b, c

---

• Impressão dos resultados dos algoritmos:
  

  imprimir <lista de expressões>

  Imprime os valores das saídas do algoritmo. Os valores das expressões são impressos, um de cada vez, na ordem em que aparecem na lista. Uma expressão pode ser uma variável ou uma expressão aritmética.

  Exemplo:

  imprimir media, nota1, nota2 imprimir x1, x2 imprimir a+b

  Textos explicativos

  É possível inserir textos explicativos entre as variáveis da lista, ou mesmo imprimir somente um texto explicativo para o usuário do programa. O texto deve estar entre ".

  Exemplo:

  imprimir "A media das notas foi", media, "nota 1", nota1, "nota 2", nota2 imprimir "Entre com o salário."

---

• Comando de repetição:
  

  enquanto <expressão lógica> faça

  <lista de comandos>

  fimenquanto

  Os comandos entre enquanto e fimenquanto são executados repetidamente enquanto a condição de teste for satisfeita; Exemplo:
  

  
  i=0
  enquanto i<10 faça
     imprimir i, i*i
     i=i+1
  fimenquanto
  
  

---

• Comando de teste (desvio)
  

  Se <expressão lógica> então

  <lista de comandos1>

  senão

  <lista de comandos2>

  fimse

  Testa se a expressão lógica é verdade. Caso seja verdade então executa a lista de comandos 1, senão executa a lista de comandos 2.

  Exemplo:
  

  se (i % 2) == 0 então
      imprimir "O número é par."
  senão
      imprimr "O número é ímpar."
  fimse
  

---

• Função
  

  - Funções são a base de toda a linguagem a--. Um programa é composto de funções. A primeira função a ser executada é obrigatoriamente chamada de principal. O que uma função executa está definido pela sua lista de comandos. A lista de parâmetros, é uma lista de variáveis contendo os valores que passamos para a função usar durante a sua execução. Funções recebem valores (parâmetros) e retornam resultados ao algoritmo que usou a função. Por exemplo, considere que existe a função seno(x) que calcule o seno de ângulo x, o algoritmo abaixo calcula o seno de ângulos entre 0 e 90 de 1 em 1 grau.

  
  principal()
  inicio
      ang = 0
      enquanto ang <= 90 faça
          imprimir ang, seno(ang)
   ang = ang + 1
      fimenquanto
  fim
  
  Os parâmetros que a função recebe são chamados de parâmetros de entrada. Caso a função precise retornar somente um valor ela pode usar o comando retornar expressão. Existem casos onde a função não precisa receber nenhum parâmetro nem retornar Por exemplo, considere o algoritmo abaixo em que dois valores são lidos na função principal em seguida uma funçào é chamada para calcular e imprimir a soma destes valores. 
  

  nome da função (<lista de parâmetros>)
  início

  <lista de comandos>

  fim

  Exemplo:
  

  
  principal ()
  inicio
      ler a
      ler b
      soma(a,b)
  fim
  soma (x,y)
  inicio
      imprimir "A soma vale ", x+y
  fim
  
  

  Neste exemplo o programa começa na função principal que lê os valores a e b. Em seguida o programa chama a função soma passando como parâmetros os valores das variáveis a e b. A função recebe estes valores e imprime a sua soma. No entanto, em muitos casos é necessário retornar mais de um valor e neste caso uma solução e usar o que chamaremos de parâmetro de entrada e saída. Este é um caso especial em que um parâmetro serve para transmitir valores para a função e para retornar um valor, caso necessário. Por exemplo, uma função que precise trocar os valores de duas variáveis de posição. Esta função recebe os valores em duas variáveis e retorna os valores trocados nestas mesmas duas variáveis.

Exemplos de Algoritmos

1. Algoritmo de Euclides
   Dados dois números positivos m e n encontre seu maior divisor comum, isto é o maior inteiro positivo que divide tanto m como n. Assuma que m é sempre maior que n, e n diferente de zero.
   • principal () início
     
     • ler m, n;
     • r = m % n; // resto da divisão de m por n
     • enquanto r != 0 faça
       
       • m = n;
       • n = r;
       • r = m % n;
     • fim do enquanto
     • imprimir n;
   • fim de principal
   Este algoritmo escrito em C pode ser visto no arquivo: au1ex1.c
   

   ---

2. Multiplicação de dois números inteiros positivos
   • principal () início// achar quanto vale m*n
     
     • ler m, n;
     • r = 0;
     • enquanto n != 0 faça
       
       • r = r + m;
       • n = n-1;
     • fim do enquanto
     • imprimr r;
   • fim de principal
   Este algoritmo escrito em C pode ser visto no arquivo: au1ex2.c
   

   ---

3. Resolução de uma equação do segundo grau.
   Neste algoritmo vamos assumir que o coeficiente a da equação é sempre diferente de 0.
   
   • principal () início
     
     • ler a, b, c
     • delta = b*b-4*a*c
     • se delta < 0
       
       • então
         • imprimir ¨Não há raizes reais.¨
       • senão início
         
         • x1 = (-b + sqrt(delta))/(2*a)
         • x2 = (-b + sqrt(delta))/(2*a)
         • imprimir x1, x2
     • fim de se
   • fim

 

Pseudo Linguagem

Este modo de representar algoritmos procura empregar uma linguagem que esteja o mais próximo possível de uma linguagem de programação de computadores de alto nível mas evitando de definir regras de construção gramatical muito rígidas. A idéia é usar as vantagens do emprego da linguagem natural, mas restringindo o escopo da linguagem. Normalmente estas linguagens são versões ultra reduzidas de linguagens de alto nível do tipo Pascal ou C. No próximo capítulo veremos um exemplo de uma destas pseudo-linguagens.

Para escrever estes exemplos de algoritmos usaremos uma pseudo linguagem de programação, que chamaremos de a--. Nesta linguagem definimos um número mínimo de comandos, o suficiente para descrever os algoritmos exemplos. Os dados não tem tipo definido, como em C e PASCAL. A linguagem como o C, que é utilizado no resto do programa é baseada em funções. Todos os algoritmos são descritos por funções, sendo que a função básica, e que deve existir sempre, pois ela é sempre a primeira a ser executada é a função principal.

Um exemplo simples da forma geral de um algoritmo em a-- é o seguinte:

principal ()
início
    imprimir "Alo mundo."
fim

O algoritmo começa com a funçào principal que é a funçào obrigatória em todos os algoritmos. Os parênteses após o nome primcipal são normalmente usados para delimitar a lista de argumentos, também chamados parâmetros que a função irá receber para executar a sua tarefa. Neste caso a função não está recebendo nenhum parâmetro. Esta algoritmo executa um único comando que imprime o texto "Alo mundo" em um dispositivo qualquer de saída de dados.

 

Tipos de Dados

Os algoritmos irão manipular dados, que normalmente são fornecidos pelos usuários, e entregar resultados para estes usuários. Uma pergunta importante neste momento é: que tipo de dados poderemos manipular? As linguagens de programação normalmente estabelecem regras precisas para definir que tipos de dados elas irão manipular. A pseudo-linguagem a-- também estabelece, ainda que informalmente, algumas regras que limitam o conjunto de dados existentes na natureza e que poderão ser manipulados pelos algoritmos.

Existem três tipos básicos de dados que a linguagem irá manipular:

• Dados numéricos
• Dados alfa-numéricos
• Dados Logicos

Dados Numéricos

Os dados numéricos que os algoritmos podem manipular são de dois tipos:

• Dados inteiros
• Dados reais
• exemplos de números inteiros:
  • +3
  • 3
  • -324

exemplos de números reais:

• 0.5
• +0.5
• -3.1415

Dados Alfa-numéricos

Dados alfa-numéricos servem para tratamento de textos e normalmente são compostos por uma seqüência de caracteres contendo letras, algarismos e caracteres de pontuação. Nos algoritmos são normalmente representados por uma seqüência de caracteres entre aspas, por exemplo:

• "Linguagem de programação"
• "Qual é o seu nome?"
• "12345"

Dados Lógicos

Este tipo de dados é intensamente aplicado durante o processo de tomada de decisões que o computador frequentemente é obrigado a fazer. Em muitos textos este tipo de dados também é chamado de dados booleanos, devido a George Boole, matemático que deu ao nome à álgebra (álgebra booleana) que manipula este tipo de dados. Os dados deste tipo somente podem assumir dois valores: verdadeiro e falso. Computadores tomam decisões, durante o processamento de um algoritmo, baseados nestes dois valores.

Variáveis

São os nomes que utilizamos para referenciar as posições de memória.Na introdução, a memória de um computador pode ser entendida como um conjunto ordenado e numerado de palavras.

Na linguagem a-- um nome de variável é contruído da seguinte maneira: uma letra seguida por um conjunto de letras ou algarismos. Por exemplo, os nomes seguintes são nomes de variáveis válidos:

• i
• valor
• nome
• nota1