Comando de repetição for e comando break

Abreviações

Em Javascript, o comando de atribuição que soma um a uma variável de nome nome_var pode ser abreviado pela expressão nome_var++ (ou seja, o nome da variável seguido de dois sinais "+" consecutivos). Por exemplo, o comando

i = i + 1;

pode ser abreviado por

i++;

De forma similar, o comando de atribuição que subtrai um de uma variável de nome nome_var pode ser abreviado pela expressão nome_var++ (ou seja, o nome da variável seguido de dois sinais "-" consecutivos). Por exemplo, o comando

contador = contador - 1;

pode ser abreviado por

contador--;

Note que são apenas abreviações, e você pode usar ou não, dependendo da conveniência.

O comando de repetição for

O comando de repetição for pode ser visto também como uma abreviação do comando de repetição while. O comando for à direita executa exatamente o mesmo que o comando while à esquerda.

O formato geral do comando de repetição for é:

for (comando inicial ; expressão_lógica ; incremento) {
    bloco_de_comandos
}

(note os caracteres ponto-e-vírgula separando os componentes do comando for; eles são importantes!).

O que ocorre na execução:

1. o comando de inicial é executado
2. o valor da expressão_lógica é computado, e se o resultado é verdadeiro os comandos do bloco_de_comandos são executados
3. executa uma vez o bloco de comandos
4. executa o incremento e volta a executar o passo 2 acima.

Note mais uma vez a semelhança com o comando while no exemplo abaixo, em que o comando inicial está colorido com azul, a expressão lógica está colorida com rosa, o incremento está colorido com verde, e o bloco de comandos está colorido com amarelo:

i = 1;
while (i<=10) {
    printf("i=%d\n", i);
    i = i + 1;
}

for (i=1 ; i<=10 ; i++) {
    printf("i=%d\n", i);
}

Como último exemplo, vejam um programa que usa dois comandos de repetição encaixados para escrever na saída um retângulo de 3 linhas por 5 colunas de caracteres asteriscos, como abaixo:

*****
*****
*****

implementado usando comandos while e comandos for:

var i, j;

i = 1;
while (i<=3) {
    // para cada linha, escreve a
    // linha com um outro comando while
    j = 1;
    while (j<=5) {
        // para cada coluna escreve um '*'
	printf("*");
        j = j + 1;
    }  
    // ao final da linha, 
    // escreve caractere final-de-linha
    printf("\n"); 
    i = i + 1;
}

var i, j;

for (i=1; i<=3; i++) {
    // para cada linha, escreve a
    // linha com um outro comando for
    for (j=1; j<=5; j++) {
        // para cada coluna escreve um '*'
	printf("*");
    }  
    // ao final da linha, 
    // escreve caractere final-de-linha
    printf("\n"); 
}

O comando break

Quando precisamos interromper a execução de um comando de repetição, usamos o comando break.

Como um exemplo simplório, o trecho de programa abaixo escreve apenas três valores na saída (10, 11 e 12) apesar de a expressão lógica do comando for indicar que a repetição deveria acontecer enquanto i<=1000:

var i;

for (i=10; i<=1000; i++) {
    printf("%d\n", i);
    if (i===12)
        break;
}
printf("fim\n");

Quando i é igual a 12, o comando break é executado, e isso faz com que a execução do comando for termine. O próximo comando executado é então o comando de escrita printf que escreve "fim", de forma que o programa acima escreve na saída quatro linhas:

10
11
12
fim

O comando break interrompe somente o comando de repetição no qual está inserido. Ou seja, se o comando break é usado em um comando de repetição encaixado, apenas o comando de repetição mais interno é interrompido.

Joana criou um canal no YouTube, que tem feito muito sucesso! Desde o primeiro dia, diariamente Joana anota o número de visualizações de vídeos do seu canal, no que ela chamou de Lista de Audiência.

Joana quer saber se sua Lista de Audiência é estritamente crescente (ou seja, se cada elemento na lista é maior do que o elemento imediatamente anterior). Você pode ajudá-la?

Entrada

A entrada consiste de duas linhas. A primeira linha contém um número inteiro N que indica o comprimento da Lista de Audiência. A segunda linha descreve os elementos da Lista de Audiência. Ela contém N inteiros X_i, indicando o número de visualizações em dias consecutivos.

Saída

Seu programa deve escrever uma única linha na saída contendo apenas um caractere: "S" se a Lista de Audiência é estritamente crescente, ou "N" caso contrário.

Restrições

• 1 ≤ N ≤ 1000
• 0 ≤ X_i ≤ 10000

Exemplos

5
10 30 40 41 80

S
	

4
1 1000 1000 10000

N

3
3 2 1

N

Zinho quer ser comerciante quando crescer. Como todo comerciante, Zinho gosta de negociar, especialmente quando as duas partes ficam satisfeitas com o resultado da negociação. E, claro, também é bom poder ganhar dinheiro fazendo o que se gosta!

Apesar da pouca idade, Zinho já percebeu que pode ganhar dinheiro com compras e vendas pela Internet. Zinho quer comprar e revender uma série de itens, ganhando dinheiro ao final da sequência de compras e vendas. Zinho acredita que consegue comprar por exemplo uma console de jogos e vendê-la logo em seguida por um valor um pouco maior do que pagou, usar o dinheiro para comprar um outro item e novamente vendê-lo por um pouco mais do que pagou, e assim ir ganhando dinheiro. O segredo está na propaganda, diz Zinho.

Zinho já fez inclusive uma lista com a sequência de itens a serem comprados e revendidos, na ordem que deseja efetuar as transações. No entanto, Zinho não tem o dinheiro inicial para comprar o primeiro item de sua lista, e pediu ao seu avô o dinheiro emprestado. O avô de Zinho é bem legal mas foi também um grande comerciante, e disse que somente empresta o dinheiro sob as seguintes condições:

• A sequência de transações deve gerar lucro, ou seja, a quantia de dinheiro que Zinho tem ao final da sequência de transações deve ser maior do que a quantia inicial emprestada;
• No momento de cada transação de compra, Zinho deve ter dinheiro suficiente para efetuar a compra, para todas as transações de compra da sequência.

A lista de Zinho indica o valor pelo qual ele pretende comprar e vender cada item; na lista, todos os itens comprados são revendidos (ou seja, o número de transações de compra é igual ao número de transações de venda).

Mas a lista tem uma grande quantidade de itens, e antes de mostrá-la a seu avô ele quer ter a certeza de que a lista obedece às restrições impostas. Você pode ajudá-lo?

Entrada

A entrada consiste de duas linhas. A primeira linha contém um número inteiro N e um número real C, com duas casas decimais, que indicam respectivamente o comprimento da sequência de transações e o valor emprestado pelo avô. A segunda linha contém N valores X_i, com precisão de duas casas decimais, indicando os valores das transações. Uma transação de compra é dada como um número negativo, e uma transação de venda é dada como um número positivo.

Saída

Seu programa deve escrever uma única linha na saída contendo

• um único número com duas casas decimais de precisão, o lucro a ser obtido por Zinho ao final das transações, se as condições do avô são obedecidas.
• o caractere "*" (asterisco) caso contrário.

Restrições

• 1 ≤ N ≤ 1000, N par
• 0.01 ≤ C ≤ 500.00
• 0.01 ≤ X_i ≤ 500.00
• Na lista de Zinho, cada item é comprado antes de ser vendido (assim, a primeira operação é sempre de compra, a última é sempre de venda)

Exemplos

6 100.00
-100.00 110.00 -90.00 100.00 -10.00 20.00

30.00
	

2 200.00
-150.00 140.00

*

4 100.00
-50.00 100.00 -200.00 500.00

*

4 10.00
-5.00 -5.00 500.00 500.00

990.00

A sequência de Fibonacci é uma das sequências de números mais famosas. Ela começa assim:

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

À primeira vista pode ser difícil perceber a regra de formação da sequência, mas ela é muito simples: os dois primeiros elementos são 1 e a partir do terceiro cada elemento é a soma dos dois elementos precedentes:

• 2 é a soma (1+1)
• 3 é a soma (1+2)
• 5 é a soma (2+3)
• 8 é a soma (3+5)
• e assim por diante

Entrada

A entrada consiste de duas linhas. A primeira linha contém um número inteiro N que indica o comprimento da sequência de números. A segunda linha contém N números inteiros X_i, descrevendo a sequência encontrada nas escavações.

Saída

Seu programa deve imprimir uma única linha contendo um único caractere, 'S' se a sequência encontrada é uma sequência de Fibonacci, e 'N' caso contrário.

Restrições

• 2 ≤ N ≤ 30
• 1 ≤ X_i ≤ 10⁶

Exemplos

6
1 1 2 3 5 8

S
	

10
1 1 2 3 5 8 13 21 33 55

N

2
1 2

N

12
1 1 2 3 5 8 13 21 34 55 89 144

S

A cada dia uma quantidade enorme de informação é postada na Internet. Sobre tudo e sobre todos! Luísa recentemente descrobriu uma página que disponibiliza uma tabela com o volume de água em algumas represas do país. A tabela contém, para cada represa, para cada dia, a porcentagem de água represada em relação à capacidade total.

Cada linha da tabela representa a medição de um dia, cada coluna representa uma represa. A figura abaixo mostra um exemplo da tabela para as represas 1, 2, 3 e 4, com dados de cinco dias.

Luísa está interessada nos dados da represa de sua região (uma coluna da tabela). Ela quer verificar se é verdade uma notícia que ela leu no jornal: que a o volume de água represada em caindo continuamente, dia após dia, desde o início das medições, mesmo tendo chovido normalmente.

Como são muitos dados, ela pediu que você faça um programa para fazer a análise.

Entrada

A primeira linha contém dois inteiros N, M e C que indicam respectivamente o número de dias (linhas da tabela), o número de represas (colunas da tabela), e a coluna de interesse de Luísa. As represas são identificadas por números de 1 a M. Cada uma das N linhas seguintes contém M números inteiros X_i,j, representando o volume de água para cada represa em um dia.

Saída

Seu programa deve imprimir uma única linha contendo um único caractere, que deve ser 'S' se as medições para a coluna de interesse são estritamente decrescentes, ou o caractere 'N' caso contrário.

Restrições

• 1 ≤ N ≤ 10
• 1 ≤ M ≤ 10
• 1 ≤ C ≤ 10
• 0 ≤ X_i,j ≤ 100

Exemplos

4 3 1
90.0 90.8 90.2
89.0 88.1 89.3
88.0 88.1 90.4
87.0 87.2 89.7

S
	

4 3 2
90.0 90.8 90.2
89.0 88.1 89.3
88.0 88.1 90.4
87.0 87.2 89.7

N

4 3 3
90.0 90.8 90.2
89.0 88.1 89.3
88.0 88.1 90.4
87.0 87.2 89.7

N

O famoso cientista Dr. Ding Dong anunciou uma invenção extraordinária. A partir de uma pequena amostra do DNA de uma pessoa o Dr. Ding Dong desenvolveu um procedimento que permite testar se essa pessoa tem alergia a qualquer substância. A descoberta desse teste vai beneficiar milhões de pessoas que sofrem de alergia e não conseguem determinar a causa.

Mais especificamente, o processo do Dr. Ding Dong gera, a partir da amostra de DNA, uma sequência de letras minúsculas, de 'a' a 'z'. O Dr. Ding Dong precisa, para terminar sua invenção, de um programa que, dada a sequência de letras, determina qual o maior número de letras 'a' consecutivas.

Por exemplo, para a sequência "b a a a a c d" o resultado é 4, pois o maior número de letras 'a' consecutivas é esse. Já para a sequência "x a a a x x a a a x" o resultado é 3.

O Dr. Ding Dong promete repartir os louros e os lucros da invenção com quem ajudá-lo. Quem se interessa?

Entrada

A entrada consiste de duas linhas. A primeira linha contém um inteiro N que indica o comprimento da sequência de letras. A segunda linha contém N letras X_i, separadas por um espaço em branco.

Saída

Seu programa deve imprimir uma única linha contendo um único inteiro, o comprimento da maior sequência consecutiva de letras 'a'.

Restrições

• 1 ≤ N ≤ 1000
• X_i é uma letra minúscula, de 'a' a 'z'.

Exemplos

5
a a a b a

3
	

8
a z a y a z a a

2

4
b c d e

0

Soluções para os exercícios

Nesta seção você encontra exemplos de soluções para os exercícios. Mas antes de ver a solução para um exercício tente resolvê-lo, criando a sua própria solução.

// Solução para o exercício 1, Aula 13
// Audiência crescente
// Autor: Ricardo Anido

var N,         // comprimento da lista
    i,         // contador para a repetição
    corrente,  // valor do elemento corrente
    anterior,  // valor do elemento anterior
    resultado; // resultado (S ou N)

scanf("%d", "N");        // comprimento da lista
scanf("%d", "anterior"); // primeiro valor
resultado = "S";         // assume que é crescente

for (i=2; i<=N; i++) {
    scanf("%d", "corrente");
    if (corrente <= anterior) {
        resultado = "N"; // não é crescente
        break;           // pode parar de ler!
    }
    anterior = corrente;
}
// imprime o resultado
printf("%s\n", resultado);

// Solução para o exercício 2, aula 13
// Comércio pela Internet

var i,              // usado como contador
    N,              // comprimento da sequência
    transacao,      // valor da transação corrente
    caixa_inicial,  // valor em caixa no início
    caixa;          // valor em caixa corrente

// lê comprimento da sequência e valor inicial do caixa
scanf("%d%f", "N", "caixa_inicial");

// inicializa valor do caixa corrente
caixa = caixa_inicial;

// percorre todas as transações da sequência
for (i=1; i<=N; i++) {
    scanf("%f","transacao");
    caixa = caixa + transacao;
    if (caixa < 0)
	// se não consegue comprar interrompe a repetição
	break;
}

// escreve o resultado
if (caixa > caixa_inicial)
    printf("%.2f\n", caixa - caixa_inicial);
else
    printf("*\n");

// Solução para o exercício 3, aula 13
// Fibonacci

var i,               // usado como contador
    N,               // comprimento da sequência
    resultado,       // armazena o resultado, S ou N
    antecessor,      // valor antecessor
    ante_antecessor; // valor ante_antecessor

// vamos assumir que a sequência está correta
resultado = "S";

// lê comprimento da sequência
scanf("%d", "N");

// lê os dois primeiros elementos, que devem ser 1
scanf("%d%d", "ante_antecessor", "antecessor");
if (ante_antecessor!=1 || antecessor != 1)
    // sequência não está correta
    resultado = "N";
else {
    // percorre todas os outros elementos da sequência
    for (i=3; i<=N; i++) {
        // lê elemento
        scanf("%d", "corrente");
        // verifica se tem valor esperado
        if (corrente != antecessor+ante_antecessor) {
            // sequência não está correta
            resultado = "N";
            break;
        }
        // atualiza valores
        ante_antecessor = antecessor;
        antecessor = corrente;
    }
}

// escreve o resultado
printf("%s\n", resultado);

// Solução para o exercício 4, aula 13
// Volume decrescente

var i, j,             // usados como contadores
    N,                // número de linhas da tabela
    M,                // número de colunas da tabela
    C,                // coluna de interesse
    corrente,         // valor corrente de medição
    ultimo,           // último valor lido
    resultado;        // armazena o resultado, S ou N

// lê número de linhas e de colunas da tabela
scanf("%d%d%d", "N", "M", "C");

// inicializa último valor lido 
ultimo=101;

// vamos assumir que a coluna é estritamente decrescente
resultado = "S";

// percorre todos as linhas da tabela
for (i=1; i<=N; i++) {
    // percorre todos as colunas da tabela
    for (j=1; j<=M; j++) {
        // lê um valor da tabela
        scanf("%f","corrente");
        if (j===C) { // é a coluna de interesse?
            if (corrente>=ultimo) {
                resultado = "N";  // marca que coluna não é decrescente
                break;
            }
            ultimo = corrente;
        }
    }
}

// escreve o resultado
printf("%s\n", resultado);

// Solução para o exercício 4, aula 13
// O teste perfeito

var i,             // usado como contador
    N,             // comprimento da sequência
    corrente,      // a letra corrente lido da sequência
    ultimo,        // a última letra lido da sequência
    max_corrente,  // a maior número de 'a' consecutivos corrente
    max_total;     // a maior número de 'a' consecutivos total

// lê comprimento da sequência
scanf("%d", "N");

// inicializa alguns valores
max_total=0;
max_corrente=0;
ultimo='x';

// percorre todos as letras da sequência
for (i=1; i<=N; i++) {
    scanf("%s","corrente");
    if (corrente===ultimo) {
        if (corrente === "a")
	    // encontramos outro 'a' consecutivo
            max_corrente++;
    }
    else if (corrente==="a") {
	// ultimo é diferente de "a", corrente é "a"
	// iniciamos uma nova sub-sequência de 'a' consecutivos
        max_corrente = 1;    
    }
    else { 
	// ultimo é "a", corrente é diferente de "a"
	// terminou uma sub-sequência de "a" consecutivos
	// verifica se seu comprimento é o maior conhecido até o momento
        if (max_corrente>max_total)
            max_total = max_corrente; // encontramos uma sub-sequência maior 
    }
    ultimo = corrente;
}

if (ultimo==="a") {
    // se ultima letra é "a", a sub-sequência de "a" terminou com o final da sequência
    // verifica se seu comprimento é o maior conhecido até o momento
    if (max_corrente>max_total)
	max_total = max_corrente; // encontramos uma sub-sequência maior 
}

// escreve o resultado
printf("%d\n", max_total);