ENGENHARIA MECANICA

ANDERSON LUIS PINTO RA: 6893527885

ATPS: ALGORITMO

LIMEIRA 2013

ATPS: Algoritmo

Projeto de pesquisa apresentado Faculdade Anhanguera de Limeira, como atividade de Algoritmo, sob responsabilidade do Prof. Renato

Orientador: Prof. Renato

Limeira 2013

ATPS: Algoritmo

Limeira, ___ / ____________________ de 2013.

Nota: ____, ____

_____________________________________ Prof. Renato Faculdade Anhanguera de Limeira

Algoritmo

Encontramos diferentes definies para algoritmo, algumas tratam uma simples receita de bolo como um algoritmo, outros autores consideram esses exemplos simplificaes demasiadas do conceito e preferem associar o conceito de algoritmo a solues computacionais.

Neste aspecto, podemos expressar a soluo de qualquer problema na forma de algoritmo, desde o mais simples ao mais complexo e independente se solucionveis no universo real, ou no universo computacional.

No dia-a-dia nos deparamos com diversos problemas que podem ser expressos na forma de algoritmos, alguns simples rotinas como escovar os dentes, ir faculdade, preparar um suco de frutas, uma receita para fazer salada de batatas, as regras para calcular uma equao de primeiro grau e muitos outros.

Em todos os algoritmos so identificadas caractersticas comuns, que so sries finitas e bem definidas de passos ou regras que, quando realizadas, produzem um determinado resultado.

Neste trabalho preferimos a definio de algoritmo como sendo:

Um conjunto de aes com propriedades especiais e especificas e com algumas estruturas padres para controlar a ordem na qual as aes so realizadas.

Etapa 1 - Algoritmos

/*conversor de moedas*/ #include <stdio.h> #include <stdlib.h> Int main (){ float real, dolar, dolarc, euro; printf (digite o valor em real\n); scanf (%f,& real); dlar=real/1.95 system (pause) return 0; } ; printf(dlar:%.2f\n, dlar);

/*conversor de moedas*/ #include <stdio.h> #include <stdlib.h> Int main (){ float real, dolar, dolarc, euro; printf (digite o valor em real\n); scanf (%f,& real); dlar=real/1.95 ; printf (\ndolar:%14.2f\n, dlar); dolarc=real/1.89; printf ((\ndolar canadense:%.2f\n, dolarc); euro=real/2.50; printf (\neuro:%15.2f\n, euro); system (pause) return 0; }

/*conversor de moedas*/ #include <stdio.h> #include <stdlib.h> Int main (){ float real,dolar,dolarc,euro,vmoeda,resul; int opcao1,opcao2; printf(digite qual a conversao deseja:\n) printf(1 - dolar\n); printf(2 - dolar canadense\n); printf(3 - euro\n\n); printf(opcao:); scanf(%d, & opcao1); if(opcao1==1){ printf(Voce escolheu a moeda dolar!); vmoeda=1.95; printf (qual o valor desejado em real?\n); scanf (%f,& real); resul=real/vmoeda; printf(\resultado:$%.2f\n\n,resul); } else if(opcao1==2){ printf(Voce escolheu a moeda dolar canadense!); vmoeda=1.89; printf (qual o valor desejado em real?\n); scanf (%f,& real); resul=real/vmoeda; printf(\resultado:$%.2f\n\n,resul); } else if(opcao1==3){ printf(Voce escolheu a moeda euro!); vmoeda=2.50; printf (qual o valor desejado em real?\n); scanf (%f,& real); resul=real/vmoeda; printf(\resultado:$%.2f\n\n,resul); } else

{printf("valor incorreto"); } system (pause) return 0; }

Pseudocdigo

/*conversor de moedas*/ conversor_de_real(){ reais real, dlar, dlar c, euro escreve (digite o valor em real) salva (real) dolar =real/1.95 escreve (dlar) dlar canadense = real/1.89 escreve (dlar canadense) euro = real/2.50 escreve (euro) }

Documente essa etapa de estudos apresentando quais foram os resultados alcanados em cada Passo. Por isso, elaborem um relatrio, a ser entregue ao gerente do projeto - professor da disciplina, contendo capa, sumrio, descrio e a anlise que a equipe fez do problema, descrio dos algoritmos explicando a lgica utilizada, apresentao dos fluxogramas e referncias bibliogrficas. Usem as normas da ABNT para a apresentao adequada do

Conforme proposto nesta etapa 4 foi documentado e registrados todas as informaes dos passos anteriores.

Realizado leitura do texto: Introduo Programao de Computadores para

Cursos de Engenharia e de Automao.

Pelo que li e vi no texto todos os pontos so importantes, ainda mais se tratando de uma pessoa leiga no assunto. Algoritmo e programao novo para mim por este motivo todos os pontos so importantes.

#include <stdio.h> #include <stdlib.h> float pesoteorico; int largura, comprimento; nbobinasjumbo = somaquantidadepedido / pesobobinajumbo; printf ("o numerode bobinas jumbo com 2450 mm e %2f", nbobinasjumbo); printf("a largura total ultilizada e 2%f", totallargurabobinasfilhas); float perdacomercial = 1-(totallargurabobinasfilhas / 2450); printf(" o numero de bobinas jumbo com 2450 mm e 2%f /% ", nbobinasjumbo); system("PAUSE"); return 0; } #include <stdio.h> #include <stdlib.h> float pesoteorico; int largura, comprimento; nbobinasjumbo = somaquantidadepedido / pesobobinajumbo;

printf ("o numerode bobinas jumbo com 2450 mm e %2f", nbobinasjumbo); printf("a largura total ultilizada e 2%f", totallargurabobinasfilhas); float perdacomercial = 1-(totallargurabobinasfilhas / 2450); printf(" o numero de bobinas jumbo com 2450 mm e 2%f /% ", nbobinasjumbo); system("PAUSE"); return 0; } #include <stdio.h> #include <stdlib.h> float pesoteorico; int largura, comprimento; nbobinasjumbo = somaquantidadepedido / pesobobinajumbo; printf ("o numerode bobinas jumbo com 2450 mm e %2f", nbobinasjumbo); printf("a largura total ultilizada e 2%f", totallargurabobinasfilhas); float perdacomercial = 1-(totallargurabobinasfilhas / 2450); printf(" o numero de bobinas jumbo com 2450 mm e 2%f /% ", nbobinasjumbo); system("PAUSE"); return 0; } #include <stdio.h> #include <stdlib.h> float pesoteorico; int largura, comprimento; nbobinasjumbo = somaquantidadepedido / pesobobinajumbo; printf ("o numerode bobinas jumbo com 2450 mm e %2f", nbobinasjumbo);

printf("a largura total ultilizada e 2%f", totallargurabobinasfilhas); float perdacomercial = 1-(totallargurabobinasfilhas / 2450); printf(" o numero de bobinas jumbo com 2450 mm e 2%f /% ", nbobinasjumbo); system("PAUSE"); return 0; } #include <stdio.h> #include <stdlib.h> float pesoteorico; int largura, comprimento; nbobinasjumbo = somaquantidadepedido / pesobobinajumbo; printf ("o numerode bobinas jumbo com 2450 mm e %2f", nbobinasjumbo); printf("a largura total ultilizada e 2%f", totallargurabobinasfilhas); float perdacomercial = 1-(totallargurabobinasfilhas / 2450); printf(" o numero de bobinas jumbo com 2450 mm e 2%f /% ", nbobinasjumbo); system("PAUSE"); return 0; }
Realizado as seguintes leituras: Tipos Estruturados Introduo Programao de Computadores para Cursos de Engenharia e de Automao. Captulos Livro Funes Matrizes e Strings

 Treinamento em Linguagem C

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 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("--------------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 Bobina ",Cont, " ---------------")

fimse se resposta <> "mudado" entao Largura_Sequencia:= Largura_Sequencia + ((LarguraJumbo Largura_Sequencia)+1)

senao se SequenciaCorte[Contagem] > 0 entao escreval(Contagem," - Cortar: ",SequenciaCorte[Contagem]," Mm ",Porcentagem,"%") Contagem:= Contagem + 1 fimse fimse resposta:= ""

fimenquanto fimpara escreval("") escreval("Para realizar outra sequencia de pedidos digite CALCULAR, para sair digite FIM") escreva("->") leia(resposta) se resposta = "CALCULAR" entao TotalPedidos:= 0 LarguraTotal:= 0 Largura:= 0 Contagem:= 0 Retirados:= 0 Perda:= 0 QuantidadeRetirar:=0 limpatela

Cabecalho() EntraPedidos() senao fimalgoritmo fimse fimprocedimento

//Funcao Para Recolocar Pedidos Retirados

procedimento Recoloca()

inicio limpatela j:= Retirados para Contagem de 1 ate j faca Pedidos[1,TotalPedidos+1]:= PedidosRetirar[1,Contagem] Pedidos[2,TotalPedidos+1]:= PedidosRetirar[2,Contagem] Pedidos[3,TotalPedidos+1]:= PedidosRetirar[3,Contagem] Clientes[TotalPedidos+1]:= ClientesRetirados[Contagem] SomaRetira:= SomaRetira - PedidosRetirar[2,Contagem] TotalPedidos:= TotalPedidos + 1 ClientesRetirados[Contagem]:= "" PedidosRetirar[1,Contagem] := 0 PedidosRetirar[2,Contagem] := 0 PedidosRetirar[3,Contagem] := 0 Retirados:= Retirados - 1

fimpara ordena_sequencia(">") //Reajusta Valores Temp:= 0 para j de 1 ate TotalPedidos faca Temp := Temp + Pedidos[2,j] fimpara LarguraTotal := Temp PesoTotal := (LarguraTotal * (Diametro / 1000)) * Peso fimprocedimento

//Imprimir apenas os pedidos procedimento Pedidos_I() inicio // Seo de Comandos escreval("") //Imprimir Pedidos escreval("") escreval("========================================================= ===================") escreval(" Pedidos ")

escreval("____________________________________________________________ ________________") Para Contagem de 1 ate TotalPedidos faca se Pedidos[2,Contagem] > 0 entao escreva("Pedido N: ",Pedidos[1,Contagem]) escreva(" | PesoTeorico: ",Pedidos[3,Contagem]) escreva(" | Largura Mm: ",Pedidos[2,Contagem]) escreval(" | Cliente: ",Clientes[Contagem]) escreval("----------------------------------------------------------------------------") fimse fimpara fimprocedimento

//Procedimento para Ordenar o Vetor

procedimento ordena_sequencia(ordem:caractere) inicio escolha ordem caso ">" j:= Cont 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 caso "<" j:= Cont 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 fimescolha fimprocedimento

//funcao para aprovacao dos pedidos

procedimento CalculaPerda () inicio ValidaBobinas:= (LarguraTotal / int((LarguraTotal / LarguraJumbo)+1)) se ValidaBobinas = LarguraJumbo entao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) Perda:= 0 senao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) + 1 Perda:= 100 - (((LarguraTotal / LarguraJumbo) - int((LarguraTotal / LarguraJumbo))) * 100) fimse se Perda = 100 entao

Perda := 0 TotalBobinas:= TotalBobinas-1 fimse Pedidos_I() escreval("") escreval("Bobinas necessarias: ",TotalBobinas) escreval("Refugo Comercial(Sobra): ",Perda,"%") escreval("Largura Total: ",LarguraTotal) escreval("Peso Total: ",PesoTotal) escreval("Total de Pedidos: ",TotalPedidos) escreval("Optimizao: ", Retorno) se Retirados > 0 entao escreval("") escreval("===================== Pedidos Retirados ========================") para Contagem de 1 ate Retirados faca escreva("Pedido : ",PedidosRetirar[1,Contagem]) escreva(" | Quanditade: ",PedidosRetirar[2,Contagem]) escreval(" | Cliente: ",ClientesRetirados[Contagem]) escreval("_______________________________________________________ _________") fimpara

escreval("") escreval("Deseja Recolocar esses Pedidos na sequencia? SIM / NAO") leia(resposta) se resposta = "SIM" entao Recoloca() CalculaPerda () escreval("") fimse fimse escreval("") escreval("------------------------------------------------------------------------------") escreval("Deseja aprovar esse pedido?") escreval("Digite SIM para imprimir a sequncia de corte ou NAO para optimizar") escreva("-> ") leia(resposta) resposta:= maiusc(resposta) se resposta = "SIM" entao limpatela imprime_pedido() senao se resposta = "NAO" entao optimiza_corte () fimse fimse fimprocedimento

procedimento Retirar(Ordem:caractere)

inicio ordena_sequencia(Ordem) //Ver quanto Precisa ser retirado para reduzir a perda QuantidadeRetirar := LarguraTotal - (LarguraJumbo * int((LarguraTotal / LarguraJumbo))) //Analizar Quais Pedidos Podem Ser Retirados para Contagem de 1 ate TotalPedidos faca se (SomaRetira + Pedidos[2,Contagem]) <= QuantidadeRetirar entao se (Pedidos[2,Contagem] <= QuantidadeRetirar) e (Pedidos[2,Contagem] > 0)

entao Retirados:= Retirados + 1 PedidosRetirar[1,Retirados] := Pedidos[1,Contagem] PedidosRetirar[2,Retirados] := Pedidos[2,Contagem] PedidosRetirar[3,Retirados] := Pedidos[3,Contagem] ClientesRetirados[Retirados]:= Clientes[Contagem] Pedidos[1,Contagem] := 0 Pedidos[2,Contagem] := 0 Pedidos[3,Contagem] := 0 TotalPedidos:= TotalPedidos - 1 SomaRetira:= SomaRetira + PedidosRetirar[2,Retirados] fimse senao para j de 1 ate Cont faca se ((SomaRetira + Pedidos[2,j]) <= QuantidadeRetirar) e (Pedidos[2,j] > 0) entao Retirados:= Retirados + 1 PedidosRetirar[1,Retirados] := Pedidos[1,j] PedidosRetirar[2,Retirados] := Pedidos[2,j] PedidosRetirar[3,Retirados] := Pedidos[3,j] ClientesRetirados[Retirados]:= Clientes[j] Pedidos[1,j] := 0 Pedidos[2,j] := 0 Pedidos[3,j] := 0 TotalPedidos:= TotalPedidos - 1 SomaRetira:= SomaRetira + PedidosRetirar[2,Retirados] fimse fimpara fimse fimpara fimprocedimento

//Recalcula

procedimento Recalcula()

inicio //Reajusta Valores Temp:= 0 para Contagem de 1 ate Cont faca Temp := Temp + Pedidos[2,Contagem] fimpara LarguraTotal := Temp PesoTotal := (LarguraTotal * (Diametro / 1000)) * Peso //Vendo se a perda maior ValidaBobinas:= (LarguraTotal / int((LarguraTotal / LarguraJumbo)+1)) se ValidaBobinas = LarguraJumbo entao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) Perda2:= 0 senao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) + 1 Perda2:= 100 - (((LarguraTotal / LarguraJumbo) - int((LarguraTotal / LarguraJumbo))) * 100) fimse se Perda2 = 100 entao Perda2 := 0 TotalBobinas:= TotalBobinas-1 fimse

fimprocedimento

//Optimizao do Corte

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() Retirar(">") Recalcula() //Recoloca //Manda Retirar dessa vez do Menor para o Maior //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(" escreva (" leia(resposta) resposta:= maiusc(resposta) se resposta = "INICIAR" entao limpatela EntraPedidos() senao fimalgoritmo fimse fimprocedimento Para iniciar o calculo digite INICIAR, para sair digite FIM -> ") ")

inicio

//Inicio do Codigo Inicial()

fimalgoritmo

Gostaria de Agradecer o Professor Renato por todo seu esforo em nos passar uma parte de seu conhecimento.

O meu muito OBRIGADO..........