Resposta do problema da caixa

Programa 7 - Volume da caixa em C

1. #include <stdio.h>
2. 
   
3. // Programa que procura o volume máximo de uma caixa, restrito à uma dada área superficial..
4. 
   
5. int main(){
6.            int c=0,a=0;
7. //"c" é o limite de iterações do While da linha 28; a é o auxiliar para diminuir o tempo de busca.
8. 
   
9.            float area=0,x=0,y=0,z=0,v=0,vs=0,xs=0,ys=0,zs=0;
10. // "area" é o valor que irá ser digitado. As variáveis x,y,z,v irão ser usadas na busca da solução. As variáveis xs,ys,zs,vs  irão armazenar o valor das melhores soluções.
11.            
12.            srand(time(NULL)); // Faz o rand() gerar valores distintos a cada execução.
13.            
14.            printf("Digite o valor da area superficial da caixa.\n");
15.            scanf ("%f",&area);
16.            
17.            //area = 255,45; // Para testar a capacidade de achar uma solução ótima, define-se um valor arbitrário e executa o programa n vezes
18.            
19.            if(area<=1){a=1;}
20.            if(area<=10){a=10;}
21.            if(area<=100){a=100;}
22.            if(area<=1000){a=1000;} // Otimizando o gasto computacional
23.            if(area<=10000){a=10000;}
24.            if(area<=100000){a=100000;}
25. 
    
26.            while(c<1000){ // Quanto maior o limite de c, maior o gasto computacional, porém melhor é o resultado.
27.                           x=rand()%a;
28.                           y=rand()%a;
29.               
30.                           while(x>area){x=rand()%a;} // "a" reduz o tempo de busca pois limita a busca a valores próximos do esperado..
31.                           while (2*x*y>area){y=rand()%a;}
32.                           z=( (area/2)-(x*y) )/(x+y);  // Lembrar que Área superficial = 2(xy+xz+yz)
33.               
34.                           v=x*y*z; // Cálculo do volume..
35.                           if(v>vs){vs=v;xs=x;ys=y;zs=z;} // Se a solução é melhor, substitui valores..
36.                           c++;
37.                          }// Fim While
38.               
39.            printf ("\n\nVolume maximo: %f \n\nAs medidas sao x=%.2f\ty=%.2f\tz=%.2f\n\n",vs,xs,ys,zs);
40. //Nessa linha, o código %.2f ordena imprimir até as 2 primeiras casa decimais do resultado.
41.            
42.            system("pause");
43.            }// Fim Main

       Nesse programa é interessante observar a tática usada para diminuir o tempo de busca do computador. Nas linhas 19 até 24, "a" é determinado de acordo com cada área superficial dada. Ou seja, quando nas linhas 27 e 28 efetua-se  x=rand()%a e  y=rand()%a obtemos valores menores que a área superficial, e ainda, provavelmente mais próximos da solução ideal. Lembrar que esse programa é aleatório. Se você executá-lo várias vezes, poderá obter resultados diferentes, entretanto satisfatórios em sua maioria. Esse é o princípio da busca aleatória, que é feita em programas de otimização.

       Novamente vemos as linhas rand () e srand(time(NULL)). Ambas são funções e fazem parte da biblioteca padrão de C. A linha rand() gera um número randômico qualquer. A linha srand(time(NULL)) faz com que esse número seja diferente a cada execução do programa, pois estabelece uma relação com o relógio do computador.

       Bem, por hoje é só. No próximo post, alguns exercícios de C, do estilo dos que eu fiz quando fazia a disciplina de algoritmos no IFET, e que podem cair em provas. Para quem está fazendo a disciplina, é uma boa.

Boa semana à todos!

Estruturas de repetição (2)

       Boa noite! Hoje o post é a continuação das estruturas de repetição. Vou falar do "For infinito", do While e aproveitando o gancho, sobre o conceito de programação estocástica (aleatória). Esse tipo de programação consiste na aproximação do resultado ideal, por uma busca aleatória. No final um desafio, que devo postar a resposta em breve...Vou considerar o For infinito uma extrapolação do uso convencional do for convencional. Lembrando, o for convencional tem a seguinte forma : For(inicialização;limite;incremento){Comandos;} . O For infinito pode se dar de algumas formas: 

                       For( ; ; ){Comandos;}
                       For(inicialização ; ;){Comandos;} 
                       For(; ; incremento){Comandos;}

                       For(inicialização ; ; incremento){Comandos;}

       Note: no primeiro caso, nada se estabelece para o For, ou seja, ele irá executar o comando indefinidamente, até que alguma condição seja atendida e o loop seja encerrado, ou até o programa "dar pau". Digo isso, pois não conheço a fundo as implicações desse uso do For, podem haver erros inesperados em sua execução. Já o segundo tipo, possui um início e um padrão de crescimento/decrescimento, porém não possui um limite.

       Para sair de um For infinito, como eu já mencionei, é preciso impor uma condição de saída, com um comando que encerre o loop. Veja a seguir:

Trecho 1

1. int i;
2. for(;;){
3. 
   
4.           i++;
5.           if(i>50)break; // Condição e comando de saída 
6.           printf("%d",i);
7.           
8.          }

Trecho 2

1. int i;
2. for(i;;){
3. 
   
4.           i++;
5.           if(i>50)break; // Condição e comando de saída 
6.           printf("%d",i);
7.           
8.          }

Trecho 3

1. int i;
2. for(;;i++){
3. 
   
4.           if(i>50)break; // Condição e comando de saída 
5.           printf("%d",i);
6.           
7.          }

Trecho 4

1. int i;
2. for(i;;i++){
3. 
   
4.           if(i>50)break; // Condição e comando de saída 
5.           printf("%d",i);
6.           
7.          }

      Como você imagina as saídas desses programas? São iguais? A resposta é não. Os trechos 1 e 2 irão fazer uma contagem de 1 a 50, enquanto que os trechos 3 e 4 de 0 a 50.

      

      Quanto ao While: seu uso, como eu disse no post Estruturas de repetição (1), é para algo que você sabe onde irá acabar, ou ao menos para que se atinja um valor esperado. Imagine o seguinte: você tem um problema muito grande de Programação Linear (otimização), que te dá milhões de possibilidades de soluções. Logo, para percorrer todo o cenário de respostas possíveis, o tempo de operação do computador é muito grande, acredite.

      O que você faz? Faz o que chamamos de busca aleatória. Você escolhe pontos por onde procurar a solução, e, por exemplo, com o uso do While, estabelece um pré valor esperado para sua solução, por exemplo Lucro = 5000 Reais. Feito isso, a primeira solução que o programa encontrar que te dê R$ 5000 ou mais de lucro, ele apresenta à você. A ideia é simples assim. Entretanto sua aplicação nem tanto. Conheço vários professores  e alunos daqui da UFJF, que estudam esse estilo de programação, tanto em C,C++,Matlab,etc... é um assunto interessante que irei retomar em um próximo post.

      Basicamente o While se dá assim: While(Condição){Comandos;}. Veja:

Programa 6 - Busca aleatória do lucro em C.

1. #include <stdio.h>
2. 
   
3. int main () {
4. 
   
5. int lucro=0,x=0,y=0,contador=0;
6. srand(time(NULL)); // Essa linha é responsável pelo rand() abaixo, gerar números diferentes a cada execução.
7. while(lucro<5000){
8.                            contador++; // Número de iterações.
9.                            x=rand(); // x = Número aleatório.
10.                            x=x%1000; // x = Resto da divisão de x por 1000.
11.                            y=rand(); // y = Número aleatório.
12.                            y=y%1000; // y = Resto da divisão de y por 1000.
13.                            lucro = 2*x + 4*y; // Função Objetivo
14.                           }
15. printf("\n\nx=%d\n\ny=%d\n\nLucro=%d\n\nIteracoes=%d\n\n",x,y,lucro,contador);
16. 
    
17.          
18. system("pause");
19. return(0); }

Observações: 

      Nesse post, inseri alguns comandos ( rand e srand ) que você podia não conhecer. São comandos da biblioteca padrão de C. Não se preocupe muito com a forma com que eles funcionam por enquanto, só saiba que eles funcionam e são de grande valia na programação. Num próximo post, irei abordar detalhes destes.

      Também apresentei uma parte do conceito de programação estocástica. Esse é um tema vasto, com inúmeras aplicações reais em problemas da matemática, engenharia, estatística e de empresas. Vários softwares já foram desenvolvidos com base nesse conceito e ainda rola muita pesquisa em universidades à respeito disso. É outro assunto que voltarei a falar numa próxima oportunidade. É uma boa pra se informar.

Proposta: Mexa no Programa 6. Rode várias vezes e observe as variações de solução. Mude as condições, e a equação objetivo do problema. Dificulte o trabalho do programa para achar a solução. Tente algo para que o número de iterações aumente bastante. Tente algo para que o número de iterações caia bastante também. Isso pode ser feito mexendo nas linhas 10 e 12, mudando o divisor da divisão, aumentando o lucro,etc...

Desafio: Esse eu considero realmente um desafio. Não se preocupe se não conseguir. 

Programa 7 - Volume da caixa em C.

Dada uma determinada caixa, de dimensões X, Y e Z;

sua área superficial é descrita por 2(XY+XZ+YZ).

Proposta: Com base em um valor qualquer de área superficial,encontrar o 

máximo volume que pode ser obtido e quais as dimensões da caixa de maior volume.

Ou seja, maximizar a capacidade da caixa, com menos material gasto...

Obs: Faça para áreas superficiais de até 100.000 unidades.

Boa semana à todos!

Resposta do problema de programação linear

Programa 5 - Otimização Barcos

1.  #include <stdio.h>
2. int main(){
3.     
4.     int a,b,c,l=0,ra,rb,rc,rl=0;// a = jangadas, b = canoas , c = arcas
5.     
6.     for (a=0;a<5;a++){
7.          for (b=0;b<9;b++){
8.                 for (c=0;c<4;c++){
9.                           if (a+b+c<11){ // restringe o máximo de capitães
10.                           if(a+2*b+3*c<19){ // restringe o máximo de funcionários
11.                                   l=(50*a)+(70*b)+(100*c); if(l>rl){ rl=l ; ra = a; rb = b ; rc = c;}
12. // Faz o teste, se o lucro encontrado na equação é maior que o lucro armazenado, se sim troca as respostas para arcas, canoas, jangadas e lucro.
13. // As variáveis que começam com r estão armazenando a resposta.
14.                                 } 
15.                                                  }
16.                                              }
17.                                         }
18.                                    }
19.     
20.     printf ("Solucao: \n\nJangadas = %d\nCanoas = %d\nArcas = %d\nLucro = %d\n\n\n",ra,rb,rc,rl);
21.     system("pause");
22.     return 0;
23.            }    

Estruturas de repetição (1)

       Olá! Boa noite! Hoje darei início aos posts abordando também as estruturas de repetição. Elas podem ser o For(para), While (Enquanto) e Do-While(Faça-Enquanto). Basicamente a diferença entre o For e as estruturas While, é que o primeiro é geralmente usado para problemas em que se sabe quantas iterações (repetições) serão realizadas, e que a realização dessas não depende de outra condição inicial. Já as estruturas While são usadas para quando se quer uma contagem indefinida, por exemplo procurar uma solução de equação ou problema de Programação Linear*. Ou seja, quando uma solução é encontrada o While pára automaticamente.

       As estruturas tem as seguintes "caras":

              
              For(Inicialização;Limite;Incremento){Comandos;}
          
              While(Condição){Comandos;}

              Do{Comandos;}While(Condiçao);

       Há ainda a diferença entre While e Do-While que é o seguinte: o While só executa se a condição for atendida. O Do-While executa pelo menos uma vez, ainda que sua condição não esteja satisfeita, e então, se for este o caso, pára. Ou seja:

Programa 2: While e Do-While em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=6;
6. 
   
7.                                while(i==2){
8.                                                    i=i*3;
9.                                                    printf("\n\n%d\n\n",i);
10.                                                   }//Este loop nunca irá rodar
11. 
    
12.                                do{
13.                                       i=i*5;
14.                                       printf("\n\n%d\n\n",i);
15.                                      }while(i==2); // Este loop será executado e trará resposta 30 na tela.
16.                                
17.                                system("pause");
18.                                return 0;
19.                               
20.                               }

      Entretanto, pensei esse post para falar mais do For, na sequência lançar outros sobre While/Do-While e mais tarde mais aplicações dos três...

    O For, como já foi dito, tem a seguinte "cara": For(Inicialização;Limite;Incremento){Comandos;}. A inicialização, é de onde partirá a "contagem", o limite é até onde ela vai, e o incremento de qual valore ela vai ser acrescida ou decrescida a cada repetição. Imagine o seguinte, um algoritmo que diga para subir uma escada de 30 degraus, um a um. Logo, você parte do primeiro degrau ( 0 ), chega ao último degrau (29) e sobe de um em um (i++). Seria algo mais ou menos assim:

Programa 3: For básico em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=0;
6. 
   
7.                                for(i=0;i<30;i++){//(Inicialização;Limite;Incremento)
8.                                                              printf("\n\n%d\n\n",i);
9.                                                             }//Este loop executa 30 passos, do 0 ao 29.
10. 
    
11.                                
12.                                system("pause");
13.                                return 0;
14.                               
15.                               }

    Note que o a variável de repetição, i, na linguagem C tem que ser declarada antes da estrutura For. Também é bom notar que o limite imposto NUNCA é atingido. Por exemplo, se o limite é 30, os loops vão até i = 29! Parece óbvio, pois olhando o sinal, o limite é menor que 30. Entretanto essa é uma característica do For que pode trazer resultados errados ao seu programa, se você se esquecer dela. 

      Há também o For usado com decremento, ou seja diminuindo. Imagine agora, que você quer descer a mesma escada que acabou de subir, o programa fica quase igual, exceto pela linha 7:

      7.                                for(i=30;i>0;i--){//(Inicialização;Limite;Incremento)

    Nesse For, o i começa de fato em 30, decresce um a um, chega em 1 e pára. É o chamado For Backward (de trás pra frente). O anterior é o For Foward.

      Na maior parte das vezes, usa-se o for para contagens, para adicionar dados a algum problema, para realizar testes nos programas, etc... A seguir um exemplo simples:

Programa 4: Fatorial com For em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=0,s=1;
6. 
   
7.                                for(i=1;i<11;i++){//(Inicialização;Limite;Incremento)
8.                                                            s*=i; // A cada repetição, s é multiplicada por i.
9.                                                             }//Este loop executa 10 passos, do 1 ao 10.
10. 
    
11.                                printf("\n\n%d\n\n",i);//Saída 3628800
12. 
    
13.                                
14.                                system("pause");
15.                                return 0;
16.                               
17.                               }

Observações:

    Programação Linear é uma área da otimização, que utiliza uma função objetivo, e restrições lineares. Ou seja, problemas do tipo maximizar lucro de uma fábrica que possui "x" funcionários e precisa produzir "y".
    

    Os sinais "++","--" são alternativos para "i=i+1" e "i=i-1". Já " s*=i " é o mesmo que " s=s*i ". Isso funciona da mesma forma para " s+=i ", " s-=i "...

    A seguir alguns bons livros sobre C/C++:

      Introdução à programação. 500 Algoritmos resolvidos. Por Anita Lopes e Guto Garcia.
      Guia C++ para Iniciantes por Herbet Schildt.

      C Completo e Total por Herbert Schildt.

Proposta: Tente, usando o For, resolver o seguinte problema de Programação Linear.

    A Capitão Caverna S.A., localizada em Pedra Lascada, aluga 3 tipos de barcos para passeios marítimos: jangadas, super-canoas e arcas com cabine. A companhia fornece juntamente com o barco um capitão para navegá-lo e uma tripulação que varia de acordo com a embarcação: uma para jangadas, duas para super-canoas e três para arcas. 

    A companhia tem 4 jangadas, 8 super-canoas e 3 arcas; e em seu corpo de funcionários: 10 capitães e 18 tripulantes.

    O aluguel é por diárias e a Capitão Caverna lucra $50 por jangada, $70 por super-canoa e $100 por arca.

    Objetivo: Maximizar o lucro obedecendo as restrições impostas.

(Resposta 4 jangadas, 4 super-canoas, 2 arcas, lucro $ 680)
Solução: Programa 5 - Barcos Otimização

Bom fim de semana à todos!

Um pouco sobre C/C++, Linhas Condicionais.

       Bom dia! Me chamo Rodrigo. Atualmente sou estudante de Engenharia Elétrica da UFJF, tendo começado o curso de    engenharia no IFET-Sudeste.. De agora em diante serei colaborador do blog e vou postar alguns tópicos de estudo sobre C, C++, posteriormente aplicações nas áreas de modelagem computacional (basicamente a implementação de problemas reais), curiosidades, desafios... Enfim, será uma série para estudos das linguagens C, C++ e sobre aplicações práticas da programação.

       Pra quem precise aprender para a faculdade é uma boa, pra quem gosta ou tem bolsa de pesquisa mais ainda. É uma área muito visada no meio da engenharia, pois muito da pesquisa que se faz em universidades se passa pela simulação computacional...
       Não farei aqui algum tipo de apostila ( pois na internet já existem várias), o que farei são postagens com programas já feitos e algumas discussões sobre seu funcionamento. Para iniciar (seguir) seus estudos, já foi recomendado aqui, o material do Prof. Jabour disponível em Apostila, na aba Ensino, é uma boa pedida pra quem nunca viu C... Também há vários bons livros sobre C e C++, que no próximo post irei recomendar aqui. Podem fazer perguntas e sugestões à vontade nos comentários!

Programa 1: Soma e Subtração básica em C

1. #include <stdio.h>// biblioteca padrão em C
2. 
   
3. int main ( ) {
4.                   int a, b, soma, final; // Declaração das variáveis
5. 
   
6.                   printf("\n Digite um valor:\n"); // Comando de impressão na tela
7. 
   
8.                   scanf ("%d",&a); // Lê o que o usuário digitou no teclado
9. 
   
10.                   printf("\n Digite um segundo valor:\n");
11. 
    
12.                   scanf ("%d",&b);
13. 
    
14.                   soma = a+b; // Soma os valores a e b e atribui o resultado à variável soma.
15. 
    
16.                   if (soma>20) {
17.                                          final = soma+8; } // Comando condicional
18.     
19.                   else {
20.                            final = soma-5; } // Complemento do comando condicional
21.                   
22.                   printf ("\n O resultado e: %d", final);
23. 
    
24.          
25.                   system("pause") // Linha de comando para que se possa visualizar o resultado na tela
26.                   return 0; } // Retorno da função main( )

       Bem, esse é um programa bem simples de ser entendido, mesmo por quem ainda está começando. São 26 linhas de código, o que é bem pouco. Na linha 1 temos a inclusão da biblioteca stdio.h, que faz parte da biblioteca padrão de C. Biblioteca é, basicamente, um conjunto de funções. Na linha 3 temos a declaração da função main ( ), que deve estar em qualquer programa em C. Por ela se dá a execução do código. Em seguida dois pares printf/scanf que servem para pedir que o usuário digite um valor e em seguida armazenam esse valor em variáveis int. Na linha 14 faz-se a soma dos valores que o usuário digitou. Logo vem o mais interessante desse programa, as linhas condicionais. Na linha 16 temos : Se a soma for maior que 20 faça isto ( soma + 8). Na sequência, na linha 19 temos o complemento: Senão faça isto (soma - 5). Ou seja, se a soma de 'a' e 'b' for menor ou igual a 20 ( note que a condição é >20) ele subtrai 5 e, somente se, for maior que 20 ele soma 8. O resultado é impresso e o código retorna 0 para main ( ).

Observações:
     
       //As linhas verdes, precedidas por // são apenas comentários! Não interferem no código e são muito úteis em qualquer programa... Lembre-se de que há programas complexos e extensos, e sem comentários é praticamente impossível entender seu funcionamento.

       Atente para a identação do código. Ou seja, os espaços antes de cada comando. O que pertence ao if, à frente do if, o que pertence ao else, à frente do else...

       A linha 25 serve somente para que a tela "congele" ao mostrar o resultado. É uma maneira de fazer isso, apesar de haver controversas, nunca tive problemas com ela. Mais adiante postarei uma alternativa.

       A linha 26 dá o retorno da função main ( ). É recomendado dar algum retorno para toda função que não seja do tipo void ( que não possui retorno ).

Proposta:

       Modifique o programa bastante. Mude as operações, faça com produtos( * ), divisões( / ), etc... Inclua printf para que mostre o resultado da operação antes de entrar nas linhas condicionais ( essa é uma ótima maneira de testar programas que dão errado, e achar o erro!), mude o else da linha 19 por outro if, e tente obter o mesmo resultado...

Boa semana à todos!

Algoritmos, "colocando no papel" parte II

Hoje vamos aprender um importante recursos para visualizar o fluxo do algoritmo e nos ajudar a entender as consequências dos condicionais e dos ciclos:  a montagem de fluxogramas, diagramas com setas e símbolos que representam os passos do algoritmo.

Mais uma vez não vamos aqui seguir a regra pura de construção de fluxogramas. Vamos ver uma versão simplificada e fácil, apenas para termos mais um recurso a mão. Quem quiser pode se aprofundar, procurando materiais didáticos sobre o assunto. Na internet temos diversos gratuitos.

Iniciadores e terminadores:

Iniciador e terminador

Aparecem no início e no final do programa e servem exatamente para isso (indicar o começo e o fim do algoritmo). Podem ser representados de diversas formas, mas aqui adotaremos a do retângulo-oval (essa salsicha ai em cima).

Processos genéricos (Passos):

Um verdadeiro processo genérico!

A maior parte das instruções, os passos do programa, os chamados "processos genéricos", são representados por esse retângulo (não, não ESSE exatamente, se o passo for x = a+1, você vai escrever isso dentro do retângulo e não "solte o barro", por favor, nada de programas diarrentos!)

Condicionais:

Um condicional

Representam os testes condicionais e comparativos, além disso, são usados para representar os ciclos também. Isso mesmo! Os ciclos aqui são representados como testes condicionais! O caso é que todos os símbolos só admitem uma única seta entrando e uma única seta saindo, menos... este, que pode ter saindo dele duas, ou mais setas de fluxo.

Setas de fluxo:

Setas de fluxo

Unem os símbolos e representam o fluxo de dados do algoritmo. Em geral, cada símbolo possui duas setas: uma entrando e outra saindo. Inicializadores tem apenas uma seta saindo, enquanto terminadores tem apenas uma seta entrando. Condicionais tem uma seta entrando e duas, ou mais, saindo. Pode acontecer também de uma seta apontar para outra seta.

Entradas e saídas:

Entrada e saída

Representam ah... hã... bem... as entradas e saídas do programa. O símbolo é o mesmo para ambos, um paralelogramo.

Um fluxo simples:

Um fluxo simples e retilíneo

Peguei um dos primeiros algoritmos da postagem anterior e passei para um fluxograma. Notem que é fácil entender onde ele começa, por onde deve seguir e onde termina. Usei o editor de imagens do google docs para desenhar isso. Qualquer um que tenha uma conta google (é grátis, se você tem uma conta blogger, gmail, conta no youtube, google+ e etc, provavelmente você tem acesso ao google docs).

Representando o SE ENTÃO:

Apesar do condicional "SE ENTÃO" ser um só, ele pode ter dois efeitos em um algoritmo, o que gera "duas representações" num fluxograma. No geral, um SE ENTÃO é representado por uma seta entrando num símbolo condicional e duas saindo dela. O problema está nessas setas.

Temos casos em que o SE ENTÃO só serve para adicionar passos em um programa, ou seja, ele não tem um "SE NÃO". O programa corre normalmente e quando chega no "SE ENTÃO", sendo o teste verdadeiro, ele inclui instruções do bloco SE e depois retorna a linha normal do programa. Se o teste for falso, ele simplesmente salta o bloco SE e continua o programa. Veja um modelo:

Um SE sem um SE NÃO

Nesse caso ele vai executar 1-2-3-{4-5}-6-7 se A for verdadeiro e 1-2-3-{}-6-7 se A for falso. A representação para casos como esse é, uma seta entrando no simbolo condicional e duas saindo, uma à direita para caso o teste for verdadeiro e uma para baixo, seguindo a seqüência do programa.

Um SE sem um SE NÃO

Temos também os SE ENTÃO que usam o "SE NÃO", ou seja, o programa vai correndo em sua linha normal, chega no "SE ENTÃO" e realiza o teste lógico, se o teste der verdadeiro executa um bloco de instruções, se der falso executa outro. Depois de realizar os blocos o programa volta para o curso normal. Veja o modelo:

Um SE com um SE NÃO

Nesse caso ele vai executar 1-2-3-{4-5}-8-9 se o teste for verdadeiros e 1-2-3-{6-7}-8-9 se for falso. A representação segue a anterior, seta para o lado para o caso verdadeiro, seta para baixo para o caso falso. A diferença é que da ultima instrução verdadeira vai seguir uma seta e esta vai apontar para a seta que sai da última instrução falsa.

Representando o ESCOLHA UM CASO:

Como vimos, temos os ESCOLHA UM CASO com "SAIR" em cada caso, os ESCOLHA UM CASO sem o "SAIR" em alguns casos e os escolha um caso e os sem o "SAIR" em todos os casos. Embora o condicional seja o mesmo a representação gráfica pode mudar.

A representação geral do escolha um caso é uma seta entrando em um símbolo condicional e uma saindo se dividindo em várias setas, uma para cada caso. Os casos que tiverem um "SAIR", ao fim das instruções deverá sair uma seta convergindo para a linha normal do programa. Os sem "SAIR", ao fim das instruções, deverão ter uma seta convergindo para o início do próximo caso. Veja os modelos:

Escolha um caso com SAIR em todos os casos

Escolha um caso com SAIR em todos os casos 

ESCOLHA UM CASO sem SAIR em alguns dos casos

ESCOLHA UM CASO sem SAIR em alguns dos casos 

ESCOLHA UM CASO sem SAIR

ESCOLHA UM CASO sem SAIR

 Obs.: Parece que eu esqueci de mudar o conteúdo dos símbolos condicionais em algumas figuras, está escrito "Motor ligado" ao invés de "Variável".

Ciclos:
Os ciclos, apesarem de terem diversas formas para serem escritas (teste de quebra no início, no meio e no fim) não tem maiores delongas quanto a sua representação gráfica: Eles são representados por uma seta saindo de um condicional e apontando para algum ponto anterior ao mesmo. As instruções entre esse ponto de retorno e o condicional são as que ficam entre o início do ciclo e o teste de sua quebra. As instruções que ficam na seta de retorno até o ponto de retorno são as que ficam entre do condicional de quebra e o final do bloco do ciclo. O importante é lembrar que, no caso dos ciclos, quando o condicional é verdadeiro a seta segue para baixo, voltando a linha normal do algoritmo. Quando é falso ele segue o caminho do loop, para a esquerda. Veja os modelos:

Ciclo com teste de quebra no final

Ciclo com teste de quebra no final

Ciclo com teste de quebra no meio

Ciclo com teste de quebra no meio

Ciclo com teste de quebra no início

Ciclo com teste de quebra no início

Exercícios:

1) Montar os fluxogramas dos algoritmos dos exercícios 1 a 7 da postagem anterior.

2) Montar primeiro o fluxograma e depois escrever os algoritmos para os seguintes programas:

a) Que receba 3 números e diga qual deles é o maior.
b) Que receba 5 números e os coloque em ordem crescente.
c) Que receba 10 temperaturas e armazene classifique elas em 4 classes: a < 50º, 50º <= b < 0º, 0º <= c < 50º, d >= 50º.
d) Receba 2 números e tire o mínimo múltiplo comum.

Pronto, eu pessoalmente já devia estar dormindo. Escrevi isso aqui 12/09 0130h, às 0800h vou dar um curso em um batalhão de infantaria. Já sei que a greve acabou e por isso a próxima postagem está prevista só para mês que vem, provavelmente 19/11. Trabalharemos com o MS Excel / BrOffice Calc para aprendermos a lidar com condicionais.

Isso é tudo.

Respostas aos exercícios de 19/09

1) Variáveis: hipotenusa "a", catetos "b" e "c". Entradas: dimensões dos catetos "b" e "c". Saídas: dimensão da hipotenusa "a".

Exercício 1

2) Variáveis: hipotenusa "a", catetos "b" e "c", ângulo "g". Entradas: hipotenusa "a", ângulo "g". Saídas: catetos "b" e "c".

Exercício 2

3) Variáveis: coeficientes "a", "b" e "c", delta "d", raízes "x1" e "x2", verificador "grau "(declarei esse errado, com o nome de "ver"). Entradas: coeficientes "a", "b" e "c". Saídas: raízes "x1", "x2" e textos "não existem raízes reais" e "equação de 1º grau". Blocos(em cores): nível 1(mais externos): vermelho, lilás e vermelho escuro. Nível 2 (ambos  internos ao bloco lilás) azul e ciano. Nível 3(ambos internos ao ciano): verde e amarelo. Condicionais: "Coeficiente "a" é igual à zero?" (a==0), "Delta é maior que zero?" (d>0), "Delta é igual a zero?" (d==0), "Comparar verificador grau com caso 1,2,restante" (ver).

Exercício 3

4) Variáveis: nivel_da_agua (nível da água no balde). Entradas "nivel_da_agua". Blocos (em cores): Nível 1(mais externo): vermelho. Nível 2(interno ao vermelho): lilás. Condicionais: "O balde está cheio?" (nivel_da_agua == cheio). Ciclos:  tudo o que está dentro do bloco vermelho.

Exercicio 4

5) Variáveis: nivel_do_combustivel, capacidade_do_tanque (poderia ter feito igual ao do problema do balde, colocando um nível fixo, ou um não numérico, mas dessa vez eu quis aprimorar), motor_ligado. Entradas nivel_do_combustivel, capacidade_do_tanque e motor_ligado. Blocos: Nível 1(mais externos) vermelho e ciano. Nível 2 (internos ao vermelho): lilás e azul, (internos ao ciano): verde. Condicionais: "o motor está ligado?" (motor_ligado), "o tanque está cheio?" (nivel_de_combustivel == capacidade_do_tanque). Ciclos: (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano.

Exercício 5

6) Variáveis: nivel_de_combustivel, capacidade_do_tanque, litros_pedidos, nivel_inicial_do_tanque, motor_ligado. Entradas: nivel_de_combustivel, capacidade_do_tanque, nivel_inicial_do_combustivel, litros_pedidos. Blocos: Nível 1(mais externos): vermelho, ciano, vermelho-escuro. Nível 2 (internos ao vermelho): lilás, azul, (internos ao ciano): verde e amarelo, (interno ao vermelho-escuro): roxo. Condicionais: "o motor está ligado?" (motor_ligado), "é possível colocar todo esse combustível no tanque do veículo?" (litros pedidos > capacidade_do_tanque - nivel_inicial_do_tanque), "os litros pedidos foram colocados?" (nivel_de_combustivel == nivel_inicial_do_tanque + litros_pedidos). Ciclos (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano, (3) tudo o que está dentro do bloco vermelho escuro.

Exercício 6

7) Variáveis: nivel_de_combustivel, capacidade_do_tanque, litros_pedidos, nivel_inicial_do_tanque, motor_ligado, preço_pedido. Entradas: nivel_de_combustivel, capacidade_do_tanque, nivel_inicial_do_combustivel, preço_pedido. Saídas: preço_pedido .Blocos: Nível 1(mais externos): vermelho, ciano, vermelho-escuro. Nível 2 (internos ao vermelho): lilás, azul, (internos ao ciano): verde e amarelo, (interno ao vermelho-escuro): roxo. Condicionais: "o motor está ligado?" (motor_ligado), "é possível colocar todo esse combustível no tanque do veículo?" (litros pedidos > capacidade_do_tanque - nivel_inicial_do_tanque), "os litros pedidos foram colocados?" (nivel_de_combustivel == nivel_inicial_do_tanque + litros_pedidos). Ciclos (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano, (3) tudo o que está dentro do bloco vermelho escuro.

Exercício 7

8) Resposta inclusa nos exercícios anteriores.