Triangle Sum through down with NON-PRIME numbers with Swift 4 - swift

Question

I know this question is asked before for different programming languages, and I tried to implement this with Swift 4 but once I submit my answer, I've been told that my answer was wrong so here is the task;
You will have a TRIANGLE input from a file and you need to find the maximum sum of the numbers according to given rules below;
You will start from the top and move downwards to an adjacent number as in below.
You are only allowed to walk downwards and diagonally.
You can only walk over NON PRIME NUMBERS.
According to above rules the maximum sum of the numbers from top to bottom in below example is 24.
var sampleString = """
1
8 4
2 6 9
8 5 9 3
As you can see this has several paths that fits the rule of NOT PRIME NUMBERS; 1>8>6>9, 1>4>6>9, 1>4>9>9
1 + 8 + 6 + 9 = 24. As you see 1, 8, 6, 9 are all NOT PRIME NUMBERS and walking over these yields the maximum sum.
assignment string:
var assignmentString = """
215
193 124
117 237 442
218 935 347 235
320 804 522 417 345
229 601 723 835 133 124
248 202 277 433 207 263 257
359 464 504 528 516 716 871 182
461 441 426 656 863 560 380 171 923
381 348 573 533 447 632 387 176 975 449
223 711 445 645 245 543 931 532 937 541 444
330 131 333 928 377 733 017 778 839 168 197 197
131 171 522 137 217 224 291 413 528 520 227 229 928
223 626 034 683 839 53 627 310 713 999 629 817 410 121
924 622 911 233 325 139 721 218 253 223 107 233 230 124 233"""
my code:
func maxSumForTriangle(triangleString: String) {
var temporaryIndex = 0
var earlierIndex = 0
var greatSum = 0
var temporaryMaxInLine = 0
let values = triangleString.components(separatedBy: .newlines).map {
$0.components(separatedBy: .whitespaces).compactMap(Int.init)
}
print(values)
print(values.count)
for line in values {
if line.count == 1 {
greatSum += line[0]
earlierIndex = line.count - 1
} else {
for number in line.enumerated() {
if number.offset == earlierIndex || number.offset == earlierIndex + 1 {
//Check the number if its prime or not with the isPrime function we defined
if !isPrime(number.element) {
if number.element > temporaryMaxInLine {
temporaryMaxInLine = number.element
temporaryIndex = number.offset
}
}
}
}
earlierIndex = temporaryIndex
greatSum += temporaryMaxInLine
temporaryMaxInLine = 0
}
}
print(greatSum)
}
Which results in 7619 but then I realized where my problem is; I don't check for every possible path, I just check for the highest non prime number at each line and continue summing with it.
So I need to find a different approach for this problem so that my function can check every possible scenarios and return with the highest sum
I could not figure it out yet, should I implement a different function where it calls itself again so that it can check for all the possible paths?
Sorry for long question but I also wanted to show my old implementation.

Answer 1

This is a typical problem which can be solved with “dynamic programming”: The idea
is to compute the maximal possible sum for every starting
point in the pyramid.
And that becomes simple if we start at the bottom row and work upwards:
We only have to add to each entry the larger of its two lower neighbors.
At the end, the top entry is the desired maximal sum.
Taking the additional condition about non-primes into account, this
can be implemented as
var values = triangleString.components(separatedBy: .newlines).map {
$0.components(separatedBy: .whitespaces).compactMap(Int.init)
}
for row in values.indices.reversed() {
for col in values[row].indices {
if isPrime(values[row][col]) {
values[row][col] = Int.min
} else if row + 1 < values.endIndex {
values[row][col] += max(values[row+1][col], values[row+1][col+1])
}
}
}
print(values[0][0])