Fixed Scala code using Partition Numbers with Stream calculate, BUT too slowly

问题

I want to talk about how to which proceed.
1. Incorrect usage of Scala. I should try to more improve the code.
2. The efficiency of the algorithm is poor. I should think of an efficient algorithm.

Goal: Can quickly calculate the max number from more than 1,000 Partition Numbers collections.

Partition Number:
e.g.,

5 -> (5), (1, 4), (2, 3), (1, 1, 3), (1, 2, 2), (1, 1, 1, 2), (1, 1, 1, 1, 1)

I ask that "I want to convert from Python to Scala that Partition Function using Vector", and I was taught to use Stream yesterday.
I fixed code, I can use 10, 50, and so on. But using big numbers(e. g., 100, 1,000 or 10,000) weren't calculate max number.
It calculate from Stream.last to Stream.head.

In my understanding that Stream type can add an element at the head only, so the order of the numbers is reversed form the fist code.

code

import scala.math.floor

class PartitionNumbers(startNum: Int, point: Int) {
  var maxNum = 0
  var tmpNum = 0

  private def appendOnes(n: Int, s: Stream[Int] = Stream.empty[Int]): Stream[Int] = {
    if (n == 0) s
    else appendOnes(n - 1, 1 #:: s)
  }

  private def partition(n: Int, k: Int, tmpStream: Stream[Int] = Stream.empty): Int = {
    if (n == 0) tmpNum = calculate(tmpStream)
    else if (n == 1 | k == 1) tmpNum = calculate(appendOnes(n))
    else {
      if (n >= k) partition(n - k, k, k #:: tmpStream)
      partition(n, k - 1, tmpStream)
    }
    if (maxNum < tmpNum) maxNum = tmpNum
    maxNum
  }

  def searchMax(n: Int = point): Int = {
    partition(n, n)
  }

  def calculate(usePointsStream: Stream[Int], num: Int = startNum): Int = {
    if (usePointsStream.isEmpty) {
      num
    } else {
      calculate(usePointsStream.init, floor(num * (100 + usePointsStream.last) / 100).toInt)
    }
  }

}

output example

val pn_1 = new PartitionNumbers(100, 10)
println(pn_1.searchMax())  // -> 110

val pn_2 = new PartitionNumbers(1000, 50)
println(pn_2.searchMax())  // -> 1630

val pn_3 = new PartitionNumbers(10000, 100)
println(pn_3.searchMax())  // Can't calculate within 3 minutes using Ryzen 7 2700X.

来源：https://stackoverflow.com/questions/58139520/fixed-scala-code-using-partition-numbers-with-stream-calculate-but-too-slowly

标签

algorithm

scala

recursion

max