Найти минимального значения в массиве

Question

У меня есть два массива:

int playerSums[9] = { }; 
string playerNames[9] = { }; 

Я пытаюсь получить наименьшее значение в массиве playerSums, а также индекс массива этого значения.

Вот что я пытался до сих пор:

if (playerNames[index] == "End" || playerNames[index] == "end") { 
    int lowestValue = playerSums[0]; 
    for (i = 1; i < sizeof(playerSums)/sizeof(playerSums[0]); i++) { 
     if (playerSums[i] < lowestValue || lowestValue != 0) 
      lowestValue = playerSums[i]; 
    } 
    cout << index[playerNames] << " had the lowest values and got the sum "; 
    cout << lowestValue << endl; 
} 

Как найти и отобразить наименьшее значение в массиве playerSums если, например, только 3 игрока играют, то есть только 3 элементов массив заполняется (а остальные элементы равны нулю)?

Мне нужен указатель, чтобы отобразить имя игрока, который получил наименьшее значение.

Answer 1

Вы можете использовать стандартный алгоритм std::min_element заявленных в заголовке <algorithm>, что, чтобы найти WITN минимального элемента суммы. Например

#include <algorithm> 

int *min = std::min_element(playerSums, playerSums + 3); 

std::cout << playerNames[min - playerSums] 
      << " had the lowest values and got the sum " << *min 
      << std::endl; 

То же самое можно записать с помощью стандартных функций std::begin, std::end и std::distance объявленных в заголовке <iterator>

#include <algorithm> 
#include <iterator> 

int *min = std::min_element(std::begin(playerSums), std::end(playerSums)); 

std::cout << playerNames[ std::distance(playerSums, min)] 
      << " had the lowest values and got the sum " << *min 
      << std::endl; 

Вместо использование алгоритма вы могли бы написать свою собственную функцию, аналогичную алгоритму. Например

size_t min_sum(int playerSums[], size_t n) 
{ 
    size_t min = 0; 

    for (size_t i = 1; i < n; i++) 
    { 
     if (playerSums[min] < playerSums[i]) min = i; 
    } 

    return min; 
} 

size_t min = min_sum(playerSums, sizeof(playerSums)/sizeof(*playerSums) ); 

std::cout << playerNames[min] 
      << " had the lowest values and got the sum " << playerSums[min] 
      << std::endl; 

Если необходимо пропустить элементы массива, которые равны нулю, то функция будет выглядеть

size_t min_sum(int playerSums[], size_t n) 
{ 
    size_t min = 0; 

    while (min < n && playerSums[i] == 0) ++min; 

    for (size_t i = min; i < n; i++) 
    { 
     if (playerSums[min] < playerSums[i]) min = i; 
    } 

    return min; 
} 

size_t min = min_sum(playerSums, sizeof(playerSums)/sizeof(*playerSums) ); 

if (min != sizeof(playerSums)/sizeof(*playerSums)) 
{ 
    std::cout << playerNames[min] 
       << " had the lowest values and got the sum " << playerSums[min] 
       << std::endl; 
} 

Answer 2

Вы знаете индекс элемента присвоенным lowestValue при изменении значения этой переменной, так что просто сохранить этот индекс в переменной (скажем, index), так что, когда вы сделали index имеет индекс последнего значения назначены.

Answer 3

Сначала скорректируйте свое состояние цикла. Я не уверен, что вы определили i раньше, так что, возможно, вы это забыли. Вторым является условие остановки i < sizeof (palyerSums). Также вам нужно сохранить индекс самого низкого playerSums в массиве. Условие if также имеет слишком много. Если lowValue не равен нулю, вы всегда будете изменять это значение, что не кажется правильным, если lowValue не равно нулю.

int lowestValue = playerSums[0]; 
int resultIndex = 0; 
for(int i = 1; i < sizeof(playerSums)/sizeof(playerSums[0]); i++) { 
    if(playerSums[i] < lowestValue) { 
    lowestValue = playerSums[i]; 
    resultIndex = i; 
    } 
} 
cout << playerNames[resultIndex] << "blabla" << lowestValue; // instead of lowestValue you could also do playerSums[resultIndex] ofcourse. 

Позволь мне знать, если это работает

Answer 4

так же, как вы сохраняете самое низкое значение в lowestValue, хранить индекс в переменной, скажем, lowestValueIndex. Кроме того, удалить внешний, если и переместить его внутри для цикла:

if(playerNames[i] == "End" || playerNames[i] == "end") 
    break; 

таким образом, вы убедитесь, что только игроки, которые играют будут обработаны. Кроме того, вам не нужно будет проверять, является ли самое низкое значение равным нулю.Таким образом, код будет выглядеть следующим образом:

int lowestValue = playerSums[0]; 
int lowestValueIndex = 0; 
for (int i = 1; i < sizeof(playerSums)/sizeof(playerSums[0]); ++i) 
{ 
    if(playerNames[i] == "End" || playerNames[i] == "end") 
     break; 
    if (playerSums[i] < lowestValue) 
    { 
      lowestValue = playerSums[i]; 
      lowestValueIndex = i; 
    } 
} 
cout << index[playerNames] << " had the lowest values and got the sum " 
    << lowestValue << endl; 

Так же, как примечание, используйте стандартный массив, который может расти, чтобы упростить это (как vector):

std::vector<std::string> playerNames; 
std::vector<int> playerSums; 

for (int i = 1; i < playerSums.size(); ++i) 
{ 
    if (playerSums[i] < lowestValue) 
    { 
      lowestValue = playerSums[i]; 
      lowestValueIndex = i; 
    } 
} 
cout << index[playerNames] << " had the lowest values and got the sum " 
    << lowestValue << endl; 

Answer 5

Как обычно, самое простое решение заключается в использовании стандартная библиотека , например

auto it = std::min_element(std::begin(playerSums), std::end(playerSums)); 
std::size_t index = std::distance(std::begin(playerSums), it); 

Теперь вы можете получить мин значения разыменования итератора it:

int lowestValue = *it; 

Если вы хотите перебрать первых 3 элементов в массиве, то вы можете сделать что-то вроде этого вместо:

auto first = std::begin(playerSums); 
auto it = std::min_element(first, std::next(first, 3)); 
std::size_t index = std::distance(first, it); 

Примечание: предпочитают std::next вместо простой арифметики указателей (например, playerSums + 3), поскольку он более общий (работает на всех типах итераторов).