Scala algorithm: Find the contiguous slice with the minimum average

Published , last updated

Algorithm goal

In an array, find the contiguous slice that has the minimum average.

For example, \([3, 1, 9, 1, 2]\) has slices:

  1. \([3, 1]\), average \(2\).
  2. \([3, 1, 9]\), average \(4.33\).
  3. \([3, 1, 9, 1]\), average \(3.5\).
  4. \([3, 1, 9, 1, 2]\), average \(3.2\).
  5. \([1, 9]\), average \(5\).
  6. \([1, 9, 1]\), average \(3.67\).
  7. \([1, 9, 1, 2]\), average \(3.25\).
  8. \([9, 1]\), average \(5\).
  9. \([9, 1, 2]\), average \(4\).
  10. \([1, 2]\), average \(1.5\).

The slice with the minimum average is \([1, 2]\) because it has minimum average of \(1.5\).

This is similar to Codility's MinAvgTwoSlice problem.

Test cases in Scala

assert(findMinAvgSlice() == None)
assert(findMinAvgSlice(1) == None)
assert(findMinAvgSlice(1, 2) == Some(SubSlice(startIndex = 0, List(1, 2))))
assert(
  findMinAvgSlice(3, 1, 2) == Some(SubSlice(startIndex = 1, List(1, 2)))
)
assert(
  findMinAvgSlice(3, 1, 1, 2) == Some(SubSlice(startIndex = 1, List(1, 1)))
)
assert(
  findMinAvgSlice(3, 1, 2, 1, 2) ==
    Some(SubSlice(startIndex = 1, List(1, 2, 1)))
)
assert(
  findMinAvgSlice(3, 1, 9, 1, 2) ==
    Some(SubSlice(startIndex = 3, List(1, 2)))
)
assert(
  findMinAvgSlice(Int.MaxValue, Int.MaxValue, 1, 2) ==
    Some(SubSlice(startIndex = 2, List(1, 2)))
)
assert(
  findMinAvgSlice(3, 4, Int.MinValue, Int.MinValue, 1, 2) ==
    Some(SubSlice(startIndex = 2, List(Int.MinValue, Int.MinValue)))
)

Algorithm in Scala

29 lines of Scala (version 2.13), showing how concise Scala can be!

Get the full algorithm Scala algorithms logo, maze part, which looks quirky!

or

'Unlimited Scala Algorithms' gives you access to all the Scala Algorithms!

Upon purchase, you will be able to Register an account to access all the algorithms on multiple devices.

Stripe logo

Explanation

We could find the solution using a brute-force search which would be computationally expensive because it means for every starting element, we have to consider nearly N other elements, so our complexity would be at least \(O(n^2)\).

However, this (and similar problems like MaximumProfitStockPrices), are often mathematical in nature, and it is wise to have some mathematics in your toolbox to find a more optimal algorithm, which you will find here: (this is © from www.scala-algorithms.com)

Mathematics

Suppose \(V(p, l)\) is the average of \(l\) numbers starting at position \(p\). For example, \(V(3, 2)\) is \((A_3 + A_4) \div 2\), where \(A_i\) is the \(i\)th element of the input array.

Consider that a slice is of minimum length 2. If the next number decreases our average, then we get a slice of length \(3\).

However, if we extend it by 2, and it decreases our average, we get the following equation:

\(V(p, 4) < V(p, 2) \implies 2 (A_p + A_{p+1} + A_{p+2} + A_{p+3}) < 4(A_p + A_{p+1})\).

\(\implies 2(A_{p+2} + A_{p+3}) < 2(A_p + A_{p+1})\), which would mean that we have just found a new and smaller slice of size 2.

Full explanation is available for subscribers Scala algorithms logo, maze part, which looks quirky

Scala concepts & Hints

  1. Collect

    'collect' allows you to use Pattern Matching, to filter and map items.

    assert("Hello World".collect {
      case character if Character.isUpperCase(character) => character.toLower
    } == "hw")
    
  2. Drop, Take, dropRight, takeRight

    Scala's `drop` and `take` methods typically remove or select `n` items from a collection.

    assert(List(1, 2, 3).drop(2) == List(3))
    
    assert(List(1, 2, 3).take(2) == List(1, 2))
    
    assert(List(1, 2, 3).dropRight(2) == List(1))
    
    assert(List(1, 2, 3).takeRight(2) == List(2, 3))
    
    assert((1 to 5).take(2) == (1 to 2))
    
  3. Option Type

    The 'Option' type is used to describe a computation that either has a result or does not. In Scala, you can 'chain' Option processing, combine with lists and other data structures. For example, you can also turn a pattern-match into a function that return an Option, and vice-versa!

    assert(Option(1).flatMap(x => Option(x + 2)) == Option(3))
    
    assert(Option(1).flatMap(x => None) == None)
    
  4. Pattern Matching

    Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.

    assert("Hello World".collect {
      case character if Character.isUpperCase(character) => character.toLower
    } == "hw")
    
  5. Sliding / Sliding Window

    Get fixed-length sliding sub-sequences (sliding windows) from another sequence

  6. View

    The .view syntax creates a structure that mirrors another structure, until "forced" by an eager operation like .toList, .foreach, .forall, .count.

View the rest of Scala algorithms