Как сделать эту программу меньше, эффективнее?

Question

Как сделать эту программу меньше, эффективнее?

Я делал практический вопрос, который звучал так:

Напишите программу, которая просит пользователя ввести количество съеденных гамбургеров
десятью разными людьми (p1, p2, … и т. д.)

После того, как данные введены, программа должна проанализировать данные и вывести, какой человек ел меньше всего гамбургеров, и вывести человека, который съел больше всего гамбургеров.

Я знаю, что мой код не идеален (мягко говоря, но я был полон решимости просто закончить его, чтобы у меня было, на что ответить на этот вопрос. Если вы хотите помочь, не бойтесь бросить у меня есть более сложные вещи, вот как я учусь, верно?

Вот мой код:

#include <iostream>

#include <string>

using namespace std;

int main()
{
int p1 = 0;

int p2 = 0;

int p3 = 0;

int p4 = 0;

int p5 = 0;

int p6 = 0;

int p7 = 0;

int p8 = 0;

int p9 = 0;

int p10 = 0;cout << "How many pancakes did p1 eat?" << endl;
cin >> p1;

cout << "How many pancakes did p2 eat?" << endl;
cin >> p2;

cout << "How many pancakes did p3 eat?" << endl;
cin >> p3;

cout << "How many pancakes did p4 eat?" << endl;
cin >> p4;

cout << "How many pancakes did p5 eat?" << endl;
cin >> p5;

cout << "How many pancakes did p6 eat?" << endl;
cin >> p6;

cout << "How many pancakes did p7 eat?" << endl;
cin >> p7;

cout << "How many pancakes did p8 eat?" << endl;
cin >> p8;

cout << "How many pancakes did p9 eat?" << endl;
cin >> p9;

cout << "How many pancakes did p10 eat?" << endl;
cin >> p10;// LARGE section of if statements incoming// Test to see which person ate the least pancakes

if (p1 < p2 && p1 < p3 && p1 < p4 && p1 < p5 && p1 < p6 && p1 < p7 && p1 < p8 && p1 < p9 && p1 < p10)
{
cout << "p1 ate the least pancakes." << endl;
}

if (p2 < p1 && p2 < p3 && p2 < p4 && p2 < p5 && p2 < p6 && p2 < p7 && p2 < p8 && p2 < p9 && p2 < p10)
{
cout << "p2 ate the least pancakes." << endl;
}

if (p3 < p1 && p3 < p2 && p3 < p4 && p3 < p5 && p3 < p6 && p3 < p7 && p3 < p8 && p3 < p9 && p3 < p10)
{
cout << "p3 ate the least pancakes." << endl;
}

if (p4 < p1 && p4 < p2 && p4 < p3 && p4 < p5 && p4 < p6 && p4 < p7 && p4 < p8 && p4 < p9 && p4 < p10)
{
cout << "p4 ate the least pancakes." << endl;
}

if (p5 < p1 && p5 < p2 && p5 < p3 && p5 < p4 && p5 < p6 && p5 < p7 && p5 < p8 && p5 < p9 && p5 < p10)
{
cout << "p5 ate the least pancakes." << endl;
}

if (p6 < p1 && p6 < p2 && p6 < p3 && p6 < p4 && p6 < p5 && p6 < p7 && p6 < p8 && p6 < p9 && p6 < p10)
{
cout << "p6 ate the least pancakes." << endl;
}

if (p7 < p1 && p7 < p2 && p7 < p3 && p7 < p4 && p7 < p5 && p7 < p6 && p7 < p7 && p7 < p9 && p7 < p10)
{
cout << "p7 ate the least pancakes." << endl;
}

if (p8 < p1 && p8 < p2 && p8 < p3 && p8 < p4 && p8 < p5 && p8 < p6 && p8 < p7 && p8 < p9 && p8 < p10)
{
cout << "p8 ate the least pancakes." << endl;
}

if (p9 < p1 && p9 < p2 && p9 < p3 && p9 < p4 && p9 < p5 && p9 < p6 && p9 < p7 && p9 < p8 && p9 < p10)
{
cout << "p9 ate the least pancakes." << endl;
}

if (p10 < p1 && p10 < p2 && p10 < p3 && p10 < p4 && p10 < p5 && p10 < p6 && p10 < p7 && p10 < p8 && p10 < p9)
{
cout << "p10 ate the least pancakes." << endl;
}// Test to see who ate the most pancakes

if (p1 > p2 && p1 > p3 && p1 > p4 && p1 > p5 && p1 > p6 && p1 > p7 && p1 > p8 && p1 > p9 && p1 > p10)
{
cout << "p1 ate the most pancakes." << endl;
}

if (p2 > p1 && p2 > p3 && p2 > p4 && p2 > p5 && p2 > p6 && p2 > p7 && p2 > p8 && p2 > p9 && p2 > p10)
{
cout << "p2 ate the most pancakes." << endl;
}

if (p3 > p1 && p3 > p2 && p3 > p4 && p3 > p5 && p3 > p6 && p3 > p7 && p3 > p8 && p3 > p9 && p3 > p10)
{
cout << "p3 ate the most pancakes." << endl;
}

if (p4 > p1 && p4 > p2 && p4 > p3 && p4 > p5 && p4 > p6 && p4 > p7 && p4 > p8 && p4 > p9 && p4 > p10)
{
cout << "p4 ate the most pancakes." << endl;
}

if (p5 > p1 && p5 > p2 && p5 > p3 && p5 > p4 && p5 > p6 && p5 > p7 && p5 > p8 && p5 > p9 && p5 > p10)
{
cout << "p5 ate the most pancakes." << endl;
}

if (p6 > p1 && p6 > p2 && p6 > p3 && p6 > p4 && p6 > p5 && p6 > p7 && p6 > p8 && p6 > p9 && p6 > p10)
{
cout << "p6 ate the most pancakes." << endl;
}

if (p7 > p1 && p7 > p2 && p7 > p3 && p7 > p4 && p7 > p5 && p7 > p6 && p7 > p7 && p7 > p9 && p7 > p10)
{
cout << "p7 ate the most pancakes." << endl;
}

if (p8 > p1 && p8 > p2 && p8 > p3 && p8 > p4 && p8 > p5 && p8 > p6 && p8 > p7 && p8 > p9 && p8 > p10)
{
cout << "p8 ate the most pancakes." << endl;
}

if (p9 > p1 && p9 > p2 && p9 > p3 && p9 > p4 && p9 > p5 && p9 > p6 && p9 > p7 && p9 > p8 && p9 > p10)
{
cout << "p9 ate the most pancakes." << endl;
}

if (p10 > p1 && p10 > p2 && p10 > p3 && p10 > p4 && p10 > p5 && p10 > p6 && p10 > p7 && p10 > p8 && p10 > p9)
{
cout << "p10 ate the most pancakes." << endl;
}return 0;
}

0

c++processing-efficiency

Решение

Другие решения

Я не понимаю, почему ответ должен быть таким сложным.

Это может быть сделано очень легко с vector:

  auto num_eaten = std::vector<int>(10);

for (auto i = 0u; i < num_eaten.size(); ++i) {
cout << "Enter number of hamburgers eaten by " << (i + 1) << "> ";
cin >> num_eaten[i];
}

auto min_it = std::min_element(num_eaten.begin(), num_eaten.end());
cout << (std::distance(num_eaten.begin(), min_it) + 1) << " ate the least"<< endl;

auto max_it = std::max_element(num_eaten.begin(), num_eaten.end());
cout << (std::distance(num_eaten.begin(), max_it) + 1) << " ate the most"<< endl;

или с map:

  auto eaten = std::unordered_map<int, int>{};

for (auto i = 1; i < 10; ++i) {
cout << "Enter number of hamburgers eaten by " << i << "> ";
cin >> eaten[i];
}

auto min_it = std::min_element(
eaten.begin(), eaten.end(),
[](auto const &lhs, auto const &rhs) { return lhs.second < rhs.second; });
cout << min_it->first << " ate the least: " << min_it->second << endl;

auto max_it = std::min_element(
eaten.begin(), eaten.end(),
[](auto const &lhs, auto const &rhs) { return lhs.second > rhs.second; });

cout << max_it->first << " ate the most: " << max_it->second << endl;

0

Ваш комментарий правильный.

редакция:
создать структуру s1;

с тремя значениями — личный индекс, количество гамбургеров и блинов.

Заполните и поместите s1 в вектор

используйте std :: sort для подсчета гамбургеров. — распечатайте значения, которые вы хотите.

используйте std :: sort для подсчета блинов — выведите нужные значения.

Больший счет будет на одном конце (и наименьший счет на другом).

редакция 14.05.2015:

Время ответить на ваш вопрос — как сделать меньше.

Вы просто определяете шаблон … и сопоставляете его с циклом for.

идея шаблона 1 — последовательность personId от 1 до 10;

Приводит нас к:

for (int personId = 1; personId <= 10; ++personId)
{

}

Для каждого человека ваш код запрашивает количество — блины, а затем гамбургеры:

for (int personId = 1; personId <= 10; ++personId)
{
cout << "How many pancakes did p" << personId << " eat?" << endl;
int p1 = 0;
cin >> p1;

cout << "How many hamburgers did p" << personId << " eat?" << endl;
int p2 = 0;
cin >> p2;

// perhaps these should be joined into a single prompt to get 2 numbers
// example:
cout << "Enter pancake count, then hamburger count: " << endl;
int p1 = 0;
int p2 = 0;
cin >> p1 >> p2;
// error handling is somewhat easier in the 1st style.

}

Чтобы определить, какая из них наименьшая или большая, я рекомендую поместить эти элементы в вектор для сортировки.

struct S1 {
int personId;
int pancakeCount;
int hamburgerCount;

// define ctor
S1(void) : personId(0), pancakeCount(0), hamburgerCount(0)
{
}
};

vector<S1> s1Vec;

for (int personId = 1; personId <= 10; ++personId)
{
cout << "How many pancakes did p" << personId << " eat?" << endl;
int p1 = 0;
cin >> p1;

cout << "How many hamburgers did p" << personId << " eat?" << endl;
int p2 = 0;
cin >> p2;

{
S1 s1; // declare an instance, and fill in
s1.personId = personId;
s1.pancackecount = p1;
s1.hamburgerCount = p2;

s1Vec.push_back(s1);  // default cpy-ctor will capture into vec
} // THIS brace triggers the dtor of s1 ... currently does nothing,
// but sometimes the intermediate structs / classes need cleaning
}

// now you have all ids and counts captured to the vector

// sort s1Vec by pancakeCount, and
//  print out s1Vec.begin() and .end()

// sort s1Vec by hamburgerCount, and
//   print out s1.begin() and .end()

Я предлагаю вам добавить метод шоу в S1 …

struct S1 {
int personId;
int pancakeCount;
int hamburgerCount;

// define ctor to initialize values
S1(void) : personId(0), pancakeCount(0), hamburgerCount(0)
{
}

std::string show(void)
{
stringstream ss;
ss << "person: " << personId
<< "    p1: " << pancakeCount
<< "    p2: " << hamburgerCount << endl;
return (ss.str());
}

std::string showP1(void)
{
stringstream ss;
cout << "person: " << personId
<< "    p1: " << pancakeCount << endl;
return (ss.str());
}

std::string showP2(void)
{
stringstream ss;
cout << "person: " << personId
<< "    p2: " << hamburgerCount << endl;
return (ss.str());
}

};

Удачи.

Это уменьшает размер вашего кода с помощью цикла и структуры.

Ваш код можно считать «развернутым» циклом, который вы можете рассмотреть из-за проблем с производительностью. Но эй, Пользовательский ввод / вывод (запросы и ответы) никогда не может быть высокая производительность.

0

Источник

Accepted Answer

Вектор количества блинов

Попробуй это:

typedef std::vector<unsigned int> Pancake_Container;
const unsigned int MAXIMUM_PARTICIPANTS = 10;
Pancake Container pancake_quantities(MAXIMUM_PARTICIPANTS);
for (unsigned int i = 0U; i < MAXIMUM_PARTICIPANTS; ++i)
{
static const char prompt_text1[] = "\nHow many pancakes did participant #";
static const char prompt_ending[] = " eat? ";
cout.write(prompt_text1, sizeof(prompt_text1) - 1U);
cout << i;
cout.write(prompt_ending, sizeof(prompt_ending) - 1U));
unsigned int quantity = 0U;
cin >> quantity;
pancake_quantities[i] = quantity;
}

unsigned int max_person_index = 0U;
unsigned int max_pancakes_eaten = 0U;
unsigned int min_person_index = 0U;
unsigned int min_pancakes_eaten = MAX_UINT;
for (unsigned int i = 0U; i < MAXIMUM_PARTICIPANTS; ++i)
{
const unsigned int quantity = pancake_quantities[i];
if (quantity > max_pancakes_eaten)
{
max_person_index = i;
max_pancakes_eaten = quantity;
}
if (quantity < min_pancakes_eaten)
{
min_person_index = i;
min_pancakes_eaten = quantity;
}
}

cout << "Person #" << max_person_index << " ate " << max_pancakes_eaten << "\n";
cout << "Person #" << min_person_index << " ate " << min_pancakes_eaten << "\n";

Вектор структур

Этот позволяет сортировать, чтобы вычислить максимум и минимум.

struct Pancake_Info
{
unsigned int id;
unsigned int quantity;
Pancake_Info() : id(0), quantity(0)
{}
bool operator < (const Pancake_Info& other)
{
return quantity < other.quantity;
}
};

typedef std::vector<Pancake_Info> Pancake_Container;
Pancake_Container pancake_quantities;
for (unsigned int i = 0U; i < MAXIMUM_PARTICIPANTS; ++i)
{
static const char prompt_text1[]  = "\nHow many pancakes did participant #";
static const char prompt_ending[] = " eat? ";
cout.write(prompt_text1, sizeof(prompt_text1) - 1U);
cout << i;
cout.write(prompt_ending, sizeof(prompt_ending) - 1U);
unsigned int quantity = 0U;
Pancake_Info p_i;
cin >> p_i.quantity;
p_i.id = i;
pancake_quantities.push_back(p_i);
}
std::sort(pancake_quantities.begin(), pancake_quantities.end());
cout << "Minimum of "<< pancake_quantities[0].quantity
<< " eaten by person "<< pancake_quantities[0].id
<< "\n";
cout << "Maximum of "<< pancake_quantities[MAXIMUM_PARTICIPANTS - 1].quantity
<< " eaten by person "<< pancake_quantities[MAXIMUM_PARTICIPANTS - 1].id
<< "\n";

2