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

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

Thiago Soares Mota
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;
}



  


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

Fernando
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.


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

Paulo Jr
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];

}
}



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

Fernando
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 



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

Fernando
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:


Vetor original: {1,20,19,6,14,15,19,11,3,2,19,19,7,0,17,13,8,18,6,1}

Teste em ciclos de CPU

Sexto maior elemento (cópia): 14
CiclosCPU: 39055

Sexto maior elemento (iter) : 14
CiclosCPU: 11440


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"






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts