Count the reviews!

Question

Introduction and Credit

Imagine you're Amazon. Imagine you have a large number of products for which a lot of people have written reviews scoring 1-5 stars. Now you need to give your customers a summary for each product based on the simple product-scoring association. Because you're Amazon, time is money and as such you need to fit this into the smallest code possible because that's the code you can write the fastest.
Credit: This task appeared in 2014 in a programming mid-term exam in the functional programming course at my university and since then an example solution has been provided. I have the lecturer's and author's (same person) permission to post this question publicly.

---

Input

Your input will be a list of pairs of natural numbers, where the second value of each pair is always either 1, 2, 3, 4 or 5. Take the input using your preferred, generally accepted way.

Output

Your output will be a list of pairs of a number and a list of 5 numbers. Give the output using your preferred, generally accepted way.

What to do?

Given the (unsorted) list of product-id and scoring pairs, count for each product how often each score appears and return the amounts in the second list of the output pair at the appropriate position.
So for product #5 with 10x 1-star, 15x 2-star, 25x 3-star, 50x 4-star and 150x 5-star would result in the entry [5 [10 15 25 50 150]].

Potential Corner Cases

The input list may be empty in which case your output should be as well.
You don't need to consider the case where the input violates the above constraints.
You can safely assume all numbers to be representable by a signed 32-bit integer.
If you have no review(s) for a product (ie it doesn't appear in the output) it must not appear in the output either, i.e. 5x zeroes doesn't happen and can always be dropped.

Who wins?

This is code-golf so the shortest answer in bytes wins. Built-ins are allowed and standard rules apply.

---

Examples

Example input:

[(1,4),(2,5),(1,5),(1,1),(1,5),(1,4)]

Example corresponding output:

[
(1,[1, 0, 0, 2, 2]),
(2,[0, 0, 0, 0, 1])
]

Other test vectors:

[] -> []
[(1,1),(2,2),(3,3),(4,4),(5,5)] ->
[(1, [1,0,0,0,0]),(2, [0,1,0,0,0]),(3, [0,0,1,0,0]),(4, [0,0,0,1,0]),(5, [0,0,0,0,1])]

Answer 1

MATL, 8 bytes

5B#uilZ?

Input format is a column array of products followed by a column array of scores:

[1; 2; 1; 1; 1; 1]
[4; 5; 5; 1; 5; 4]

Output format is a vertical array of products followed by a matrix of score occurrences:

1
2
1 0 0 2 2
0 0 0 0 1

Try it online!

Explanation

5B#u   % Implicitly input array of products. Push unique values and integer labels
       % of the input entries. So input [1; 3; 1; 1; 1] would give outputs [1; 3]
       % and [1; 2; 1; 1; 1]. The latter is lik the input but without "holes", i.e.
       % uses consecutive integers. This is required to avoid rows of zeros in the
       % result for non-existing intermediate products
i      % Input array of scores
l      % Push 1
Z?     % Build sparse matrix with those row indices, column indices, and value 1.
       % Implicitly display

Answer 2

R, 64 bytes

function(m)`if`(length(m)>1,by(m[,2],m[,1],tabulate,n=5),list())

This solution works if the I/O is somewhat flexible. It's an unnamed function that works by taking an R-matrix as input and tabulates the frequency of each type of review. The only problem is dealing with the empty list. We need to introduce a control whether this is actually the case and because an empty matrix matrix() is not actually empty, we return an empty list() instead.

Try it on R-fiddle

Example output for the last test case:

m[, 1]: 1
[1] 1 0 0 0 0
--------------------------------------------------------------------------------------------- 
m[, 1]: 2
[1] 0 1 0 0 0
--------------------------------------------------------------------------------------------- 
m[, 1]: 3
[1] 0 0 1 0 0
--------------------------------------------------------------------------------------------- 
m[, 1]: 4
[1] 0 0 0 1 0
--------------------------------------------------------------------------------------------- 
m[, 1]: 5
[1] 0 0 0 0 1

Answer 3

Python 2 - 88 72 71 69 67 bytes

def s(l,d={}):
 for p,s in l:d.setdefault(p,[0]*5)[s-1]+=1
 print d

Input to the function:
[(1,4),(2,5),(1,5),(1,1),(1,5),(1,4)]

Output:
{1: [1, 0, 0, 2, 2], 2: [0, 0, 0, 0, 1]}

Edits:

• Thanks to nedla2004 for saving 16 bytes!
• Changed to Python 2 to save 1 byte :D
• Saved 3 bytes by taking newline byte count as 1 byte.
• Thanks flp-tkc for saving 2 bytes. (There was an unnecessary extra space too :D)

Golfing suggestions are welcome :)

Answer 4

Mathematica, 68 bytes

{#[[1,1]],Last/@Tally@Join[Range@5,#2&@@@#]-1}&/@GatherBy[#,#&@@#&]&

Unnamed function taking as input a list of ordered pairs of integers such as {{1, 4}, {2, 5}, {1, 5}, {1, 1}, {1, 5}, {1, 4}}. To start, GatherBy[#,#&@@#&] groups together all the pairs with the same first element (which can be any identifier, actually, not just an integer).

Each of those groups is then operated on by the function {#[[1,1]],Last/@Tally@Join[Range@5,#2&@@@#]-1}, which produces a two-element list as output, the first element of which is just the common identifier. Join[Range@5,#2&@@@#] generates a list of integers starting with 1,2,3,4,5 and ending with all of the scores corresponding to the given identifier. Last/@Tally then computes how many time each score was found, returning the appropriate 5-tuple; then -1 makes up for the fact that we introduced each score one extra time, leaving zeros for any missing score (which otherwise would be skipped completely).

Answer 5

Jelly, 18 17 bytes

Fm2QṢµ5,@þċ@€€³ż@

TryItOnline!

How?

Fm2QṢµ5,@þċ@€€³ż@ - Main link: List of (id, score) pairs
F                 - flatten
 m2               - mod 2 of list (gets the IDs)
   Q              - unique items by first appearance (one of each ID)
    Ṣ             - sorted (IDs in order)
     µ            - monadic chain separation (call the above z)
         þ        - table the result of
       ,@         -    pair z (with reversed @rguments) with
      5           -    5 (implicit range, so [1,2,3,4,5]) ...we now have:
                  -        [[id,1],[id,2],[id,3],[id,4],[id,5]] for every id, in order.
          ċ@€€    - count occurrences of (with reversed @rguments) for €ach for €ach in
              ³   - the first input (the list of (id, score) pairs)
               ż@ - zip (with reversed @rguments) with z

Answer 6

JavaScript (ES6), 58 bytes

Returns an object whose keys are the product IDs, associated to a list of review scores.

a=>a.map(([i,n])=>(o[i]=o[i]||[0,0,0,0,0])[n-1]++,o={})&&o

Test cases

let f =

a=>a.map(([i,n])=>(o[i]=o[i]||[0,0,0,0,0])[n-1]++,o={})&&o

console.log(JSON.stringify(f([])));
console.log(JSON.stringify(f([[1,4],[2,5],[1,5],[1,1],[1,5],[1,4]])));
console.log(JSON.stringify(f([[1,1],[2,2],[3,3],[4,4],[5,5]])));

Answer 7

Clojure, 79 bytes

(fn[c](reduce(fn[r[i v]](update r i #(update(or %[0 0 0 0 0])(dec v)inc))){}c))

Must called with a sequence of vectors so that item id and ratinv value are correctly mapped to function arguments. Returns a hash-map of vectors.

(def f (fn[c]( ... )))
(f [[1 4] [2 5] [1 5] [1 1] [1 5] [1 4]])
{1 [1 0 0 2 2], 2 [0 0 0 0 1]}