TallPeople

Used In: SRM 208
Used As: Division I Level One

Problem Statement

A group of people stand before you arranged in rows and columns. Looking from above, they form an R by C rectangle of people. You will be given a String[] people containing the height of each person. Elements of people correspond to rows in the rectangle. Each element contains a space-delimited list of integers representing the heights of the people in that row. Your job is to return 2 specific heights in a int[]. The first is computed by finding the shortest person in each row, and then finding the tallest person among them (the "tallest-of-the-shortest"). The second is computed by finding the tallest person in each column, and then finding the shortest person among them (the "shortest-of-the-tallest").

Definition

Class: TallPeople
Method: getPeople
Parameters: String[]
Returns: int[]
Method signature: int[] getPeople(String[] people)
(be sure your method is public)

Constraints

• people will contain between 2 and 50 elements inclusive.
• Each element of people will contain between 3 and 50 characters inclusive.
• Each element of people will be a single space-delimited list of positive integers such that:
• Each positive integer is between 1 and 1000 inclusive with no extra leading zeros.
• Each element contains the same number of integers.
• Each element contains at least 2 positive integers.
• Each element does not contain leading or trailing whitespace.

Examples

1. {"9 2 3",
   "4 8 7"} Returns: { 4, 7 }
   The heights 2 and 4 are the shortest from the rows, so 4 is the taller of the two. The heights 9, 8, and 7 are the tallest from the columns, so 7 is the shortest of the 3.

2. {"1 2",
   "4 5", "3 6"} Returns: { 4, 4 }

3. {"1 1",
   "1 1"} Returns: { 1, 1 }

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

using namespace std;

class TallPeople {  
    public:
        vector<int> getPeople(vector<string> people) {
            vector<vector<int> > grid(people.size());
            for (int i = 0; i < people.size(); ++i) {
                istringstream iss(people[i]);
                int n;
                while (iss >> n) {
                    grid[i].push_back(n);
                }
            }
            int tos = 0;
            for (int i = 0; i < grid.size(); ++i) {
                int shortInRow = grid[i][0];
                for (int j = 1; j < grid[i].size(); ++j) {
                    if (grid[i][j] < shortInRow) {
                        shortInRow = grid[i][j];
                    }
                }
                if (shortInRow > tos) {
                    tos = shortInRow;
                }
            }
            int sot = 10000;
            for (int i = 0; i < grid[0].size(); ++i) {
                int tallestInColumn = grid[0][i];
                for (int j = 1; j < grid.size(); ++j) {
                    if (grid[j][i] > tallestInColumn) {
                        tallestInColumn = grid[j][i];
                    }
                }
                if (tallestInColumn < sot) {
                    sot = tallestInColumn;
                }
            }
            vector<int> ans(2);
            ans[0] = tos, ans[1] = sot;
            return ans;
        }
};