Embedded Files
O Conceito de Programação
O Conceito de Programação
A programação é um processo de escrita, testes e manutenção de programas de computadores. Esses programas são compostos por conjuntos de instruções determinados pelo programador que descrevem tarefas a serem realizadas pela máquina e atendem diversas finalidades.
A programação é um processo de escrita, testes e manutenção de programas de computadores. Esses programas são compostos por conjuntos de instruções determinados pelo programador que descrevem tarefas a serem realizadas pela máquina e atendem diversas finalidades.
Hardwares
Hardwares
Um computador é uma máquina destinada ao processamento de dados. Ele é formado por componentes que convertem os sinais elétricos em informações. Esses componentes físicos são o monitor, teclado, mouse, CPU entre outros.
Esses componentes físicos são chamados de hardware e a sua linguagem binária, que é a linguagem de máquina, é composta apenas por bits, que são zeros e uns. O termo hardware se aplica à unidade central de processamento, à memória e aos dispositivos de entrada e saída. Os bits representam a ausência ou presença de sinais elétricos.
Softwares
Softwares
O software é o meio pelo qual a linguagem de máquina pode ser compilada ou interpretada, através de códigos criados em uma linguagem intermediária, convertendo assim para uma linguagem visual e amigável para o usuário.
A programação possibilita a existência dos softwares e, por consequência, a utilização mais prática dos hardwares. Para poder dar origem aos softwares, a programação ganha uma linguagem própria que compõe códigos escritos por programadores.
Introdução à Programação
Introdução à Programação
O conceito de algoritmo
Um algoritmo é uma sequência finita de ações executáveis que visam obter uma solução para um determinado tipo de problema. Alguns exemplos genéricos de algoritmos são: uma coreografia, um manual de instruções, uma receita culinária, técnicas para resolver problemas matemáticos, uma pesquisa na internet, dentre outros.
Torre de Hanoi
Um clássico problema que trabalha o desenvolvimento da lógica e do raciocínio matemático é a Torre de Hanói, inventado pelo matemático francês Édouard Lucas em 1883. O quebra-cabeça é composto por três hastes e vários discos de tamanhos diferentes, que podem deslizar para qualquer haste. O quebra-cabeça começa com os discos em uma pilha organizada em ordem crescente de tamanho em uma haste, a menor no topo, fazendo assim uma forma cônica.
Neste exemplo, toma-se o seguinte problema: tem-se três hastes. Umas das hastes serve de suporte para três discos. Deseja-se mover todos os discos para outra haste, porém deve-se movimentar um disco de cada vez e um disco maior nunca pode ser colocado sobre um disco de menor tamanho.
Como representar um algoritmo?
Um algoritmo pode ser visto como uma sequência de instruções ou operações que resolvem um dado problema. O passo-a-passo para resolver o problema da Torre de Hanoi pode ser considerado um algoritmo. Uma forma de representar tal algoritmo é através da forma textual ordenada:
Nomeiam-se as hastes como A, B e C e os discos como Vermelho, Verde e Azul. Considera-se que inicialmente os discos estão na haste A. Segue uma sequência de passos para a resolução do quebra-cabeça:
Move-se o disco Vermelho para a haste C;
Move-se o disco Verde para a haste B;
Move-se o disco Vermelho para a haste B;
Move-se o disco Azul para a haste C;
Move-se o disco Vermelho para a haste A;
Move-se o disco Verde para a haste C;
Move-se o disco Vermelho para a haste C.
Outras formas são mais apropriadas para o uso no meio computacional:
pseudo-código
fluxogramas
Para quem são os algoritmos?
Uma receita de bolo é apropriada para ser executada por um ser humano.; um procedimento de como trocar um pneu também. Mas muitas vezes queremos que o algoritmo seja executado por uma máquina. Assim, o computador é o mais adequado para a tarefa.
Nessa seção vamos nos concentrar no desenvolvimento de algoritmos simples, desde a sua concepção até a sua implementação (e depuração) através de uma LINGUAGEM DE PROGRAMAÇÃO - a linguagem C , por exemplo.
Um PROGRAMA implementa um algoritmo; é o algoritmo materializado na forma de uma sequência de instruções.
A descrição de algoritmos usando fluxogramas
Fluxograma é um tipo de diagrama, mostrando a representação esquemática de um algoritmo, muitas vezes feito através de gráficos que ilustram de forma descomplicada a transição de informações entre os elementos que o compõem, ou seja, é a sequência operacional do desenvolvimento de um processo. Os fluxogramas são muito utilizados em projetos de software para representar a lógica interna dos programas.
Abaixo segue o exemplo de um fluxograma para a troca de uma lâmpada.
Pontos fortes:
permite fácil entendimento do algoritmo, mesmo para pessoas leigas;
Ponto fraco:
a descrição das estrutura dos dados inexiste. O usuário deve descrevê-los a parte. Neste caso os dados
Simbologia de um fluxograma
Teste de mesa
O Teste de Mesa é um processo manual que é utilizado para validar a lógica de um determinado algoritmo. Ele é utilizado principalmente em algoritmos quando a linguagem utilizada não possui nenhuma ferramenta automatizada de depuração. Como as linguagens de programação costumam possuir tais ferramentas, é mais comum utilizá-las a fazer o teste de mesa propriamente dito, embora para quem ainda é iniciante, eu particularmente ainda recomendo utilizá-lo, visto que provavelmente não terá domínio sobre a ferramenta de depuração.
Como é possível aplicá-lo para fazer a verificação da lógica em um programa?
Não há uma forma canônica para a elaboração de um Teste de Mesa, pois dependerá muito do que pretende verificar no algoritmo e do seu nível de entendimento. No geral, você deverá criar no papel uma tabela com todas as variáveis do programa e executar passo a passo seu código, anotando sempre os valores das variáveis. Assim você será capaz de identificar se os valores condizem com o esperado ou localizar a exata linha de código onde o valor da variável passa a ficar errado.
Apresentamos abaixo um procedimento de quatro passos que descrevem a execução do Teste de Mesa:
Elaborar uma tabela onde cada coluna se refere a cada variável envolvida e o resultado de uma operação em particular (ou observação pertinente);
Executar os passos previstos no algoritmo;
Verificar se os resultados obtidos são coerentes com os previstos;
Encerrar o teste após um número razoável de resultados corretos obtidos;
Ou seja, identifique todas as variáveis do seu programa e verifique os valores das mesmas a cada linha de código executada.
Qual é o passo a passo para efetuar o Teste de Mesa?
Como dito, não há uma sequências de passos definitiva, mas as que eu costumo seguir e que sempre tiveram uma boa aceitação por iniciantes em programação é:
Identifique todas as variáveis no seu programa;
Crie uma tabela onde a primeira coluna se chama "Passo", a segunda de chama "Linha". A partir disto, crie uma coluna para cada variável do programa;
Na primeira linha da tabela, preencha a coluna "Passo" com "Início", pode deixar a coluna "Linha" em branco e preencha cada coluna das variáveis com os respectivos valores iniciais;
Percorra seu código linha a linha, preenchendo a tabela. A coluna "Passo" deverá ser incrementada a cada nova linha na tabela; a coluna "Linha" deve indicar o número da linha no código que está sendo analisada e em cada coluna das variáveis deve constar o respectivo valor para cada variável após a linha de código ser executada;
Execute o passo 4 até o programa finalizar;
Exemplo de um Teste de Mesa
Exemplo de um Teste de Mesa
Por exemplo, vamos considerar um programa que praticamente todos os iniciantes fazem no início dos estudos: cálculo do fatorial. Um algoritmo para pseudocódigo de cálculo do fatorial é:
1 numero <- 0;
2 resultado <- 1;
3
4 leia(numero);
5
6 se (numero < 0) então
7 imprima("O número não pode ser negativo");
8 senão
9 enquanto (numero > 0) faça
10 resultado <- resultado * numero;
11 numero <- numero - 1;
12 fim
13
14 imprima("O fatorial de vale", resultado);
15 fim
Passo 1: Identificar todas as variáveis do programa;
As variáveis do programa são numero, que receberá o valor do qual desejamos calcular o fatorial, e resultado, que armazenará o resultado do cálculo.
Passo 2: Criar a tabela;
Lembrando que a primeira coluna se chama "Passo", a segunda "Linha" e as outras representam as variáveis do programa.
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| | | | |
+-----------+-----------+------------+------------+
Passo 3: Preencher a primeira linha da tabela;
Na coluna "Passo" coloque "Início", na coluna "Linha" não precisa valor e nas colunas das variáveis os valores iniciais de cada.
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
Passo 4: Percorrer cada linha do programa, preenchendo a tabela;
As linhas de definição das variáveis já foram consideradas no passo 3, quando já preenchemos a tabela com os valores iniciais. Portanto, começamos analisar o programa a partir da linha 4. Vamos supor que desejamos calcular o fatorial de 3, portanto, quando a função leia(numero) solicitar ao usuário um número, ele entrará com o valor 3, sendo armazenado na variável numero. A variável resultado não varia, então mantemos o seu valor.
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
Na linha 6 é verificado se o valor entrado pelo usuário é menor do que zero. Como 3 é maior que zero, a condição é falsa e, assim, pulamos para a linha 8. Na linha 9, criamos um laço de repetição que durará enquanto o valor de numero for maior que zero. Neste momento o valor é 3 (veja a tabela acima), então devemos executar o laço, partindo para a linha 10. Nesta linha, o valor de resultado é atualizado para o valor resultado*numero, ou seja, o novo valor de resultado será o valor atual multiplicado pelo valor de numero. Então:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
Naturalmente passamos para a linha 11, onde o valor de numero passa a ser o seu valor atual decrementado em uma unidade, então:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
| 3 | 11 | 3-1=2 | 3 |
+-----------+-----------+------------+------------+
Terminado o código dentro do laço de repetição devemos voltar a linha 9 e verificar novamente a condição para determinar se o laço de repetição deve continuar ou não. Neste momento, numero vale 2 e, portanto, ainda é maior que 0, então partimos para a linha 10 novamente. O valor de resultado será o atual multiplicado pelo valor de numero, então:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
| 3 | 11 | 3-1=2 | 3 |
+-----------+-----------+------------+------------+
| 4 | 10 | 2 | 3*2=6 |
+-----------+-----------+------------+------------+
Na linha 11, novamente o valor de numero receberá o valor atual decrementado em uma unidade, então:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
| 3 | 11 | 3-1=2 | 3 |
+-----------+-----------+------------+------------+
| 4 | 10 | 2 | 3*2=6 |
+-----------+-----------+------------+------------+
| 5 | 11 | 2-1=1 | 6 |
+-----------+-----------+------------+------------+
Voltamos para a linha 9, analisando novamente a condição do laço. Como 1 ainda é maior que zero, então passamos para a linha 10, onde novamente o valor de resultado será modificado:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
| 3 | 11 | 3-1=2 | 3 |
+-----------+-----------+------------+------------+
| 4 | 10 | 2 | 3*2=6 |
+-----------+-----------+------------+------------+
| 5 | 11 | 2-1=1 | 6 |
+-----------+-----------+------------+------------+
| 6 | 10 | 1 | 6*1=6 |
+-----------+-----------+------------+------------+
E na linha 11 o valor de numero será atualizado:
+-----------+-----------+------------+------------+
| Passo | Linha | numero | resultado |
+-----------+-----------+------------+------------+
| Início | - | 0 | 1 |
+-----------+-----------+------------+------------+
| 1 | 4 | 3 | 1 |
+-----------+-----------+------------+------------+
| 2 | 10 | 3 | 1*3=3 |
+-----------+-----------+------------+------------+
| 3 | 11 | 3-1=2 | 3 |
+-----------+-----------+------------+------------+
| 4 | 10 | 2 | 3*2=6 |
+-----------+-----------+------------+------------+
| 5 | 11 | 2-1=1 | 6 |
+-----------+-----------+------------+------------+
| 6 | 10 | 1 | 6*1=6 |
+-----------+-----------+------------+------------+
| 7 | 11 | 1-1=0 | 6 |
+-----------+-----------+------------+------------+
Após, voltamos a linha 9 para verificar novamente a condição do laço, mas agora o valor de numero é 0 e não satisfaz a condição de ser maior que zero, portanto passamos para a linha 14, onde é exibida a mensagem "o fatorial vale 6", pois o valor atual de resultado é 6.
Constantes, variáveis e expressões
Continua...
Representando o algoritmo como pseudo-código
Continua...
Representando o algoritmo em linguagem C
Continua...
Linguagem de Programação
Linguagem de Programação
A linguagem de programação padroniza a comunicação de instruções dadas a um computador. Existem centenas de linguagens de programação, e cada uma apresenta diferenças, vantagens e desvantagens, e permitem que o programador defina sobre quais dados o computador atuará, como armazenar e transmitir esses dados e quais ações tomar sob variadas circunstâncias. Abaixo, vamos nos aprofundar em algumas das mais famosas linguagens de programação.
A linguagem de programação padroniza a comunicação de instruções dadas a um computador. Existem centenas de linguagens de programação, e cada uma apresenta diferenças, vantagens e desvantagens, e permitem que o programador defina sobre quais dados o computador atuará, como armazenar e transmitir esses dados e quais ações tomar sob variadas circunstâncias. Abaixo, vamos nos aprofundar em algumas das mais famosas linguagens de programação.
Page updated
Google Sites
Report abuse