C Maior segmento crescente de uma sequência em C

[Eduardo_Braz]

Dados n e uma seqüência de n números inteiros, determinar o comprimento
máximo de um segmento crescente na sequência. O comprimento do segmento é dado pelo número de
elementos do segmento menos um.
 

Entrada
O programa deve ler um número inteiro n maior que zero e uma sequência de n números inteiros. Os
números podem aparecer em qualquer ordem na sequência.
 

Saída
O programa deve apresentar a mensagem "O comprimento do segmento crescente maximo e: k", onde
k é o tamanho do maior segmento crescente encontrado. A mensagem deve ser seguida por um caractere de
quebra de linha.
 

Exemplo

 

 

Entrada

9
5 10 3 2 4 7 9 8 5

Saída

O comprimento do segmento crescente maximo e: 3

 

Entrada

5
10 8 7 5 2

Saída

O comprimento do segmento crescente maximo e: 0

 

Entrada

7
1 2 0 40 34 35 16

Saída

O comprimento do segmento crescente maximo e: 1

 

//Programa 11

#include <stdio.h>
 
int main(){
    
    int n, sequencia = 0, segmentos = 0;
    unsigned int n1, n2;
    
    scanf("%d", &n);
 
    if(n>0){
        while(sequencia < n){
        
            scanf("%d", &n1);
                if(n1 - n2 == 1) {
                    segmentos++;
                }
                else if(n2 - n1 == -1){
                    segmentos++;
                }
            n2 - n1 == 1;
            sequencia++;    
        }
    } 
    else
    {
        return 0;
    }
    
    printf("O comprimento do segmento crescente maximo e: %d\n", segmentos);
 
    return 0;
}

 

Eu só estou conseguindo fazer os que estão na sequenciaria alguém poderia me dizer o erro??

[Ansi C]

@Eduardo_Braz  Bom dia! Você poderia me aponta onde é o segmento de 3 números consecutivos do exemplo?

21 minutos atrás, Eduardo_Braz disse:

Entrada

9
5 10 3 2 4 7 9 8 5

Saída

O comprimento do segmento crescente maximo e: 3

 

[Eduardo_Braz]

@Mauro Britivaldo Boa Tarde são o 2 3 4 o 5 não entra pois é repetido 

[brund321]

@Eduardo_Braz Tem certeza? Eu acho que sua interpretação da questão está errada, se você seguir essa lógica com os outros inputs do exemplo não bate com o resultado. 

  Exemplo 1 ->  5 10 3 2 4 7 9 8 5 Resultado: 2 4 7 9 -> output será o tamanho do resultado -1

  Exemplo 2 -> 10 8 7 5 2 Resultado: Qualquer número seria a resposta. o output será 1-1 que será 0

  Exemplo 3 -> 1 2 0 40 34 35 16 Resultado: Aqui tem duas opções: 1 2 OU 34 35 -> output será o tamanho de resultado -1 

[Eduardo_Braz]

@brund321 To bugado

[brund321]

@Eduardo_Braz Não sei se você leu os exemplos, sem querer eu enviei o post antes de escrever eles rsrs. Então você tem que achar o maior segmento de ordem crescente na array recebida, isso não quer dizer que precisa ser assim 1,2,3,4,5. Ordem crescente quer dizer o próximo número tem que ser maior que ou igual ao anterior, então poderia ser 1, 10000, 100000000. Faz sentido?

[Eduardo_Braz]

1 minuto atrás, brund321 disse:

@Eduardo_Braz Não sei se você leu os exemplos, sem querer eu enviei o post antes de escrever eles rsrs. Então você tem que achar o maior segmento de ordem crescente na array recebida, isso não quer dizer que precisa ser assim 1,2,3,4,5. Ordem crescente quer dizer o próximo número tem que ser maior que ou igual ao anterior, então poderia ser 1, 10000, 100000000. Faz sentido?

@brund321 Assim agora faz sentido

[brund321]

@Eduardo_Braz Ótimo, veja se consegue resolver agora. Se ainda não conseguir resolver deixe-me saber, se tiver algo escrito envie junto com o post. 

Abraços

[Eduardo_Braz]

@brund321 Vou fazer aqui mais eu estava lendo a saída e vi uma coisa segue abaixo.

 

"O comprimento do segmento crescente maximo e: k", onde
k é o tamanho do maior segmento crescente encontrado
 

[brund321]

@Eduardo_Braz Ele quer que você "envie" por exemplo aqui: 5 10 3 2 4 7 9 8 5

O comprimento do segmento crescente maximo e: 3 

e utilize uma quebra de linha depois de "enviar" isso.

[Eduardo_Braz]

1 minuto atrás, brund321 disse:

@Eduardo_Braz Ele quer que você "envie" por exemplo aqui: 5 10 3 2 4 7 9 8 5

O comprimento do segmento crescente maximo e: 3 

e utilize uma quebra de linha depois de "enviar" isso.

@brund321 Mais para dar 3, tarei que seguir assim 2 3 4 pois se fosse como fosse do modo que tu falaste não iria bater corretamente com a saida dada no exemplo

[brund321]

@Eduardo_Braz Leia essa parte aqui "O comprimento do segmento é dado pelo número de
elementos do segmento menos um."

adicionado 2 minutos depois

@Eduardo_Braz E ali o correto não é 2 3 4, mas sim 2 4 7 9

[Eduardo_Braz]

@brund321 Não estou conseguindo fazer o código

[brund321]

@Eduardo_Braz Eu estou de saída agora, eu vou voltar daqui 1 hora +, se você tiver algo pronto me envie aqui(para eu corrigir), se não quando chegar eu faço o código.

[Eduardo_Braz]

@brund321 Okay, Muito obrigado..

[Eduardo_Braz]

//Programa 11

 

#include <stdio.h>

 

int main(){

    

    int n, sequencia = 0, segmentos = 0;//Declaração de variáveis.

    unsigned int n1, n2; //Declaração de variáveis.

    

    scanf("%d", &n); //Entrada da quantidade de teste.

 

    if(n>0){

        while(sequencia < n){ //Loop com entrada e processamento dos números.

        

            scanf("%d", &n1);

                if(n1 - n2 == 1){ //Teste lógico.

                    segmentos++; //soma mais um no segmento.

                }

                else if (n2 - n1 == -1){//Teste lógico.

                    segmentos++;//soma mais um no segmento.

                }

                

            n2 - n1 == 1;

            sequencia++;

        }

    } 

    else{

        return 0;

    }

    

    printf("O comprimento do segmento crescente maximo e: %d\n", segmentos);

 

    return 0;

}

 

Fiquei preço nas condições para os testes

[Eduardo_Braz]

Esse código está me deixando doido 

[brund321]

@Eduardo_Braz Fala Eduardo, dei uma olhada no seu código, eu acho que você ainda não conseguiu entender o que o problema está pedindo. Eu não programo em C, então já peço perdão de início rsrs(vou postar o código). Eu acho que melhor do que eu explicar seria postar o código comentado, recomendo MUITO que você pegue um lápis e um papel e tente executar esse algoritmo com algum input para você entender como ele funciona. Depois que você entender você vai tentar implementar ele sem colar, o objetivo é aprender! Qualquer dúvida me pergunte.

Segue um algoritmo um pouco mais simples para resolver o seu problema: 

Obs: eu não sei como eu receberia o input então joguei o tamanho do vetor e o vetor em uma array e apenas "printo" o resultado, o objetivo é apenas você aprender como funciona.

int main(void) {
  int tamanhoVetor = 5;
  int vetor[5] = {10, 8, 7, 5, 2};
  int contador = 0; //aqui vamos contar o tamanho do segmento do loop
  int resultado = 0; //aqui vamos armazenar o tamanho do maior segmento

  for(int x = 0; x < tamanhoVetor; x++) {
    for(int y = x + 1; y < tamanhoVetor; y++) {
      if(vetor[y] > vetor[y - 1]) { //se passar aqui quer dizer que está em ordem crescente
        contador++; //então acrescentamos 1 ao contador
      } else {
        x = y - 1;//hm, faz no papel que você vai entender o porquê eu modifico o x aqui
        break;//se o próximo número não for maior ele quebra esse loop
      }
    }
    if(contador > resultado) {
      resultado = contador; 
    }
    contador = 0; //reseta o contador para o próximo loop
  }
  printf("%i", resultado);
  return 0;
}

Esse próximo é uma forma mais eficiente em responder esse algoritmo(tempo linear de execução), antes de estudar esse veja o de cima primeiro.

int main(void) {
  int tamanhoVetor = 7;
  int vetor[7] = {1, 2, 3, 4, 5, 6, 7};
  int contador = 0;
  int resultado = 0;

  for(int x = 1; x < tamanhoVetor; x++) {
    if(vetor[x] > vetor[x - 1]) {
      contador += 1;
    } else {
      if(contador > resultado) {
        resultado = contador;
      }
      contador = 0;
    }
  }
  if(contador > resultado) {
    resultado = contador;
  }
  printf("%i", resultado);
  return 0;
}

Obs: Testei os algoritmos com pouquíssimos inputs, pode ser que eu esteja feito algo errado.

Qualquer dúvida é só perguntar, bons estudos!

Abraço.

[Eduardo_Braz]

@brund321 Muito Obrigado vou estudar esse código valeu mesmo estava há 5 dias tentando ele.

[brund321]

@Eduardo_Braz Faz parte rsrs, continue estudando que você vai "evoluindo"

[Eduardo_Braz]

@brund321 Verdade, desistir já mais

[Ansi C]

Boa tarde!@Eduardo_Braz

Se me fosse pedido para analisar a sintaxe de seu código para a partir disso concluir se tu sabes ou não programação de linguagem C a resposta é que tu sabes. Você sabe o que é um int com e sem sinal,  Você sabe  atribuições, Você saber ler e exibir em variáveis, usou estruturas de decisão e iteração... Enfim sabe quase todo conteúdo de C necessário faltou só O entendimento de matrizes.

 

Só mais uma coisa: raciocínou  correto nessa  parte n2 - n1 == -1 porque é decrescente se (n1 > n2), mas nem sempre será uma diferença de valor igual a 1(isso já lhe foi exemplificado e em códigos).

 

 

1 hora atrás, brund321 disse:

recomendo MUITO que você pegue um lápis e um papel e tente executar esse algoritmo com algum input para você entender como ele funciona

Repito constantemente algo parecido: "como o seu cérebro resolve isto ...? ". Por quê? Senão estive bem resolvido na cabeça nada serve com C ou qualquer outra. 

 

Como já está tudo resolvido aparentemente, só quis deixa minha humilde opinião sobre o código.

 

Obrigado.

 

 

[Eduardo_Braz]

@Mauro Britivaldo Muito obrigado mano pelo o seu elogio estou tentando aprender matriz ainda estou apanhando um poco mais, é apanhando que se aprende.

 

Ps: Eu que agradeço..

[arfneto]

@Eduardo_Braz

 

Talvez já tenha terminado isso então vou mostrar uma outra maneira de tratar esse tipo de problema, muito usada na prática

 

Entendendo os tais segmentos

 

Com os dados do enunciado, marcando os segmentos

 

5 10 3 2 4 7 9 8 5, n = 9

5=====10     3     2=====4=====7=====9     8     5
     1                            1         2            3               MAX = 3

 

E o maior segmento é 2-4-7-9

 

10 8 7 5 2, n = 5

10     8     7     5     2
                          MAX = 0, série decrescente

 

E a série é decrescente então não há segmentos

 

1 2 0 40 34 35 16, n = 7

1=====2     0=====40     34=====35     16
     1                  1                      1           MAX = 1

 

E esta última série tem 3 segmentos de comprimento um

 

Como um segmento é dado por ao menos dois pontos, inicial e final, claro que o segmento de comprimento N tem (N+1) pontos e de modo inverso X pontos em ordem crescente criam um segmento de comprimento (X-1), como está no enunciado

 

Uma maneira de programar isso 

 

Entenda que num dado momento

• estamos buscando um segmento
• ou estamos dentro de um segmento vendo se ele continua crescendo
• ao terminar um segmento vemos se é o maior até o momento
• passamos uma e uma única vez por cada um dos pontos da sequência

Um algoritmo que facilita muito em geral programar esse tipo de problema é um modelo matemático conhecido como máquina finita de estados. Detalhes aqui em português.

 

Porque usar essa coisa? Porque fica muito mais fácil de programar e testar quando se consegue separar o problema em estados independentes: no código você não precisa testar toda hora  o contexto em que está. Por isso a gente usa muito por exemplo em protocolos de comunicação e em problemas tipo transação.

 

Exemplo de saída de um programa usando essa técnica

O comprimento do segmento crescente maximo e: 3
O comprimento do segmento crescente maximo e: 0
O comprimento do segmento crescente maximo e: 1

E a função declarada assim

int            maior_segmento(int, int[]);

E usada assim em main() para os valores do enunciado

int main(int argc, char** argv)
{
    maior_segmento(9, vetor_teste_1);
    maior_segmento(5, vetor_teste_2);
    maior_segmento(7, vetor_teste_3);
    return 0;
}

Essa é uma possibilidade para a função, usando  2 estados. Sim, essa função é muito simples mas por isso mesmo parece um bom exemplo para mostrar a mecânica

int maior_segmento(int n, int sequencia[])
{
#define        BUSCANDO        'b'
#define        EM_SEGMENTO     's'

    int         este = 0, maior = 0;
    char        e;
    for (int indice = 0, e = BUSCANDO; indice < n; indice += 1)
    {	// percorre toda a sequencia
        switch (e)
        {
        case BUSCANDO:
            if (sequencia[indice + 1] > sequencia[indice])
            {
                este = 1;	// NOVO segmento
                e = EM_SEGMENTO;	// muda ESTADO
            }
            break;

        case EM_SEGMENTO:
            if (sequencia[indice + 1] > sequencia[indice])
                este += 1;	// conta esse e continua
            else
            {
                maior = (este > maior) ? este : maior; // seria maior?
                e = BUSCANDO; // novo estado: segmento acabou
            }
            break;
        }    // end switch()
    };    // end for
  // atende o enunciado
    printf("O comprimento do segmento crescente maximo e: %d\n", maior);
    return maior; 
}

Eis o programa todo de teste com os dados do enunciado 

#include "stdio.h"


int                vetor_teste_1[9] = {5, 10, 3, 2, 4, 7, 9, 8, 5 };
int                vetor_teste_2[5] = { 10, 8, 7, 5, 2 };
int                vetor_teste_3[7] = { 1, 2, 0, 40, 34, 35, 16 };

int            maior_segmento(int, int[]);

int main(int argc, char** argv)
{
    maior_segmento(9, vetor_teste_1);
    maior_segmento(5, vetor_teste_2);
    maior_segmento(7, vetor_teste_3);
    return 0;
}

int maior_segmento(int n, int sequencia[])
{
#define        BUSCANDO        'b'
#define        EM_SEGMENTO        's'

    int            este = 0, maior = 0;
    char        e;
    for (int indice = 0, e = BUSCANDO; indice < n; indice += 1)
    {
        switch (e)
        {
        case BUSCANDO:
            if (sequencia[indice + 1] > sequencia[indice])
            {
                este = 1;
                e = EM_SEGMENTO;
            }
            break;

        case EM_SEGMENTO:
            if (sequencia[indice + 1] > sequencia[indice])
                este += 1;
            else
            {
                maior = (este > maior) ? este : maior;
                e = BUSCANDO;
            }
            break;
        }    // end switch()
    };    // end for
    printf("O comprimento do segmento crescente maximo e: %d\n", maior);
    return maior;
}

Não vou dizer que é melhor ou sequer se é bom, mas esse modelo matemático --- FSM de finite state machine na literatura --- é usado para problemas realmente complexos. A vantagem maior é de isolamento: você trata exatamente uma situação de um certo universo de estados. E o próprio trabalho de identificar esses estados ajuda a compreender com mais profundidade o problema.

adicionado 59 minutos depois

 confesso que não tinha lido o artigo da wikipedia de que eu falei e agora eu vi. Achei bem fraco. Talvez seja melhor procurar por outras referências

[Eduardo_Braz]

@arfneto Muito Obrigado