Você está na página 1de 34

FACULDADE ANHANGUERA DE SO CAETANO DO SUL

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

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() //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

inicio

//Inicio do Codigo
Inicial()

fimalgoritmo