Professional Documents
Culture Documents
(*) - 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
};
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
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
Esseprocedimento 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 realPedidos: 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
limpatelaCabecalho()
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 ========================")
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
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