GEORGE DE CARVALHO F. DA CRUZ - CONTROLE E AUTOMAO -
6814012733 KLAUS RELICH - CONTROLE E AUTOMAO - 1299456381 RODRIGO CHAVES - PRODUO - 6440303610 RENATO MIRANDO - CONTROLE E AUTOMAO - 6814012752 WILLIAM DOS SANTOS - CONTROLE E AUTOMAO - 6622354184
ATIVIDADE PRTICA SUPERVISIONADA - ATPS ALGORITMOS E PROGRAMAO.
ORIENTADOR: Joo Silvano
So Caetano do Sul Junho de 2013
1. Noes de algoritmo.
1.1 O que um algoritmo? - uma sequncia finita de aes simples e bem definidas , pr estabelecidas para chegar a um resultado.
1.2 Como criar um algoritmo? -Para criar um algoritmo definimos uma sequncia perfeita de comandos lgicos e simples, cada comando terminado por um ; , que o comando que determina a sequencia da execuo. Podemos utilizar outros tipos de comandos como, de comparao, de repetio e deciso. Entretanto, todas as aes solicitadas tem que ser de maneira exata, pois, todo e qualquer erro nas definies de aes, acarretaram no erro de toda a programao.
2. Pseudo Linguagem. - uma forma facilitada de desenvolver um algoritmo, constituda em uma linguagem entre a linguagem humana, e os comandos utilizados na programao de mquina, a que permite ao programador se preocupar apenas com o desenvolvimento do algoritmo em si, sem se preocupar dos meios tcnicos para a sua execuo, como por exemplo o portugol.
3. Estrutura de um Programa e Caractersticas do ambiente C. -Na estrutura do programa aonde definimos as aes a serem executadas atravs de clculos e variveis utilizando entrada e sada de dados, determinados pela necessidade e inteno dos respectivos clientes, ou da empresa a qual voc prestara o servio de programao. O programa te direcionara atravs de um fluxo a um resultado satisfatrio para o seu cliente. Primeiramente definimos as variveis e as bibliotecas a serem utilizadas no programa, caso necessrio, definir os valores das variveis. Aps definirmos as variveis, iniciar uma sequencia lgica de comandos como nos exemplos abaixo em linguagem C:
Int var1; = definir varivel inteira var1 #Include <stdio.h>; = incluir biblioteca stdio.h Printf (teste); = mostrar ao usurio texto teste If (8<var1<20); { Printf (ok); } Else; Printf (no); neste caso se a varivel var1 for maior que 8 e menor que 20 aparecera na tela o texto ok caso contrario aparecera a mensagem no. Um ponto importante para um programa bem feito a esttica, definimos linhas de observao (linhas no executveis) com textos para facilitar a leitura do que o bloco esta executando. Outro ponto importante da esttica o recuo das linhas do programa, dando TAB nas linhas e blocos de execuo, para, facilitar a visualizao dos mesmos.
4. Tipos Primitivos Durante o seu processamento, um programa de computador precisa alocar na memria RAM os dados contidos nas variveis para poder manipula-los. Para tal necessrio que durante a construo de um algoritmo seja informado ao compilador qual o tipo do dado, para que essa informao seja passada ao sistema, que por sua vez determinar a quantidade necessria de memria que ele ir ocupar. Tipos primitivos de dados, so categorias atmicas (em referncia s molculas bsicas que so indivisveis, tomo que em latim quer dizer pequeno objeto) pois no possvel sua decomposio em tipos mais simples; Sendo eles: 4.1 Inteiro Tambm conhecido como int ou integer, representa nmeros inteiros, ou seja sem casas decimais. 4.2 Real Tambm denominado como decimal ou float, utilizado para expressar numero reais, ou seja decimais. 4.3 Caractere Tambm denominado char ou strings, esse tipo de dados utilizado para expressar caracteres alfanumricos como letras e nmeros. 4.4 Lgico Tambm denominados booleanos, utilizados para expressar valores lgico, ou seja 0 e 1, true ou false. 5. Operadores Aritmticos, Relacionais, Lgicos 5.1 Operadores Aritmticos So ferramentas utilizadas em clculos de expresses matemticas utilizando quaisquer valores ou variveis numricas do tipo inteiro ou real; Sendo eles: (+) - soma; (-) - subtrao; (*) - multiplicao; (/) - diviso; (mod) - mdulo, (resto de uma diviso); (^) exponenciao ou potenciao. 5.2 Operadores Relacionais Usados para estabelecer uma relao entre operador e operando. Retorna sempre um booleano; true para uma relao verdadeira e false para uma relao falsa. (>) - maior que; (<) - menor que; (<>) - ou (!=) diferente de; (>=) - maior ou igual a; (<=) - menor ou igual a;
5.3 Operadores Lgicos Usados para traar uma relao entre valores lgicos. Como retorno apresentam sempre um booleano pois sua utilizao dada quase sempre pela combinao de dois ou mais operadores do tipo relacionais. (AND) ou (&&) ("E"); (OR) ou (||) ("Ou"); (NOT) ou (!) - "negao"; 6. Resumo do Peso de uma bobina filha 6.1 Algoritmo para o clculo do peso terico de uma bobina filha em portugol algoritmo "Cauculo do Peso Terico" // Funo : Caucular o Peso Terico de uma bobina filha // Autor : George Cruz // Data : 18/03/2013 // Seo de Declaraes var Diametro, PesoMetro, PesoTeorico, LarguraTotal, PesoTotal, largura:Real NumeroBobinas, Contagem:inteiro
inicio Contagem <- 1 PesoTotal <- 0 LarguraTotal <- 0 escreval("Quantas Bobinas Filhas Possui o Pedido?") leia(NumeroBobinas) enquanto (NumeroBobinas >= Contagem) faca escreval("Bobina numero: ",Contagem) escreval("Qual Largura Dessa Bobina Filha?") leia(Largura) escreval("Qual Peso Por Metro Linear Dessa Bobina Filha?") leia(Diametro) escreval("Qual Diametro Dessa Bobina Filha?") leia(PesoMetro) PesoTeorico <- (Largura * (Diametro / 1000)) * PesoMetro escreval("Peso Teorico dessa bobina filha",PesoTeorico) LarguraTotal <- LarguraTotal + Largura PesoTotal <- PesoTotal + PesoTeorico Contagem <- Contagem + 1
fimenquanto escreval("========================================") escreval("Lagura total do pedido: ",LarguraTotal) escreval("Peso total do pedido: ",PesoTotal) escreval("========================================")
fimalgoritmo 6.2 Algoritmo para o clculo do peso terico de uma bobina filha em C /* * File: main.c * Author: George * * Created on 7 de Maro de 2013, 13:12 */ #include <stdio.h> #include <stdlib.h>
void caucula() { int numerobobinas; float PesoTotal = 0; int larguratotal = 0; printf("\nQuantas bobinas filhas tem o pedido? \n"); scanf("%i",&numerobobinas); while(numerobobinas > 0) { float PesoT; int Largura; int Diametro; printf("\n============================================ \n"); printf("Informacoes da Bobina %i \n", numerobobinas); printf("\n============================================ \n"); printf("Qual o Peso por metro da Bobina Kg? \n"); scanf("%f",&PesoT); printf("Qual o Largura mm? \n"); scanf("%i",&Largura); printf("Qual o Diametro mm? \n"); scanf("%i",&Diametro); float Peso = (Largura * (Diametro / 1000)) * PesoT; printf("Peso teorico da Bobina Filha %.2f \n", Peso); larguratotal = larguratotal + Largura; PesoTotal = PesoTotal + Peso; numerobobinas--;
}; float PesoBobina; float largurabobinacorte; printf("Qual o peso das Bobinas a serem utilizadas no Corte Kg? \n"); scanf("%f", &PesoBobina); printf("Qual a Largura das Bobinas a serem utilizadas no Corte mm? \n"); scanf("%f", &largurabobinacorte); float totalbobinas = PesoTotal / PesoBobina; float BobinasPorLargura = larguratotal / largurabobinacorte; int BobinasPorLarguraI = larguratotal / largurabobinacorte; float perda = ((BobinasPorLargura - BobinasPorLarguraI)) * 100; printf("\n============================================ \n"); printf("\nLargura total do pedido: %i \n", larguratotal); printf("\nPeso Total do Pedido: %.2f \n", PesoTotal); printf("\nTotal de Bobinas Jumbo: de 2.450 mm Utilizadas %.2f \n" , totalbobinas); printf("\nPerda Comercial %.2f%% \n" , perda); };
int main(int argc, char**argv) { printf("################################################ \n"); printf("# Facudade Anhaguera de Sao Caetano do Sul # \n"); printf("# ATPS - Algoritimos e Programacao # \n"); printf("# Turma Engenharia de Controle e Automacao # \n"); printf("################################################ \n"); caucula(); int escolha; printf("\nDeseja realizar outro cauculo [1] - Sim, [0] - Nao ?\n"); scanf("%i", &escolha); if(escolha == 1) { printf("\n============================================\n"); caucula();
} else {
system("PAUSE"); return 0;
};
}; 7. Programao estruturada A programao estruturada estabelece uma disciplina de desenvolvimento de algoritmos que facilita a compreenso de programas atravs do nmero restrito de mecanismos de controle da execuo de programas. Qualquer algoritmo, independentemente da rea de aplicao, de sua complexidade e da linguagem de programao na qual ser codificado, pode ser descrito atravs destes mecanismos bsicos. O princpio bsico de programao estruturada que um programa composto por blocos elementares de cdigo que se interligam atravs de trs mecanismos bsicos, que so sequencia, seleo e iterao. Cada uma destas construes tem um ponto de incio (o topo do bloco) e um ponto de trmino (o fim do bloco) de execuo. Sequencia implementa os passos de processamento necessrios para descrever qualquer programa. Por exemplo, um segmento de programa da forma ``faa primeiro a Tarefa a e depois a Tarefa b'' seria representado por uma sequencia de dois retngulos. A mesma construo em pseudo-linguagem seria denotada pela expresso das duas tarefas, uma aps a outra. 8. Modularizao
Modularizao em tecnologia da informao um conceito onde o sistema ou software divido em partes distintas. Compe o ferramental necessrio para um programa mais legvel com uma melhor manuteno e melhor desempenho por meio da programao estruturada. Pode se caracterizado da seguinte forma: Elemento separadamente enderevel do sistema, menor parte do sistema que realiza uma funo completa independente de outras funes, conjunto de instrues de um programa que pode ser chamado por um nome, sendo ideal que para os outros mdulos seja uma caixa preta. A modularizao de programas utiliza vrios recursos disponveis na maior parte das linguagens de programao como funes e procedimentos para isolar cada etapa de um programa facilitando a compreenso do cdigo e o tornando mais organizado. 8.1 Uso de Vetores e Matrizes na Modularizao Outro elemento utilizado na modularizao de programas so os vetores e matrizes, vetores e matrizes so variveis multidimensionais, que evitam a necessidade da declarao de inmeras variveis em cdigos mais extensos.
Utilizando vetores e matrizes resumimos em poucas linhas de cdigo o que seria necessrio inmeras linhas somente para a declarao de variveis, ainda com o auxilio de laos de repetio e deciso podemos associar valores a vetores e matrizes de forma automtica tornando o cdigo muito mais limpo e executvel.
9. Funes do programa de calculo e Otimizao de Corte de Bobinas No exemplo do programa pedido na ATPS o cdigo foi divido em diversas funes para modularizar o programa sendo elas 9.1 Procedimento Cabealho Esse procedimento chama um texto padro de cabealho, utilizada no decorrer do programa quando a tela limpa para recolocar o cabealho. 9.2 Procedimento EntraPedidos Esse procedimento pergunta quantos pedidos o usurio deseja digitar, sendo considerado como um pedido um corte de bobina, atravs de um lao de repetio a funo alimenta os vetores e matrizes que contm as informaes dos pedidos para cada pedido que o usurio entrar. 9.4 Procedimento Imprime_Pedido Esse procedimento responsvel por imprimir os pedidos e a sequncia de corte, nela que gerada a sequncia de corte mesmo que o pedido no seja otimizado, a sequncia de corte criada nessa funo exibe a melhor sequncia de corte economizando o mximo possvel de cada bobina jumbo, essa funo chama outra funo para imprimir cada pedido, e ao final pergunta se o usurio deseja entrar mais pedidos ou encerrar o clculo. 9.5 Procedimento Recoloca Esse procedimento reverte o procedimento de otimizao que retirar alguns pedidos para reduzir a perda. 9.6 Procedimento Pedidos_I Nesse procedimento impresso os pedidos, ela utilizada diversas vezes no decorrer do programa. 9.7 Procedimento ordena_sequencia Esse procedimento utilizada para ordenar considerando a largura de cada pedido a matriz que contm as informaes dos pedidos, ela utilizada diversas no programa recendo como parmetro uma varivel caractere que indica se a ordenao vai ser em ordem ascendente ou descendente. 9.8 Procedimento CalculaPerda Esse procedimento soma a largura de todos os pedidos e calcula a perda, aps isso exibe os valores totais dos pedidos para o usurio e pergunta se ele deseja otimizar ou imprimir a sequncia de corte. 9.9 Procedimento Retirar Esse procedimento faz parte do processo de otimizao do calculo ela tenta retirar pedidos para diminuir a perda. 9.10 Procedimento Recalcula Esse procedimento utilizado aps serem retirados pedidos para recalcular os valores totais como largura, peso, total de pedidos e perda. 9.11 Procedimento optimiza_corte Esse procedimento agrupa procedimentos menores para criar a otimizao dos pedidos. 9.12 Procedimento inicial Esse procedimento tem a funo de criar uma interface amigvel, imprime na tela para o usurio um texto que explica as caractersticas do programa e pergunta se o usurio deseja iniciar a entrada de pedidos se sim chama a EntraPedidos seno a encerra o programa. 10. Cdigo do Programa algoritmo "calculo_bobinas" // Funo : Optimizar o corte de bobinas Jumbo // Autor : George C. F. Cruz // Data : 19/05/2013 // Seo de Declaraes var NomeCliente,resposta,temp4,Retorno:caractere Pedido_ID, Contagem, cont, TotalPedidos, i, j, Retirados:inteiro Largura, LarguraTotal, Peso, Perda2, PesoTotal, PesoTeorico, Diametro, ValidaBobinas:real LarguraJumbo, TotalBobinas, Perda, temp, temp2, temp3, QuantidadeRetirar, SomaRetira:real Porcentagem, Largura_Sequencia, Largura_Processada: real //Vetores SequenciaCorte: vetor[1..20] de real //Matrizes PedidosRetirar: vetor[1..3,1..20] de real Pedidos: vetor[1..3,1..20] de real Clientes: vetor[1..20] de caractere ClientesRetirados: vetor[1..20] de caractere imprimir: vetor[1..20] de caractere
//Cabealho procedimento Cabecalho () inicio escreval("################################################################### #########") escreval("# #") escreval("# Faculdade Anhanguera de So Caetano do Sul #") escreval("# ATPS Algoritimos e Programo - Professor Joo Silvano #") escreval("# George Cruz, Rodrigo Chaves, Klaus Relich, Wilian Santos, Renato Miranda #") escreval("# #") escreval("################################################################### #########") fimprocedimento //Funcao para o Cauculo de Bobinas procedimento EntraPedidos() inicio limpatela Cabecalho() escreval("")
escreval("=========================================================== =======") escreval("Informaes do Tipo de Bobina") escreval("------------------------------------------------------------------") escreval("") escreva("Largura Total (Mm): ") leia(LarguraJumbo) escreva("Peso por Metro (Kg): ") leia(Peso) escreva("Diametro (Mm): ") leia(Diametro) limpatela
escreval("=========================================================== =======") escreval("Quantos Pedidos Deseja Incluir? (Mximo 20 Pedidos)") leia(TotalPedidos) se TotalPedidos > 20 entao limpatela Cabecalho () escreval("") escreval ("<<<<< ENTRE UM VALOR MENOR QUE 20 NO CAMPO PEDIDOS >>>>>") escreval("") EntraPedidos() fimse Contagem:= 1 enquanto (Contagem <= TotalPedidos) faca Pedido_ID:= Contagem escreval("") escreval("------------------------------------------------------------------") escreval("== Entre os dados do pedido nmero: ",Pedido_ID," ==") escreva("Nome do Cliente: ") leia(NomeCliente) Clientes[Pedido_ID] := maiusc(NomeCliente) escreva("Largura desse corte (Mm): ") leia(Largura) PesoTeorico:= (Largura * (Diametro / 1000)) * Peso LarguraTotal:= LarguraTotal + Largura PesoTotal:= PesoTotal + PesoTeorico Pedidos[1,Pedido_ID] := Pedido_ID Pedidos[2,Pedido_ID] := Largura Pedidos[3,Pedido_ID] := PesoTeorico Contagem:= Contagem + 1 fimenquanto limpatela Cabecalho () CalculaPerda () fimprocedimento
//Funcao para imprimir um pedido aprovado
procedimento imprime_pedido() inicio limpatela Cabecalho () escreval("") Pedidos_I() LarguraTotal:= 0 para j de 1 ate TotalPedidos faca LarguraTotal:= LarguraTotal + Pedidos[2,j] fimpara TotalBobinas:= int(LarguraTotal / LarguraJumbo) + 1 //Ordenar Vetor Para a melhor sequencia de Corte j:= TotalPedidos + Retirados enquanto j > 1 faca para i de 1 ate j-1 faca //Largura se Pedidos[2,i] < Pedidos[2,i+1] entao temp := Pedidos[2,i] Pedidos[2,i] := Pedidos[2,i+1] Pedidos[2,i+1] := temp //Pedido_ID temp2 := Pedidos[1,i] Pedidos[1,i] := Pedidos[1,i+1] Pedidos[1,i+1] := temp2 //Peso temp3 := Pedidos[3,i] Pedidos[3,i] := Pedidos[3,i+1] Pedidos[3,i+1] := temp3 //Cliente temp4 := Clientes[i] Clientes[i] := Clientes[i+1] Clientes[i+1] := temp4 fimse fimpara j:= j-1 fimenquanto escreval("")
escreval("=========================================================== ==") escreval(" Sequencia de Corte ")
escreval("=========================================================== ==") //Imprime na melhor sequencia Contagem:= 1 Retirados:= 0 Para cont de 1 ate int(TotalBobinas) faca escreval("--------------- Bobina ",Cont, " ---------------") Largura_Sequencia:= 0 enquanto (Largura_Sequencia < LarguraJumbo) faca se (Pedidos[2,Contagem] < (LarguraJumbo - Largura_Sequencia)) e (Pedidos[2,Contagem] > 0) entao Largura_Sequencia:= Largura_Sequencia + Pedidos[2,Contagem] Porcentagem:= (Largura_Sequencia * 100) / LarguraJumbo SequenciaCorte[Contagem] := Pedidos[2,Contagem] Pedidos[1,Contagem] := 0 Pedidos[2,Contagem] := 0 Pedidos[3,Contagem] := 0 resposta:= "mudado" Retirados:= Retirados + 1 senao para j de 1 ate TotalPedidos faca se (Pedidos[2,j] < (LarguraJumbo - Largura_Sequencia)) entao se (Pedidos[2,j] > 0) e (resposta <> "mudado") entao Largura_Sequencia:= Largura_Sequencia + Pedidos[2,j] Porcentagem:= (largura_sequencia * 100) / LarguraJumbo SequenciaCorte[Contagem] := Pedidos[2,j] Pedidos[1,j] := 0 Pedidos[2,j] := 0 Pedidos[3,j] := 0 resposta:= "mudado" Retirados:= Retirados + 1 fimse fimse fimpara
procedimento optimiza_corte () inicio limpatela cabecalho() Cont:= TotalPedidos //Salva o total de pedidos para ordenao Retirar("<") //Rerira do Maior para o Menor Recalcula() //Recalcula Perda e Largura Total //Verifica se o calculo reduziu a perda senao tenta de outro modo Se Perda2 > Perda entao ordena_sequencia("<") //Ordena para Recolocar o que tirou Recoloca() //Recoloca Retirar(">") //Manda Retirar dessa vez do Menor para o Maior Recalcula() //Recalcula para conferir a Perda //Verifica se o novo calculo reduziu a perda senao desfaz toda a operacao se Perda2 > Perda entao ordena_sequencia("<") //Ordena para Recolocar o que tirou Recoloca() //Recoloca ordena_sequencia("<") //Ordena do maior para o menor Retorno:= "Nao foi Possivel Optimizar os Pedidos" //Define a resposta CalculaPerda () //Chama funcao de interface fimse senao ordena_sequencia("<") Retorno:= "Pedidos Optmizado" CalculaPerda ()
fimse fimprocedimento
//Procedimento Incial - Baboseiras de interface amigavel
procedimento inicial () inicio Cabecalho () escreval("") escreval(" Bem vindo ao sistema de optimizacao e cauculo das bobinas Jumbo esse") escreval(" sistema foi desenvolvido com o objetivo de facilitar o calculo de uma") escreval(" determinada quantidade de bobinas do mesmo tipo de diametro e peso de") escreval(" cada vez.") escreval("") escreval(" O sistema capaz de calcular at 20 pedidos por vez, desse modo ele") escreval(" no ir funcionar caso voc entre um valor maior que 20.") escreval("") escreval(" ---------------------------------------------------------------------") escreval(" Para iniciar o calculo digite INICIAR, para sair digite FIM ") escreva (" -> ") leia(resposta) resposta:= maiusc(resposta) se resposta = "INICIAR" entao limpatela EntraPedidos() senao fimalgoritmo fimse fimprocedimento