ATPS Algoritmos e programação. etapa 1 e 2.

Prévia do material em texto

`
FACULDADE ANHANGUERA EDUCACIONAL
ENGENHARIA PRODUÇÃO MECÂNICA (1ºA, 2ªsemestre)
ATIVIDADES PRÁTICAS SUPERVISIONADAS
- ALGORITMOS E PROGRAMAÇÃO -
Taubaté
2014
ATIVIDADES PRÁTICAS SUPERVISIONADAS
- ALGORITMOS E PROGRAMAÇÃO -
	NOME
	R.A.
	SÉRIE
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
Trabalho da Disciplina de Algoritmo e Programação
 Prof. Marcelo.
Taubaté
2014
SUMÁRIO
INTRODUÇÃO ......................................................................................................................04
ETAPA 1
1. CONCEITOS FUNDAMENTAIS DE PROGRAMAÇÃO ...............................................05
1.1. ALGORITMO ...................................................................................................................08
1.2. NOÇÕES DE ALGORITMO ...............................................................................................09
1.3. PSEUDO LINGUAGEM ..................................................................................................10
1.4.ESTRUTURA DE UM PROGRAMA ...............................................................................11
1.5. TIPOS PRIMITIVOS PARA REPRESENTAÇÃO DE DADOS E VARIÁVEIS...........12
1.6. OPERADORES ARITMÉTICOS, LÓGICOS E RELACIONAIS ..................................14
1.7. CARACTERÍSTICAS DO AMBIENTE DE DESENVOLVIMENTO C .......................17
1.8. ATIVIDADE PASSO 3.1..................................................................................................18
1.9. ATIVIDADE PASSO 3.2..................................................................................................19
ETAPA 2
2. PROGRAMAÇÃO ESTRUTURADA .................................................................................20
2.1. DESENVOLVIMENTO DE ALGORITMO UTILIZANDO A LINGUAGEM C ..........20
2.2. APLICAÇÃO DOS CONCEITOS DE ESTRUTURA DE CONTROLE PARA ANÁLISE DE CONDIÇÕES ..................................................................................................23
2.3. DESENVOLVIMENTO DE LAÇOS DE REPETIÇÃO ......................................................26
2.4. ATIVIDADE PASSO 3 ..................................................................................................29
2.5. REFERÊNCIAS BIBLIOGRÁFICA...............................................................................31
INTRODUÇÃO
Este trabalho tem como objetivo mostrar a noção de programação para o curso de engenharia, neste caso, o de engenharia mecânica. Os relatórios dirigidos como relatórios 1 e 2 são apresentados em formas de tópicos ao longo do trabalho, apresentando a proposta pedida na atividade pratica supervisionada.							
Ao fim deste, será possível conceber, projetar e analisar sistemas, produtos e processos, assim como identificar, formular e resolver problemas de engenharia que envolvem programação. Com isso será possível desenvolver ou utilizar ferramentas e técnicas que serão vistas, a fim de atuar em grupo para a resolução de problemas. 						
CONCEITOS FUNDAMENTAIS DE PROGRAMAÇÃO
Um algoritmo pode ser definido como uma sequência finita de passos (instruções) para resolver um determinado problema. Sempre que desenvolvemos um algoritmo estamos estabelecendo um padrão de comportamento que deverá ser seguido (uma norma de execução de ações) para alcançar o resultado de um problema.					São propriedades de algoritmos:
ações simples e bem definidas (não ambíguas);
sequência ordenada de ações;
sequência finita de passos.
		
		Um algoritmo quando programado num computador é constituído pelo menos das 3 partes, sendo elas:
		1. Entrada de dados;
		2. Processamento de dados;
		3. Saída de dados;
		Na parte de entrada, são fornecidas as informações necessárias para que o algoritmo possa ser executado. Estas informações podem ser fornecidas no momento em que o programa está sendo executado ou podem estar embutidas dentro do mesmo. Na parte do processamento são avaliadas todas as expressões algébricas, relacionais e lógicas, assim como todas as estruturas de controle existentes no algoritmo (condição e/ou repetição). Na parte de saída, todos os resultados do processamento (ou parte deles) são enviados para um ou mais dispositivos de saída, como: monitor, impressora, ou até mesmo a própria memória do computador.													A pseudo-linguagem (ou pseudocódigo)é uma maneira intermediária entre a linguagem natural e uma linguagem de programação de representar um algoritmo. Ela utiliza um conjunto restrito de palavras-chave, em geral na língua nativa do programador, que tem equivalentes nas linguagens de programação. Além disso, a pseudo-linguagem  não requer todo a rigidez sintática necessária numa linguagem de programação, permitindo que o aprendiz se detenha na lógica do algoritmos e não no formalismo da sua representação. Na medida que em se obtém mais familiaridade com os algoritmos, então o pseudocódigo pode ser traduzido para uma linguagem de programação.								Na área de programação usa-se operadores aritméticos, lógicos e relacionais. Operadores Aritméticos são utilizados na resolução de expressões matemáticas utilizando quaisquer valores, sejam eles constantes ou variáveis. Retorna um inteiro se todos os valores são inteiros ou um real se um ou mais valores são reais.							Exemplo de operadores aritméticos:
+ soma
- subtração
* multiplicação
/ divisão
módulo: resto de uma divisão
^ potenciação
		Operadores Relacionais são utilizados para estabelecer uma relação entre operador e operando. Retorna sempre um booleano; true para uma relação verdadeira e falsa para uma relação falsa.										Exemplo de operadores relacionais:
> maior que
< menor que
<> ou != diferente de
>= maior ou igual a
<= menor ou igual a
	Operadores Lógicos são utilizados para estabelecer relação entre valores lógicos. Retornam sempre um booleano pois sua utilização é dada quase sempre pela combinação de operadores relacionais.											Exemplo de operadores Lógicos:
AND ou && "E"
OR ou || "Ou"
NOT ou ! "negação"
1.1 ALGORITMO
Um algoritmo é uma sequência finita de instruções bem definidas e não ambíguas, cada uma das quais pode ser executada mecanicamente em um período de tempo finito e com uma quantidade de esforço finita.1 2
O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita culinária, embora muitos algoritmos sejam mais complexos. Eles podem repetir passos (fazer iterações) ou necessitar de decisões (tais como comparações ou lógica) até que a tarefa seja completada. Um algoritmo corretamente executado não irá resolver um problema se estiver implementado incorretamente ou se não for apropriado ao problema.
Um algoritmo não representa, necessariamente, um programa de computador3 , e sim os passos necessários para realizar uma tarefa. Sua implementação pode ser feita por um computador, por outro tipo de autômato ou mesmo por um ser humano. Diferentes algoritmos podem realizar a mesma tarefa usando um conjunto diferenciado de instruções em mais ou menos tempo, espaço ou esforço do que outros. Tal diferença pode ser reflexo da complexidade computacional aplicada, que depende de estruturas de dados adequadas ao algoritmo. Por exemplo, um algoritmo para se vestir pode especificar que você vista primeiro as meias e os sapatos antes de vestir a calça enquanto outro algoritmo especifica que você deve primeiro vestir a calça e depois as meias e os sapatos. Fica claro que o primeiro algoritmo é mais difícil de executar que o segundo apesar de ambos levarem ao mesmo resultado.
1.2 NOÇÕES DE ALGORITMO
Algoritmo é a base da ciência da computação e da programação. Quando falamos em programar, falamos, basicamente, em construir um algoritmo. Todo programa de um computador é montado por algoritmos que resolvem problemas matemáticoslógicos com objetivos específicos.
Mesmo pessoas que usam uma linguagem de programação para fazer seus programas de computadores estão, na realidade, elaborando algoritmos computacionais em suas mentes.
Um algoritmo não passa de passos sequenciais e lógicos que são organizados de forma a realizar a conclusão de certo problema. Mas precisamos entender que existem dois tipos de algoritmos – os Não Estruturados e os Estruturados.
Programadores usam algoritmos estruturados, pois se adequam a determinado objetivo ou certo fim.
Mas não são apenas os programadores que usam algoritmos. Em nosso cotidiano, os algoritmos Não Estruturados são trabalhados em nossas mentes sem nem mesmo percebermos.
1.3 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. 
A Pseudo Linguagem a--
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.
1.4 ESTRUTURA DE UM PROGRAMA
O algoritmo como um todo é um bloco de instruções, então deve ser delimitado pelos comandos início e fim. 
As constantes e variáveis devem ser declaradas no início.
Os comandos são executados sequencialmente de cima para baixo e da esquerda para a direita, assim, devem ser escritos nesta sequência.
Cada comando deve terminar com ; (ponto-e-vírgula).
Abaixo segue um modelo da estrutura básica de um algoritmo:
início
  /* declaração das constantes e variáveis*/
  inteiro: var1, var2;
  real: var3;
  caractér: nome;
  /* comandos */
  comando 1;
  comando 2;
  comando 3;
  ..........
  ..........
  ..........
  comando n;
fim 
Observe que os comandos delimitados por início e fim estão avançados de dois espaços. Isto será muito utilizado pois facilita o entendimento do algoritmo.
TIPOS PRIMITIVOS PARA REPRESENTAÇÃO DE DADOS E VARIÁVEIS
Um tipo primitivo é fornecido por uma linguagem de programação como um bloco deconstrução básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória. Tipos primitivos típicos incluem:
Tipos numéricos
Os tipos numéricos estão entre os primeiros implementados pelas linguagens de programação. A maioria das linguagens oferece tanto representações dos números inteiros, como representações dos números reais. As representações computacionais desses tipos são apenas aproximações desses conjuntos matemáticos, que são infinitos, não podendo ser representados na memória do computador, que é finita, a tabela abaixo mostra os principais operadores aritméticos, a forma como são representados e exemplos de como utilizá-los.
Valores numéricos podem também ser operandos de operadores relacionais.
Os operadores relacionais são utilizados para comparar valores, podendo ser aplicados sobre operandos numéricos, além de outros tipos. Contudo, um operador relacional sempre produz um valor de tipo booleano, independente do tipo dos operandos comparados.
Tipo inteiro
O tipo inteiro é o tipo primitivo numérico mais comum. Sem parte fracionária, o tipo inteiro é caracterizado por sua faixa de valores representáveis, havendo versões dos inteiros com ou sem sinal. São comuns implementações de inteiros, inteiros sem sinal e inteiros longos. Um tipo inteiro com sinal é representado internamente como uma sequência de bits, em geral dois bytes, sendo o bit da extrema esquerda utilizado pararepresentar o sinal e os demais bits para representar o valor absoluto do número, normalmente em uma notação conhecida como complemento de dois.
Na Tabela os exemplos de inteiros, tomando como base os inteiros oferecidos pelas linguagens C/C++:
Na Tabela ‘unsigned int’ corresponde a um inteiro simples sem sinal, enquanto ‘unsigned long int’ corresponde a um inteiro longo sem sinal. Note que o uso do bit de sinal como parte da representação do valor absoluto permite aproximadamente dobrar o número de valores positivos representáveis. Na escrita do algoritmo sob a forma de pseudocódigo, o tipo inteiro é identificado pela palavra reservada inteiro. Como o algoritmo é uma representação genérica, não existe a preocupação com o tamanho necessário para armazenar esse tipo. Veja alguns valores do tipo inteiro: 5, -3 e 0.
Tipo flutuante
Os números em ponto-flutuante correspondem ao conjunto dos números reais, aqueles que abrangem os números racionais e irracionais. Para muitos números reais, as representações computacionais em ponto-flutuante são apenas aproximações, como acontece com dízimas periódicas e números como, e pode haver prejuízo de exatidão durante algumas operações aritméticas, como supondo numerador e denominador representados em ponto-flutuante. Um valor em ponto-flutuante é definido em termos de precisão e faixa. A precisão corresponde à exatidão de sua parte fracionária, medida pelo número de bits empregados para representá-la, ao passo que a faixa devalores é uma combinação dos valores do expoente e da parte fracionária. Um número em ponto-flutuante é geralmente representado pelo padrão de ponto-flutuante IEEE 754. Nesse padrão, um bit representa o sinal, seguido de uma sequência de bits que representa o expoente e outra sequência de bits que representa o valor da parte fracionária, conforme mostrado a seguir:
Como acontece com os inteiros, a variedade de tipos flutuantes em uma linguagem de programação depende do projeto da linguagem e de sua arquitetura alvo. Um tipo ponto-flutuante de precisão simples costuma ser armazenado em quatro bytes, enquanto os de precisão dupla usam oito bytes.
Tipo booleano
O tipo booleano é certamente o tipo primitivo mais simples, pois possui apenas dois valores associados: true e false. Normalmente, o tipo booleano é empregado como sinalizador ou comutador para indicar a ocorrência de certas condições ou para desviar o fluxo de execução do programa. Ainda que algumas linguagens de programação utilizem outros tipos para essas funções, como acontece com a linguagem C, o uso do tipo booleano geralmente torna o programa mais compreensível.
Já variáveis, nas linguagens de programação, uma variável representa um valor qualquer de um determinado tipo, o tipo da variável. Variável, como o nome indica, é um dado que tem a possibilidade de variar, ou seja, ter seu valor alterado durante a execução do algoritmo existem algumas regras básicas que regulam a o batismo de variáveis. Estasregras básicas são:
O caractere "_" é contado como uma letra;
Todo primeiro caractere deve ser sempre uma letra; 
Letras maiúsculas e minúsculas são consideradas caracteresdiferentes em muitas linguagens.
Palavras reservadas não podem ser usadas como nome de variáveis. Entre outras.
Nomear uma variável com poucos caracteres e com significado.
1.6 OPERADORES ARITMÉTICOS, LÓGICOS E RELACIONAIS.
Operadores aritméticos são usados para expressar operações matemáticas básicas, estes operadores são empregados com muita frequência em programação. É com o seu uso (muitas vezes da combinação de vários deles) é que são feitas as tarefas mais comuns de processamento de dados.
A. Operadores Aritméticos.
São símbolos de conexão utilizados para a realização de cálculos aritméticos. 
Fáceis de utilizar, parecem muito com um cálculo realizado em uma calculadora comum. Vejamos uma tabela com os operadores básicos: 
	Operador
	Cálculo Realizado
	Exemplo
	Resultado
	+
	Soma entre dois números
	4 + 8
	12
	-
	Subtração entre dois números
	32 - 9
	23
	*
	Multiplicação entre dois números
	6 * 8
	48
	/
	Divisão entre dois números
	48 / 16
	3
	%
	Resto da divisão entre dois números
	21 % 2
	1
O único operador que talvez nem todos conheçam ou se lembrem é o operador de resto da divisão. Funciona assim: Digamos que você divida 10 por 3. O resultado dá 3 e sobra 1. Então, se utilizarmos o operador de resto da divisão (também conhecido como módulo) para esse mesmo cálculo, o resultado será 1. Se fizéssemos 20 % 3 o resultado seria 2 ou seja, o resto da divisão de 20 por 3. 
Vejamos mais alguns exemplos do operador de resto da divisão só para ficar bem claro: 
30 % 5
# Resultado: 0
12 % 5
# Resultado: 2
18 % 5
# Resultado: 3
Eis uma figura para ilustrar o quê afinal de contas significa o resto da divisão: 
Neste ponto podemos realizar uma comparação entre a sintaxe dos operadores aritméticos entre a Matemática, o Português Estruturado e algumas linguagens de programação: 
B. Operadores Lógicos.
Em algoritmos normalmente usamos os operadores lógicos E, OU e NAO. Mas na maioria das linguagens de programação temos outras formas de representá-los. 
Veremos agora os três operadores lógicos mais utilizados: E (and), OU (or) e NAO (not). 
Vejamos uma representação dos operadores lógicos em algumas linguagens: 
	Operador
	Português Estruturado
	Ruby
	Java
	Javascript
	E (and)
	E
	and - &&
	&&
	&&
	OU (or)
	OU
	or - ||
	||
	||
	NAO (not)
	NAO
	not - !
	!
	!
Em português estruturado usa-se E, OU ou NAO mas normalmente nas linguagens de programação usa-se &&, || e !. 
Em Ruby é possível utilizar and, or e not, mas se você já quiser ir se acostumando, pode utilizar && ao invés de and, || ao invés de or e ! ao invés de not. 
Mas isso somente em seus scripts em Ruby, pois em algoritmos em Português Estruturado utilizamos E, OU e NAO mesmo. 
C. Operadores Relacionais.
Estabelecem uma relação entre dois elementos, retornando verdadeiro ou falso. 
Também são utilizados na Matemática, por isso são fáceis de assimilar. 
Vejamos uma tabela com os símbolos dos operadores relacionais e seus significados: 
	Em Português Estruturado
	Em Ruby
	Em Java
	Em Javascript
	Sentença
	Exemplo em Algoritmos
	Resultado
	=
	==
	==
	==
	Igual a
	4 = 4
	verdadeiro
	>
	>
	>
	>
	Maior que
	15 > 7
	verdadeiro
	<
	<
	<
	<
	Menor que
	80 < 72
	falso
	>=
	>=
	>=
	>=
	Maior ou igual a
	13 >= 13
	verdadeiro
	<=
	<=
	<=
	<=
	Menor ou igual a
	5 <= 4
	falso
	<>
	!=
	!=
	!=
	Diferente de
	7 <> 9
	verdadeiro
Aqui também podemos notar que só há uma diferença no operador de igualdade e no que calcula a diferença. 
No caso do operador de igualdade o motivo de ser utilizado dois iguais (==) ao invés de somente um é porque na maioria das linguagens de programação o sinal de igual é na verdade um sinal de atribuição. O assunto "atribuição" será abordado mais adiante neste curso em detalhes quando estudarmos variáveis. Em outras linguagens de programação como PHP o operador relacional de igualdade também é constituído de dois sinais de igual (==). 
O operador de diferença em português estruturado também difere da maioria das linguagens de programação pois é composto de um sinal de menor e um sinal de maior (<>) em contraste com o sinal de exclamação seguido de um sinal de igual (!=) utilizado nas mesmas. 
1.7 CARACTERÍSTICAS DO AMBIENTE DE DESENVOLVIMENTO C.
C é uma linguagem de programação geral, padronizada pela ISO, foi criado no ano de 1972, por Dennis Ritchie, para o sistema operacional Unix. A linguagem C foi criada para facilitar a criação de programas e diminuir a margem de erros, esta linguagem possui as seguintes características:
Linguagem simplificada, com realização de funções matemáticas ou manuseamento de arquivos, fornecida por um conjunto de rotinas do mesmo padrão.
Em foco, o paradigma de programação processural.
Sistema simples que evita operações sem sentido.
Pré-processamento tendo a possibilidade de múltiplos ficheiros * Ponteiros dão maior flexibilidade à linguagem.
Acesso de baixo-nível, através de inclusões de código Assembly no meio do programa C.
Usa-se valores e não referencias.
Alto nível de definição de variáveis.
Estruturas de variáveis que permitem que dados relacionados sejam combinados e manipulados como um todo.
1.8 ATIVIDADE PASSO 3.1.
a) Bobinas com Diâmetro total externo de 1000 mm peso por metro linear 0,610: IV. Exemplo Largura de 660 peso igual a 403 Kg;
Então, 660x(1000/1000)x0,610 onde 660x1x0,610=402,60 que foi arredondado para 403 Kg.
b) Bobinas com Diâmetro total externo de 1150 mm peso por metro linear 0,678: V. Exemplo largura de 660 peso igual a 515 Kg;
Então, 660x(1150/1000)x0,678 onde660x1,15x0,678=514,60 que foi arredondado para 515 Kg.
c) Bobinas com Diâmetro total externo de 1200 mm peso por metro linear 0,725: VI. Exemplo largura de 660 peso igual a 574 Kg;
Então, 660x(1200/1000)x0,725 onde 660x12x0,725= 574,20 que foi arredondado para 574 Kg.
d) Bobinas com Diâmetro total externo de 1500 mm peso por metro linear 0,933: VII Exemplo largura de 660 peso igual a 924 Kg;
Então, 660x(1500/1000)x0,933 onde 660x15x0,933=923,67 que foi arredondado para 924 Kg.
1.9 ATIVIDADE PASSO 3.2.
#include //importa a biblioteca
#include // importa a biblioteca
int main() 
{
float pesoMetroLinear, peso, diametroE, largura; // declaração de variaveis 
printf ("Digite o Diametro Externo: "); // perguntando o valor do Diametro
scanf ("%f", &diametroE); // lendo o valor do Diametro
printf ("Digite o valor do peso por metro linear: "); // perguntando o valor do peso
scanf ("%f", &pesoMetroLinear); // lendo o valor do peso
printf ("Digite o valor da largura: "); // perguntando a largura
scanf ("%f", &largura); // lendo a largura
peso = largura* (diametroE/1000)* pesoMetroLinear; // calculando a formula do exercicio
printf (" O Peso Teorico da bobina e de: %.3f\n\n",peso); // exibindo na tela o valor do peso
system ("PAUSE"); // congelando a tela para visualização
return(0); // retornando o valor 0;
}
2. PROGRAMAÇÃO ESTRUTURADA.
2.1 DESENVOLVIMENTO DE ALGORITMO UTILIZANDO A LINGUAGEM C.
C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa padronizada pela ISO, criada em 1972. C é uma das linguagens de programação mais populares e existem poucas arquiteturas para as quais não existem compiladores para C. C tem influenciado muitas outras linguagens de programação, mais notavelmente C++, que originalmente começou como uma extensão para C. 
C tem como ponto forte, a sua eficiência, e é a linguagem de programação preferida para o desenvolvimento de sistemas e softwares de base, apesar de também ser usada para desenvolver programas de computador. É também muito usada no ensino de ciência da computação, mesmo não tendo sido projetada para estudantes e apresentando algumas dificuldades no seu uso. Outra característica importante de C, é sua proximidade do código de máquina, que permite que um projetista seja capaz defazer algumas previsões de como o software irá se comportar, ao ser executado.
C tem como ponto fraco, a falta de proteção que dá ao programador. Praticamente tudo que se expressa em um programa em C, pode ser executado, como por exemplo, pedir o vigésimo membro de um vetor com apenas dez membros. Os resultados são muitas vezes totalmente inesperados, e os erros, difíceis de encontrar.
A linguagem C é considerada de alto nível em vista de outros métodos para implementação de algoritmos no ramo da computação. A linguagem C, apesar de muito usada, necessita de um bom leiaute. Portanto alguns pontos são evitados pelos programadores, que buscam deixar o programa de forma limpa e clara para que esta lendo e executando a ação.
Na linguagem C usa-se bastante a estrutura do laço para executar alguns programas. Laços são comandos usados sempre que uma ou mais instruções tiverem de ser repetidas enquanto uma certa condição estiver sendo satisfeita. Em C existem três comandos de laços:
For
While
Do-While
O laço for é geralmente usado quando queremos repetir algo por um número fixo de vezes. Utilizamos quando sabemos de antemão o número de vezes a repetir. Utilizamos o laço while quando o laço pode ser terminado inesperadamente, por condições desenvolvidas dentro do corpo. E por fim o laço do-while é utilizado em situações em que é necessário executar o corpo do laço uma primeira vez, logo após, avaliar a expressão de teste e criar um ciclo repetido. Estes tipos de condicionamento serão visualizados ao longo do programa a ser executado.
Outro ponto são as estruturas para tomadas de Decisão na linguagem C. Os comandos de decisão permitem determinar qual é a ação a ser tomada com base no resultado de uma expressão condicional. Os dois comandos básicos para tomadas de decisões são: if-else e swith-case. Alem destes podemos citar outros que nem sempre são usados, mas também satisfazem esta parte, que são: break e continue, e goto.
If é uma estrutura de definição que tem o objetivo de testar se a condição passado é verdadeira, caso seja ele entra dentro do bloco de if, e dentro do bloco de if caso não seja ele entra dentro do bloco de else onde a decisão é satisfatória.
Sintaxe:
	
	
		SWITCH é uma declaração de múltipla escolha, diferente do if que caso tenha uma lista de escolha a ser montada não fica elegante e dependendo a extensão do programa fica difícil a manutenção.
Sintaxe:
2.2 APLICAÇÃO DOS CONCEITOS DE ESTRUTURA DE CONTROLE PARA ANÁLISE DE CONDIÇÕES.
Em ciência da computação, estrutura de controle (ou fluxo de controle) refere-se à ordem em que instruções, expressões e chamadas de função são executadas ou avaliadas em programas de computador sob programação imperativa ou funcional.
Os tipos de estruturas de controle disponíveis diferem de linguagem para linguagem, mas podem ser cruamente caracterizados por seus efeitos. O primeiro é a continuação da execução em uma outra instrução, como na estrutura sequencial ou em uma instrução jump. O segundo é a execução de um bloco de código somente se uma condição é verdadeira, uma estrutura de seleção. O terceiro é a execução de um bloco de código enquanto uma condição é verdadeira, ou de forma a iterar uma coleção de dados, uma estrutura de repetição. O quarto é a execução de instruções distantes entre si, em que o controle de fluxo possivelmente volte para a posição original posteriormente, como chamadas de subrotinas e corotinas. O quinto é a parada do programa de computador.
Interrupções e sinais são mecanismos de baixo nível que podem alterar o fluxo de controle de forma similar a uma sub-rotina, mas geralmente em resposta a algum estímulo externo ou um evento ao invés de uma estrutura de controle em uma linguagem.
Em nível de linguagem de máquina, as instruções de estruturas de controle geralmente funcionam ao alterar o contador de programa. Para algumas CPUs, as únicas instruções de estruturas de controle disponíveis são os diversos tipos de jump condicional.
Estrutura sequencial. Em ciência da computação, uma estrutura sequencial é uma estrutura de desvio do fluxo de controle presente em linguagens de programação que realiza um conjunto predeterminado de comandos de forma sequencial, de cima para baixo, na ordem em que foram declarados.
Sua estrutura básica é a repetição de comandos sequencialmente:
Ação1;
Ação2;
Ação3;
Ação4;
Ação5;
Estrutura de seleção (expressão condicional ou ainda construção condicional) é, na ciência da computação, uma estrutura de desvio do fluxo de controle presente em linguagens de programação que realiza diferentes computações ou ações dependendo se a seleção (ou condição) é verdadeira ou falsa, em que a expressão é processada e transformada em um valor booleano.
Seleção simples e composta
A condição "se-então(-senão)" é uma estrutura de seleção comum em diversas linguagens de programação. Sua estrutura básica é a seguinte:
Se (condição) Então
 (bloco de código)
Senão
 (bloco de código)
Fim Se
Quando o interpretador encontra o identificador "Se", ele espera em seguida uma condição booleana sob forma de expressão relacional (como por exemplo, "x > 0"), que pode ser ver verdadeira ou falsa. Se a condição é verdadeira, o bloco de código seguido de "Então" é executado. Caso a condição seja falsa, o bloco de código seguido de "Senão" é executado. Em ambos os casos, após a execução do bloco de código, o fluxo do programa é retornado para o ponto indicado por "Fim Se". Note que a parte do "Senão" é opcional e pode ser omitida. Caso omitida, a estrutura é chamada de seleção simples; caso contrário é chamada seleção composta.
A estrutura "Senão Se" é formada pela composição de estruturas de seleção, e um exemplo de sua estrutura é o seguinte:
Se (condição) Então
 (bloco de código)
Senão
 Se (condição) Então
 (bloco de código)
 Fim Se
Fim Se
No exemplo acima, caso a primeira condição seja falsa, o fluxo do programa é desviado para o bloco de código do "Senão", onde há o processamento de outra estrutura de seleção.
Estrutura de repetição, na ciência da computação, é uma estrutura de desvio do fluxo de controle presente em linguagens de programação que realiza e/ou repete diferentes algoritmos/ações dependendo se uma condição é verdadeira ou falsa, em que a expressão é processada e transformada em um valor booleano. Estão associados a uma estrutura de repetição uma condição (também chamada "expressão de controle" ou "condição de parada") e um bloco de código: verifica-se a condição, e caso seja verdadeira, o bloco é executado. Após o final da execução do bloco, a condição é verificada novamente, e caso ela ainda seja verdadeira, o código é executado novamente.
Deve-se observar que, caso o bloco de código nunca modificar o estado da condição, a estrutura será executada para sempre, uma situação chamada laço infinito. Da mesma forma, é possível especificar uma estrutura em que o bloco de código modifica o estado da condição, mas esta é sempre verdadeira.
Algumas linguagens de programação especificam ainda uma palavra reservada para sair da estrutura de repetição de dentro do bloco de código, "quebrando" a estrutura. Também é oferecido por algumas linguagens uma palavra reservada para terminar uma iteração específica do bloco de código, forçando nova verificação da condição.
2.3 DESENVOLVIMENTO DE LAÇOS DE REPETIÇÃO.
Estrutura de repetição nada mais é que laços de repetições.
Laços de repetições permite que um conjunto de instruções seja repetido até que se faça a condição desejada.
A linguagem C suporta aos mesmos tipos de laços que as linguagens de programações modernas, esses laços são For, While, Do While.
Laço FOR
Laço utilizado geralmente quando existe um termino definido, sempre vai tem um fim definido para esse laço implementado no inicio.
Sintaxe
For (variável de inicialização; condição; incremento)
Variável de inicialização: comando de atribuição que inicia uma variávelque faz o controle do laço.
Condição: expressão usada que determinará o final do laço.
Incremento: define a variável de controle e muda a cada passada no laço.
Exemplo 
#include<conio.h>
#include<stdio.h>
int main()
{
 int i;
 for (i=0; i<10; i++)
 {
 printf("%d\n", i);
 } 
getch();
}
Laço WHILE
Laço que pode ter uma condição de termino definida já no inicio ou não. Necessariamente ele testa a condição e se caso for verdadeiro executa o bloco abaixo, caso seja falso ele vai para a próxima instrução fora do laço.
Sintaxe 
While (Condição)
{
	Comandos;
}
Condição: Pode ser qualquer expressão valida ou até quando a verdadeira.
Comando: pode ser um bloco de comando vazio ou de repetição definido por um termino.
Exemplo 
Definindo o término
#include<conio.h>
#include<stdio.h>
int main()
{
 int i=0;
 while(i < 10)
 {
 i = i+1;
 printf ("%d\n", i);
 } 
getch ();
}
Termino definido pelo usuário
#include<conio.h>
#include<stdio.h>
int main()
{
 char ch;
 ch = 0;
 
 while (ch !='A')
 {
 ch = getche();
 }
getch();
}
Laço DO WHILE
Laço quase igual ao While, a diferença é que primeiro ele executa um bloco e testa a condição, caso seja falsa vai para o próxima instrução.
Sintaxe 
Do
{
	Comandos;
} while(condição);
Exemplo 
#include<conio.h>
#include<stdio.h>
int main()
{
 int i=0;
 
 do
 {
 i++;
 printf("%d\n", i);
 } while(i <= 10);
getch();
}
Se notarem no comando while ele preenche até o numero 10 pois ele testa a condição primeiro e no do while podem notar que ele imprime 11 devido ele entrar novamente dentro do laço e depois testar a condição.
Com isso mostro que não tem dificuldades em utilizar essa linguagem de programação, pois os conceitos são os mesmos das outras linguagens, lembrando que estou mostrando a parte básica ainda da utilização de Estrutura de repetição.
2.4 ATIVIDADE PASSO 3.
2.3.1 Criar uma função para receber os pedidos: quantidade em quilos, largura das bobinas e altura das bobinas (unidade de medida milímetros).
Instruções:
1- Digitar pedido, qtd em quilos, largura, altura
2- Somar em conta3- Mostrar os dados
4- Se fim
5- Imprima o pedido
2.3.2 Criar uma função que combine a informação de largura de todos os pedidos informados e resulte em um valor que determine qual o total que será usado da Bobina Jumbo.
Instruções:
1- Digitar pedido, largura, perda de Bobina Jumbo
2- Somar largura em conta
3- Se fim de pedido
4- Largura *2/100=perda de Bobina Jumbo
5- Largura – perda de bobina
6- Imprimir dados
2.3.3 Apresentar o volume de produção necessário para atendimento dos pedidos recebidos.Exemplo:
float Bobinas Jumbo = soma Quantida de Pedido / Peso Bobina Jumbo;
printf("O número de Bobinas Jumbo com 2.450 mm e' %.2f", Bobinas Jumbo);
Instruções:
1- Digitar soma qtd pedido, peso Bobina Jumbo
2- Somar 1 em conta
3- Qtd pedido / 2450
4- Mostrar dados
5- Se fim
6- Imprime dados
2.3.4 Apresentar o usuário da largura total que será utilizada da Bobina Jumbo. A largura total será a soma de todas as larguras dos pedidos que foram informados pelo usuário. Exemplo: printf("A largura total utilizada e' %.2f", total Largura Bobinas Filhas);
Instruções:
1- Digitar pedido, largura bobina jumbo
2- Somar largura em conta
3- Se fim
4- Imprime total largura
2.3.5 Informar ao usuário a porcentagem da Bobina Jumbo que não será utilizada. Esta informação é o total de perda comercial (Refugo Comercial). O usuário deverá ser consultado se esta conjugação será aprovada ou será descartada, sendo assim o pedido não será aceito para produção. Exemplo:
float perda Comercial = 1-(total Largura Bobinas Filhas / 2450);
printf("O número de Bobinas Jumbo com2.450 mm e' %.2f /%", n Bobinas Jumbo);
Instruções
1- Digitarpedido, largura, perda de bobina
2- Somar largura em conta
3- Se fim de pedido
4- Largura *2/100=perda de bobina
5- Imprimir perda de bobina
Vimos nesse artigo mais um importante tópico para qualquer linguagem de programação as estruturas de repetição, aprendemos sobre os diversos tipos na linguagem C+ entre eles: laços de repetição como for, laço while, laço do while. Tambem vimos como montar o sequencial do programa.
 
REFERÊNCIAS BIBLIOGRÁFICA
Noções básicas de algoritmo http://www.devmedia.com.br/nocoes-basicas-de-algoritmo/26405#ixzz3Ed9kemx3
http://pt.wikipedia.org/wiki/Algoritmo
http://equipe.nce.ufrj.br/adriano/c/apostila/algoritmos.htm#pseudo
http://homepages.dcc.ufmg.br/~joaoreis/Site%20de%20tutoriais/algo1/estrutura.htm
http://www.activeinfo.com.br/curso_programacao/operadores_aritmeticos.html
http://www.devmedia.com.br/estrutura-de-repeticao-c/24121