## DEV Community is a community of 894,881 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

# Daily Challenge #187 - Most Sales

You work in the best consumer electronics company around. Your boss asked you to find out which products generate the most revenue.

You'll be given lists of `products`, `amounts`, and `prices`. Given these three lists of same length, return the product name(s) with the highest revenue (`amount * price`). If multiple products have the same revenue, order them according to their original positions.

### Example

products: ["Computer", "Cell Phones", "Vacuum Cleaner"]
amounts: [3, 24, 8]
prices: [199, 299, 399]

return: `Cell Phones`

### Test

products: `["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"]`
amounts: `[0, 12, 24, 17, 19, 23, 120, 8]`
prices: `[9, 24, 29, 31, 51, 8, 120, 14]`

This challenge comes from JakobPri on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

## Discussion (10) Avalander • Edited on

## Scala

``````object MostSales {
private implicit val order = Ordering.Int.reverse

private val total = (x: ((Int, Int), String)) => x match {
case ((a, p), n) => (n, a * p)
}

def findHighest (names: Seq[String], amounts: Seq[Int], prices: Seq[Int]): Seq[String] = {
val sorted = amounts zip prices zip names map total sortBy (_._2)
val result = sorted takeWhile (_._2 == sorted.head._2)
result map (_._1)
}
}
``````

And some tests

``````import org.scalatest._

class MostSalesTest extends FunSuite {
import MostSales._

test("Case 1") {
val products = List("Computer", "Cell Phones", "Vacuum Cleaner")
val amounts = List(3, 24, 8)
val prices = List(199, 299, 399)

val result = findHighest(products, amounts, prices)
assert(result == List("Cell Phones"))
}

test("Case 2") {
val products = List("Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers")
val amounts = List(0, 12, 24, 17, 19, 23, 120, 8)
val prices = List(9, 24, 29, 31, 51, 8, 120, 14)

val result = findHighest(products, amounts, prices)
assert(result == List("Lego"))
}

test("Returns multiple results") {
val products = List("Computer", "Cell Phones", "Vacuum Cleaner")
val amounts = List(3, 2, 6)
val prices = List(200, 299, 100)

val result = findHighest(products, amounts, prices)
assert(result == List("Computer", "Vacuum Cleaner"))
}
}
`````` SavagePixie

Elixir

``````def get_max_revenue(products, amounts, prices) do
list = Enum.zip([ products, amounts, prices ])
|> Enum.map(fn { product, amount, price } -> { product, amount * price } end)
|> Enum.sort(fn { _, r1 }, { _, r2 } -> r1 >= r2 end)
first = list
|> List.first
|> (fn { _, revenue } -> revenue end).()
Enum.take_while(list, fn { _, revenue } -> revenue == first end)
|> Enum.map(fn { product, _ } -> product end)
end
`````` Avalander

``````module MostSales where

import Data.List (groupBy, head, zip3, sortBy)

findHighest :: [String] -> [Int] -> [Int] -> [String]
findHighest a b c =
((map fst) . head . (groupBy value) . (sortBy compare') . (map total)) \$ (zip3 a b c)
where
total (n, a, b)        = (n, a * b)
value (_, x)           = ((==) x . snd)
compare' (_, a) (_, b) = compare b a
`````` Sabin Pandelovitch

Javascript - Reduce method

``````const products = [
"Cell Phones",
"Vacuum Cleaner",
"Computer",
"Autos",
"Gold",
"Fishing Rods",
"Lego",
" Speakers"
];
const amounts = [0, 12, 24, 17, 19, 23, 120, 8];
const prices = [9, 24, 29, 31, 51, 8, 120, 14];

const { productName } = products.reduce(
(acc, val, i) =>
amounts[i] * prices[i] > acc.value
? {
productName: val,
value: amounts[i] * prices[i]
}
: acc,
{ productName: "", value: 0 }
);

console.log(productName);
`````` Michael Kohl • Edited on

OCaml, with Core as stdlib:

``````let highestSales products amounts prices =
List.map3_exn products amounts prices (fun prod a p -> prod, a * p)
|> List.max_elt ~compare:(fun (_, p1) (_, p2) -> Int.compare p1 p2)
|> Option.map ~f:fst
``````

This will return `None` in case all inputs lists are empty, but raise an exception in case they aren't of equal length. That's easy to fix though, as Core defines an appropriate result type for pattern matching against:

``````let highestSales products amounts prices =
List.map3 products amounts prices (fun prod a p -> (prod, a * p))
|> function
| List.Or_unequal_lengths.Ok l ->
List.max_elt l ~compare:(fun (_, p1) (_, p2) -> Int.compare p1 p2)
|> Option.map ~f:fst
| Unequal_lengths ->
None
`````` Andrei McMillan

python

``````def most_sales(product_list, amount_list, price_list):
if len(product_list) == len(amount_list) == len(price_list):

revenue_list = []
top_revenue = []

for i, n in enumerate(product_list):
revenue_list.append(amount_list[i] * price_list[i])

max_val = max(revenue_list)

for index, value in enumerate(revenue_list):
if value == max_val:
top_revenue.append(str(product_list[index]) + ' - ' + '\${:,.2f}'.format(value))

print '\n'.join(top_revenue)
print '\n' + ('-' * 20) + '\n'
else:
print('invalid entries')

most_sales(
["Computer", "Cell Phones", "Vacuum Cleaner"],
[3, 24, 8],
[199, 299, 399]
)
# Cell Phones - \$7,176.00

most_sales(
["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"],
[0, 12, 24, 17, 19, 23, 120, 8],
[9, 24, 29, 31, 51, 8, 120, 14]
)
# Lego - \$14,400.00

most_sales(
["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"],
[120, 12, 24, 17, 19, 23, 120, 8],
[120, 24, 29, 31, 51, 8, 120, 14]
)
# Cell Phones - \$14,400.00
# Lego - \$14,400.00

`````` Vidit Sarkar

Here is C++ solution

``````vector<string> highestRevenue(vector<string> products, vector<int> amounts, vector<int> prices){
for(int i=0; i<amounts.size();i++){
revenue.push_back(amounts[i]*prices[i]);
}

int max_revenue = *max_element(revenue.begin(),revenue.end()); // maximum revenue
if(max_revenue == 0)
return vector<string>(); // if maximum revenue is zero then there is no need to return any product

vector<string> highestRevProducts; // vector storing the products with maximum revenue
for(int i=0;i<revenue.size();i++)
if(revenue[i] == max_revenue)
highestRevProducts.push_back(products[i]);

return highestRevProducts;
}
`````` ``````maximumsBy :: Ord b => (a -> b) -> [a] -> [a]
maximumsBy f = foldr g []
where g x [] = [x]
g x ys = case f x `compare` f (head ys) of
LT -> ys
EQ -> x : ys
GT -> [x]

bestSeller :: (Ord b, Num b) => [a] -> [b] -> [b] -> [a]
bestSeller ns qs ps = map fst \$ maximumsBy snd \$
zip ns \$ zipWith (*) qs ps
`````` divyansh-pratap • Edited on

# include

int main()
{
int i , a , j , revenue;
char A;
int B;
int C;
printf("enter the number of inputs you want to enter :");
scanf("%d" , &a);
printf("enter the name of the items :-\n");
for(i=-1;i<a;i++)
{

``````    gets(A[i]);

}

for(i=0;i<a;i++)
{
printf("enter the price of %dth element :\n",i+1);
scanf("%d" , &B[i]);
}
for(i=0;i<a;i++)
{
printf("\nenter the quantity of %dth element :\n" , i+1);
scanf("%d" , &C[i]);
}
revenue=C*B;
j=0;

for(i=0;i<a;i++)
``````

{
if(i>0)
{
if(C[i]*B[i]>C[i-1]*B[i-1])
{
revenue=C[i]*B[i];
j=i;
}
}

}

``````printf("%s" , A[j]);
``````

}