Functional match-maker algorithm in scala - scala

Question

Suppose, in scala, I have a collection of Person objects where each person has an identifier and quantity value:
case class Person(identifier: String, quantity : Int)
A positive quantity represents supply and a negative quantity represents demand. Similarly, a transfer can be represented as:
case class Transfer(quantity : Int, supplier : String, consumer : String)
What is a "functional" algorithm that can maximize the transfers from suppliers to consumers by matching as much supply as possible with demand?
The signature would look something like
def matchMaker(people : Iterable[Person]) : Iterable[Transfer] = ???
Note: the collection type Iterable is not strictly necessary for either the input or output. A Set, List, etc. will suffice.
Example:
If our population is:
val people = Iterable(Person("Alice", 10),
Person("Charlie", -5),
Person("Bob", 4))
The matchmaker algorithm would create an Iterable that could be:
Iterable(Transfer(5, "Alice", "Charlie"))
Or, another possible solution could be
Iterable(Transfer(4, "Bob", "Charlie"),
Transfer(1, "Alice", "Charlie"))
A bad solution would be where only some of the possible transfer was identified:
Iterable(Transfer(4, "Bob", "Charlie")) //Charlie still has demand left
Thank you in advance for your review.

Answer 1

It's not pretty, and has much room for improvement in the details. But it should at least transport the idea of the algorithm and showcase some awesome scala language features like implicits, Ordering trait, tailrecursion, ...
implicit val peopleOrdering: Ordering[Person] = Ordering.by(_.quantity)
def matchMaker(people : Iterable[Person]) : Iterable[Transfer] = {
#tailrec
def matchMaker(sortedPeople : Vector[Person], transfers: List[Transfer]) : Iterable[Transfer] = {
// just to make a point, because I am expecting the incoming vector to be sorted
// If you are confident about your code you probably don't need the require
// However, imo, it is always a good idea to double check
// and require is 'elidable' so won't clutter your program compiled for production
require(in.sorted == in, "Passed person Vector MUST be sorted.")
if (sortedPeople.forall(_.quantity >= 0) || sortedPeople.forall(_.quantity <= 0)) {
// nothing more that can be done
transfers
} else {
val sender = sortedPeople.last
val receiver = sortedPeople.head
val transferQuantity = if (receiver.quantity + sender.quantity >= 0) {
-receiver.quantity
} else {
sender.quantity
}
val transfer = Transfer(transferQuantity, sender.identifier, receiver.identifier)
val nextPeople = sortedPeople.map {
case `sender` => sender.copy(quantity = sender.quantity - transfer.quantity)
case `receiver` => receiver.copy(quantity = receiver.quantity + transfer.quantity)
case other => other
}
matchMaker(nextPeople.sorted, transfer :: transfers)
}
}
matchMaker(people.toVector.sorted, Nil)
}
The algorithm will recursively transfer from the richest person to the person with the highest debt until no one is left with debt. Unless all persons are in debt or penniless from the beginning.

Answer 2

Split into those with supply and those wanting:
val (suppliers, demanders) = people.partition(_.quantity > 0)
Define a function to consume one supplier's quantity, returning an updated list of those wanting, and an updated list of transfers done
def consume(supplier: Person, demanders: Iterable[Person], transfers: List[Transfer]) = {
val (q, ds, ts) = demanders.foldLeft(
(supplier.quantity, Iterable[Person](), transfers))
{
case ((quantity, ds, ts), d) =>
val amount = Math.min(quantity, -d.quantity)
if (amount != 0) (quantity - amount,
ds ++ Iterable(d.copy(quantity = d.quantity + amount)),
Transfer(amount, supplier.identifier, d.identifier) :: ts)
else
(quantity, ds ++ Iterable(d), ts)
}
(ds, ts)
}
Go over the suppliers, consuming each, and passing along the updated demanders and current list of transfers
val (_, transfers) = suppliers.foldLeft((demanders, List[Transfer]()))
{ case ((ds, ts), s) => consume(s, ds, ts) }
transfers
// List(Transfer(5,Alice,Charlie))
An optimisation: drop a demander in consume if their demand is now satisfied. That way it won't be considered for later suppliers.
def consume(supplier: Person, demanders: Iterable[Person], transfers: List[Transfer]) = {
val (q, ds, ts) = demanders.foldLeft((supplier.quantity, Iterable[Person](), transfers))
{
case ((quantity, ds, ts), d) =>
val amount = Math.min(quantity, -d.quantity)
val remaining = d.quantity + amount
if (amount != 0) (quantity - amount,
if (remaining != 0) ds ++ Iterable(d.copy(quantity = remaining))
else ds,
Transfer(amount, supplier.identifier, d.identifier) :: ts)
else (quantity, ds ++ Iterable(d), ts)
}
(ds, ts)
}