FACULDADE_ANHANGUERA_ENGENHARIA_DE_PROCE

Prévia do material em texto

FACULDADE ANHANGUERA
ENGENHARIA DE PROCESSOS DE PRODUÇÃO
ATIVIDADE PRÁTICA SUPERVISIONADA
Algoritmos e Programação
	
	
	
	
	
	
	
	
	
	
	
	
1º Semestre
Santo André/2013
ATIVIDADE PRÁTICA SUPERVISIONADA
Algoritmos e Programação
Atividade Prática Supervisionada apresentada ao
Curso de Engenharia de Processos de Produção,
Faculdade Anhanguera Educacional S.A., como
requisito parcial para obtenção do título de Engenheiro
de Processo de Produção.
Orientador: Prof.º Geraldo Zaccaro
1º Semestre
Santo André/2013
Relatório 1 - Conceitos Fundamentais de Programação
Etapa 1 – Passo 2
a) Noção de Algoritmos.
Algoritmo é uma sequencia lógica de informações que define ações simples, bem ordenadas para executar uma tarefa e se chegar a um resultado.
Como criar um algoritmo?
Para criar um algoritmo é necessário utilizar uma sequencia lógica de comandos simples ordenados de modo com que as tarefas fiquem perfeitamente estruturadas. Para definir o fim de um comando e o inicio de outro comando utilizamos “;”. Podem ser utilizados comandos de: comparação, repetição, decisão entre outros para alcançar o resultado desejado, porem os comandos devem ser ordenados seguindo um raciocínio lógico coerente, qualquer erro na lógica refletirá diretamente no funcionamento do programa.
b) Pseudo Linguagem.
 	Pseudo linguagem é uma técnica utilizada para se escrever algoritmos de forma simples utilizando apenas a linguagem humana para definir a ordem dos comandos e a sua lógica entre si. Desta maneira quem desenvolve o programa tem mais facilidade para definir os comandos e sua sequencia, estudar o funcionamento de pequenos blocos e estruturas sem ter que se preocupar com as técnicas de cada linguagem de programação que possa ser utilizada. Uma das técnicas de se escrever algoritmos é o Portugol, que inclusive dispõe de softwares para facilitar a escrita dos algoritmos.
c) Estrutura de um Programa.
	A estrutura de um programa é a definição de ações que serão executadas através de cálculos e variáveis, trabalhando a entrada e saída de dados. O programa “fluí” direcionando os dados e o usuário até um resultado que seja considerado satisfatório.
d) Tipos Primitivos para representação de Dados e Variáveis.
 	Tipos primitivos de dados são os dados mais simples que podem ser trabalhados, denominados categorias atômicas, por não ser possível sua decomposição em algo mais simples. Os tipos primitivos de dados são:
I. Inteiro.		conhecidos também como int ou integer, utilizado para números inteiros sem casas decimais.
II. Real.		conhecidos também como float ou decimal, utilizado para números reais (números com casas decimais).
III. Caractere.	conhecidos também como char ou string, utilizado para utilização por caracteres alfanuméricos (letras, números, etc...).
IV. Lógico.		conhecidos também como booleanos, utilizados para expressar valores lógicos como 0 e 1, true e false, etc...
e) Operadores Aritméticos, Lógicos e Relacionais.
I. Operadores Aritméticos.
	São ferramentas utilizadas em cálculos de expressões matemáticas utilizando quaisquer valores ou variáveis numéricas do tipo inteiro ou real; Sendo eles:
	(+)	- soma;
	(-) 	- subtração;
	(*)	- multiplicação;
	(/)	- divisão;
	(mod)	- módulo, (resto de uma divisão);
	(^) 	- exponenciação ou potenciação. 
II. Operadores Lógicos
	Usados para trabalhar valores lógicos. Como retorno apresentam sempre um booleano pois sua utilização é dada quase sempre pela combinação de dois ou mais operadores do tipo relacionais.
	(AND)		ou (&&) ("E");
	(OR)		ou (||) ("Ou");
	(NOT)		ou (!) - "negação";
III. Operadores Relacionais
	Usados para estabelecer uma relação entre operador e operando. Retorna sempre um booleano; true para uma relação verdadeira e false para uma relação falsa.
	(>)	- maior que;
	(<)	- menor que;
	(<>)	- ou (!=) diferente de;
	(>=)	- maior ou igual a;
	(<=)	- menor ou igual a;
f) Características do ambiente de desenvolvimento C.
	A Linguagem de programação C possui características notáveis, que vem sendo utilizada em outras linguagens de programação diretamente ou serviram de base para a evolução de novas linguagens de programação.
I. 	Programação estruturada. 
A programação em C deve ser estruturada, executando uma tarefa por vez, forçando o programador a trabalhar de forma organizada simples e eficiente (o comando “GO TO” é uma exceção a regra, que deve ser utilizado com cautela com o propósito de verificar falhas, executar testes entre outros procedimentos de revisão do programa).
II. 	Declarar antes de utilizar. 
A Linguagem de programação C exige que antes de se trabalhar um valor de uma variável seja necessário declarar esta variável.
III. 	Linguagem de alto nível.
A programação em C é extremamente simples muito utilizada para fins acadêmicos, mesmo este não sendo o objetivo real desta linguagem.
IV. 	Acesso de baixo nível.
Com a linguagem C é possível ter acesso direto a memória e executar tarefas de baixo nível, tornando possível a utilização para desenvolvimento de programas de base, aproveitamento de programas criados inicialmente em Assembly, utilização de ponteiros, entre outros.
Passo 3
Realizar as seguintes atividades:
1. Desenvolver uma função matemática que resuma o cálculo do peso teórico de uma Bobina Filha. Fórmula:
Peso = Largura x (Diâmetro externo / 1000) x Peso por metro linear:
i. Peso = 660 x (1000 / 1000) x 0,610;
ii. Peso = 660 x 1 x 0,610;
iii. Peso = 402,60 _ 403 Kg;
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;
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;
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;
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.
Passo 3 escrito algebricamente.
1) Peso = Largura x (Diâmetro externo / 1000) x Peso por metro linear:
Pontos i, ii e iii:
Onde:
x = Peso
L = Largura
 =Diâmetro externo
T = Peso por metro linear
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;
x = 402,6 x ≈ 403
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;
x = x ≈ 515
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;
x = x ≈ 574
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.
x = x ≈ 924
Passo 3 escrito em linguagem C.
//Bibliotecas necessárias para a execução do programa
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
main()
{
//Declaração de variáveis
float peso, largura, pesoLinear, diametroExterno;//Variáveis tipo float declaradas
int constante = 1000; //Declarando uma variável com valor predeterminado de valor simples inteiro
// inteface do programa com o usuário
printf("\nDigite a largura da bobina"); //Pergunta ao usuário a largura da bobina
scanf ( "%f", &largura ); //Armazena na memória o valor digitado pelo usuário para a largura da bobina
printf("\nDigite diametro externo da bobina"); //Pergunta ao usuário diametro externo da bobina
scanf ( "%f", &diametroExterno ); //Armazena na memória o valor digitado pelo usuário para o diametro externo da bobina
printf( "\ndigite o peso por metro linear - Utilize ponto e nao virgula para valores decimais"); //Digitar valores com ponto e não com virgula 0.620
scanf ( "%f", &pesoLinear); //Armazena na memória o valor digitado pelo usuário para o peso em metro linear da bobina
 
// calculo do peso final
peso = largura * (diametroExterno/constante) * pesoLinear;
printf("\nPeso teorico da bobina filha %2.2f", peso );// imprimindo o peso final na tela pra o usuário 
getch();//segura a tela doprograma
}//fim do programa
Relatório 2 – Programação Estruturada
Etapa 2 – Passo 2
A programação estruturada nada mais é do que uma técnica que estabelece uma padronização de desenvolvimento de algoritmos que facilita a compreensão de programas através de mecanismos de controle da execução de programas em quantidades restritas. Todo e qualquer algoritmo, independentemente da aplicação e da linguagem de programação na qual será codificado, pode ser descrito através destes mecanismos básicos.
	O princípio básico de programação estruturada é que um programa é composto por blocos de código que se interligam através de três mecanismos básicos, que são sequencia, seleção e iteração. Cada uma destas construções tem um ponto de início (o topo do bloco) e um ponto de término (o fim do bloco) de execução.
	A sequencia implementa os passos de processamento necessários para descrever qualquer programa. 
Passo 3
Algoritmo unificado para atender as necessidades da etapa 3 do ponto a até e, em Portugol
// Função : Calcular o Peso Teórico de uma bobina filha
// Seção de Declarações
var Diametro, PesoMetro, PesoTeorico, LarguraTotal, PesoTotal, largura:Real
    NumeroBobinas, Contagem:inteiro
inicio
Contagem <- 1
PesoTotal <- 0
LarguraTotal <- 0
escreva("Quantas Bobinas Filhas Possui o Pedido?")
leia(NumeroBobinas)
enquanto (NumeroBobinas >= Contagem) faca
escreva("Bobina numero: ",Contagem)
escreva("Qual Largura Dessa Bobina Filha?")
leia(Largura)
escreva("Qual Peso Por Metro Linear Dessa Bobina Filha?")
leia(Diametro)
escreva("Qual Diametro Dessa Bobina Filha?")
leia(PesoMetro)
PesoTeorico <- (Largura * (Diametro / 1000)) * PesoMetro
escreva("Peso Teorico dessa bobina filha",PesoTeorico)
LarguraTotal <- LarguraTotal + Largura
PesoTotal <- PesoTotal + PesoTeorico
Contagem <- Contagem + 1
fim enquanto
escreva("========================================")
escreva("Lagura total do pedido: ",LarguraTotal)
escreva("Peso total do pedido: ",PesoTotal)
escreva("========================================")
fim algoritmo
Algoritmo unificado para atender as necessidades da etapa 3 do ponto a até e, em C
#include <stdio.h>
#include <stdlib.h>
void calcula() {
 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("# Centro Universitario Anhanguera Santo Andr		 # \n");
 printf("# ATPS - Algoritimos e Programacao 		 # \n");
 printf("# Engenharia de Produção 		# \n");
 printf("############################################## \n");
 calcula();
 int escolha;
 printf("\nDeseja realizar outro Calculo [1] - Sim, [0] - Nao ?\n");
 scanf("%i", &escolha);
 if(escolha == 1) {
 printf("\n============================================\n");
 calcula();
 
 } else {
 
 system("PAUSE");
 return 0;
 };
 };
Relatório 3 – Vetores e Matrizes. Modularização
Passo 2
Vetores e matrizes
	Vetores e matrizes são variáveis multidimensionais, que evitam a necessidade da declaração de inúmeras variáveis em códigos mais extensos.
	Utilizando vetores e matrizes resumimos em poucas linhas de código o que seria necessário inúmeras linhas somente para a declaração de variáveis. Conbinando laços de repetição e decisão podemos associar valores a vetores e matrizes de forma automática tornando o código muito mais limpo e executável.
Modularização
	Modularização na área de TI é um conceito onde o sistema ou software é divido em partes. Estas partes são distintas, únicas e funcionais que compõe o corpo de um programa mais legível, facilitando a manutenção e melhorando o desempenho dos programadores por meio da programação estruturada.
	A modularização auxilia amplamente o conceito de aproveitamento de rotinas e criação de bibliotecas, tornando programas mais leves e facilitando sua evolução. Eis algumas das características positivas da modularização: Elemento separadamente endereçável do sistema, menor parte do sistema que realiza uma função completa independente de outras funções, conjunto de instruções de um programa que pode ser chamado por um nome, sendo ideal que para os outros módulos.
	A modularização de programas utiliza vários recursos disponíveis na maior parte das linguagens de programação como funções e procedimentos para isolar cada etapa de um programa facilitando a compreensão do código e o tornando mais organizado. É amplamente usado em modularização o uso de Vetores e Matrizes.
Passo 3
 	No programa solicitado na ATPS o código foi divido em diversas funções para modularizar o programa sendo elas
1) Procedimento Cabeçalho.
	Este procedimento chama um texto padrão de cabeçalho, é utilizada no decorrer do programa quando a tela é limpa para recolocar o cabeçalho.
2) Procedimento EntraPedidos.
	Esse procedimento pergunta quantos pedidos o usuário deseja digitar, sendo considerado como um pedido um corte de bobina, através de um laço de repetição a função alimenta os vetores e matrizes que contém as informações dos pedidos para cada pedido que o usuário inserir.
3) Procedimento Imprime_Pedido
	Esse procedimento é responsável por imprimir os pedidos e a sequência de corte, nela que é gerada a sequência de corte mesmo que o pedido não seja otimizado, a sequência de corte criada nessa função exibe a melhor sequência de corte economizando o máximo possível de cada bobina jumbo, essa função chama outra função para imprimir cada pedido, e ao final pergunta se o usuário deseja entrar mais pedidos ou encerrar o cálculo.
4) Procedimento Recoloca
	Esse procedimento reverte o procedimento de otimização que retirar alguns pedidos para reduzir a perda.
5) Procedimento Pedidos_I
	Nesse procedimento é impresso os pedidos, ela é utilizada diversas vezes no decorrer do programa.
6) Procedimento ordena_sequencia
	Esse procedimento é utilizada para ordenar considerando a largura de cada pedido a matriz que contém as informações dos pedidos, ela é utilizada diversas no programa recendo como parâmetro uma variável caractere que indica se a ordenação vai ser em ordem ascendente ou descendente.
7) Procedimento CalculaPerda
	Esse procedimento soma a largura de todos os pedidos e calcula a perda, após isso exibe os valores totais dos pedidos para o usuário e pergunta se ele deseja otimizar ou imprimira sequência de corte.
8) Procedimento Retirar
	Esse procedimento faz parte do processo de otimização do calculo ela tenta retirar pedidos para diminuir a perda.
9) Procedimento Recalcula
	Esse procedimento é utilizado após serem retirados pedidos para   recalcular os valores totais como largura, peso, total de pedidos e perda.
10) Procedimento Otimiza_corte
	Esse procedimento agrupa procedimentos menores para criar a otimização dos pedidos.
11) Procedimento inicial
	Esse procedimento tem a função de criar uma interface amigável, imprime na tela para o usuário um texto que explica as características do programa e pergunta se o usuário deseja iniciar a entrada de pedidos se sim chama a EntraPedidos senão a encerra o programa.
Código do Programa
Algoritmo para o calculo das bobinas 
var
NomeCliente,resposta,teemp,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
//Cabeçalho
procedimento Cabecalho ()
inicio
escreva("##################################################################")
escreva("#                                                                           #")
escreva("#          Centro Universitario Anhanguera Santo Andre #")
escreva("#       ATPS - Algoritimos e Programacao #")
escreva("# Ricardo de Souza Ferreira, Robson Gonsalves de Oliveira, #")
escreva("# Andreia A. L. Ferreira, Fábio Félix Cavallari e Jeferson Leite Bonfim #")
escreva("#                                                                           #")
escreva("#################################################################")
fim procedimento
//Função para o Calculo de Bobinas
procedimento EntraPedidos()
  inicio
  limpatela
  Cabecalho()
  escreva("")
  escreva("=======================================")
  escreva("Informações do Tipo de Bobina")
  escreva("------------------------------------------------------------------")
  escreva("")
  escreva("Largura Total (Mm): ")
  leia(LarguraJumbo)
  escreva("Peso por Metro (Kg): ")
  leia(Peso)
  escreva("Diametro (Mm): ")
  leia(Diametro)
  limpatela
  escreva("==================================================================")
  escreva("Quantos Pedidos Deseja Incluir? (Máximo 20 Pedidos)")
  leia(TotalPedidos)
  se TotalPedidos > 20 entao
      limpatela
      Cabecalho ()
      escreva("")
      escreval ("<<<<< ENTRE UM VALOR MENOR QUE 20 NO CAMPO PEDIDOS >>>>>")
      escreva("")
      EntraPedidos()
  fimse
  Contagem:= 1
  enquanto (Contagem <= TotalPedidos) faca
      Pedido_ID:= Contagem
      escreva("")
      escreva("------------------------------------------------------------------")
      escreva("== Entre os dados do pedido número: ",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
  fim enquanto
  limpa tela
  Cabecalho ()
  CalculaPerda ()
fim procedimento
//Função para imprimir um pedido aprovado
procedimento imprime_pedido()
  inicio
  limpatela
  Cabecalho ()
  escreva("")
  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
            teemp := Clientes[i]
            Clientes[i] := Clientes[i+1]
            Clientes[i+1] := teemp
        fimse
      fimpara
      j:= j-1
  fimenquanto
  escreva("")
  escreva("=============================================================")
  escreva("                     Sequencia de Corte                       ")
  escreva("=============================================================")
  //Imprime na melhor sequencia
  Contagem:= 1
  Retirados:= 0
  Para cont de 1 ate int(TotalBobinas) faca
  escreva("---------------         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
              escreva(Contagem,"º - Cortar: ",SequenciaCorte[Contagem]," Mm - ",Porcentagem,"%")
              Contagem:= Contagem + 1
            fimse
        fimse
          resposta:= ""
      fimenquanto
  fimpara
  escreva("")
  escreva("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
//Função 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
// Seção de Comandos
  escreva("")
  //Imprimir Pedidos
  escreva("")
  escreva("============================================================================")
  escreva("                                 Pedidos                                     ")
  escreva("____________________________________________________________________________")
  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])
        escreva(" | Cliente: ",Clientes[Contagem])
        escreva("----------------------------------------------------------------------------")
      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
                  teemp := Clientes[i]
                  Clientes[i] := Clientes[i+1]
                  Clientes[i+1] := teemp
              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
                  teemp := Clientes[i]
                  Clientes[i] := Clientes[i+1]
                  Clientes[i+1] := teemp
              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()
  escreva("")
  escreva("Bobinas necessarias: ",TotalBobinas)
  escreva("Refugo Comercial(Sobra): ",Perda,"%")
  escreva("Largura Total: ",LarguraTotal)
  escreva("Peso Total: ",PesoTotal)
  escreva("Total de Pedidos: ",TotalPedidos)
  escreva("Otimização: ", Retorno)
  se Retirados > 0 entao
    escreva("")
    escreva("===================== Pedidos Retirados ========================")
    para Contagem de 1 ate Retirados faca
            escreva("Pedido : ",PedidosRetirar[1,Contagem])
            escreva(" | Quanditade: ",PedidosRetirar[2,Contagem])
            escreva(" | Cliente: ",ClientesRetirados[Contagem])
            escreva("________________________________________________________________")
    fimpara
    escreva("")
    escreva("Deseja Recolocar esses Pedidos na sequencia? SIM / NAO")
    leia(resposta)
    se resposta = "SIM" entao
        Recoloca()
        CalculaPerda ()
        escreva("")
    fimse
  fimse
  escreva("")
  escreva("------------------------------------------------------------------------------")
  escreva("Deseja aprovar esse pedido?")
  escreva("Digite SIM para imprimir a sequência de corte ou NAO para Otimizar")
  escreva("-> ")
  leia(resposta)
  resposta:= maiusc(resposta)
  se resposta = "SIM" entao
      limpatela
      imprime_pedido()
  senao
        se resposta = "NAO" entao
          Otimiza_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
//Otimização do Corte
procedimento Otimiza_corte ()
  inicio
  limpatela
  cabecalho()
  Cont:= TotalPedidos //Salva o
total de pedidos para ordenação
  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 paraconferir 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 Otimizar 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 ()
  escreva("")
  escreva("   Bem vindo ao sistema de Otimizacao e Calculo das bobinas Jumbo   esse")
  escreva("   sistema foi desenvolvido com o objetivo de facilitar o calculo de uma")
  escreva("   determinada quantidade de bobinas do mesmo tipo de diametro e peso de")
  escreva("   cada vez.")
  escreva("")
  escreva("   O sistema é capaz de calcular até 20 pedidos por vez, desse modo   ele")
  escreva("   não irá funcionar caso você entre um valor maior que 20.")
  escreva("")
  escreva("   ---------------------------------------------------------------------")
  escreva("         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()
fim do algoritmo.