Função que recebe 20 números inteiros e retorna o 6° maior elemento do vetor.

thiagomota456
(usa Ubuntu)

Enviado em 22/10/2017 - 12:17h

Olá, Sou um estante de engenharia do 1° período, e em resumo semana passada fiz uma prova q não consegui resolver uma das questões. Estou refazendo ela para aprender o que tive dificuldade. Na prova em si eu simplesmente ordenei o vetor e imprimi a 6° posição, mas essa solução não é valida uma vez que não posso alterar o vetor recebido como parâmetro e pode haver elementos repetidos.
Vou enviar o novo código que estou fazendo, se puderem, por favor me expliquem como fazer ou mesmo criando uma função que realize a tarefa para que eu entenda como funciona.

/*



	int sexto_maior:

		1°- Recebe um vetor como parametro de 20 números inteiros

		2°- Ñ modificar vetor recebido e pode háver n° repetidos

		3°- Retornar Sexto maior

		

*/

#include<stdio.h>

#include<stdlib.h>

#include<time.h>





#define TAM 20



void aleatorio()//OK

{

	srand(time(0));

}



void preencher(int vetor[])//OK

{

	int i;



	aleatorio();

	//prenchimento 

	/*mensagem para teste*/printf("Vetor:");

	for(i=0;i<TAM;i++)

	{

		vetor[i]=(1+rand()%20);

		/*mensagem para teste*/printf("%d ",vetor[i]);

	}

	/*mensagem para teste*/putchar('\n');

}



int sexto_maior(int vetor[])

{

	

}



int main()

{

	int vetor[TAM];

	preencher(vetor);

	return 0;

}

 

phoemur
(usa Debian)

Enviado em 22/10/2017 - 13:39h

Eu teria duas alternativas:

1-) A mais fácil: faça uma cópia do vetor, ordene a cópia e ache o 6º maior elemento. Assim você não modifica o vetor original e acha o elemento com a mesma lógica de antes.

2-) Fazer um contador, iterar 6 vezes pelo vetor cada vez pegando um máximo < máximo anterior;

O que é mais eficiente vai depender do tamanho do vetor, do custo de criação de objetos que compõe o vetor, do custo e disponibilidade para alocação de memória, se a comparação é feita por igualdade ou por identidade, enfim, são várias variáveis...
Eu tendo sempre a preferir o que é mais simples de entender, ou seja, optaria pela primeira opção.

Pebis
(usa Debian)

Enviado em 22/10/2017 - 14:23h

Inclui um if dentro do for

	for(i=0;i<TAM;i++)

	{

		vetor=(1+rand()%20);

		/*mensagem para teste*/printf("%d ",vetor[i]);

        [i]            if(maior < vetor[i]){

                         maior=vetor[i];

}

}

 

phoemur
(usa Debian)

Enviado em 22/10/2017 - 14:33h

Eu fiz aqui considerando as duas alternativas que eu te disse:

main.cpp

#include <iostream>

#include <random>

#include <vector>

#include <set>



using namespace std;



int sexto_maior_copia(const vector<int>& vec)

{

    //cópia para um set que já é ordenado e tem elementos unicos

    set<int> buffer (vec.begin(), vec.end()); 

    auto it = buffer.rbegin();

    advance(it, 5);

    return *it;

}



int sexto_maior_iter(const vector<int>& vec)

{   // Aqui iterando 6 vezes e cada vez pegando um

    // máximo[i] < máximo[i+1]

    int currMax=0;

    for (int j=0; j<vec.size();++j) {

        if (vec[j] > currMax) {currMax = vec[j];}

    }

    

    for (int i=0; i<5; ++i) {

        int m = 0;

        for (int j=0; j<vec.size();++j) {

            if (vec[j] > m && vec[j] < currMax) {

                m = vec[j];   

            }

        }

        currMax = m;

    }

    return currMax;    

}



int main()

{

    random_device seeder;

    mt19937 engine(seeder());

    uniform_int_distribution<int> dist(0, 20);

    

    // Cria um vector com 20 elementos aleatórios

    vector<int> original;

    original.reserve(20);

    for (int i=0; i<20; ++i) {

        original.emplace_back(dist(engine));

    }

    

    // Pega o sexto maior elemento pelos dois métodos

    int elem = sexto_maior_copia(original);

    int elem2 = sexto_maior_iter(original);

    

    // Imprime

    cout << "Vetor original: " << '{';

    for (int i=0; i<original.size(); ++i) {

        cout << original[i];

        cout << (i == original.size()-1 ? '}':',');

    }

    

    cout << "\nSexto maior elemento (cópia): " << elem << endl;

    cout << "Sexto maior elemento (iter) : " << elem2 << endl;

    return 0;

}

 

compilar com

g++ -o main main.cpp -O3 --std=c++14 

phoemur
(usa Debian)

Enviado em 22/10/2017 - 15:15h

https://gist.github.com/phoemur/478e01258ddd88c94195db08a851c2cf

No link acima um benchmark que considera os ciclos de CPU para cada uma das funções:



Mesmo compilando com otimizações -O3 a função iterativa sempre é mais eficiente.
Porém, ao menos que esse seja o gargalo do seu programa, não faz muita diferença.
Opte sempre pelo código mais expressivo e legível.

"Premature optimization is the root of all evil -- DonaldKnuth"