So bit of a weird one here. My question is, do people get the same results from running my code as I do? And if you do, is it a fault of my code (I'm a python programmer usually), or a bug in golang?

System info: Go version (1.1.2) linux x64 (fedora 19)

Background info on the code: What I'm doing is finding the highest cost route from the top of a triangle to the bottom, this is from project_euler 18 and 67

The bug: I set a variable called pathA, this is an integer list, plus a new int for the new value found from the triangle e.g. 3, 7, 2 append 8 should equal 3, 2, 7, 8 and, it does! ... until I set pathB. pathB gets set correctly however suddenly pathA is the same value as pathB.

tl;dr one variable is being overwritten when I set another

My code is as follows:

package main

import (
    "fmt"
)

func extendPaths(triangle, prePaths [][]int) [][]int {
    nextLine := triangle[len(prePaths)]
    fmt.Println("#####PrePaths: ", prePaths)
    fmt.Println("#####nextLine: ", nextLine)

    postPaths := [][]int{{}}
    for i := 0; i  getSum(postPaths[i+1]) {
            prePaths = append(prePaths, postPaths[i])
        } else {
            prePaths = append(prePaths, postPaths[i+1])
        }
    }
    prePaths = append(prePaths, postPaths[len(postPaths)-1])
    return prePaths
}

func getSum(sumList []int) int {
    total := 0
    for i := 0; i 

This gives the output in my terminal shown below:

#####PrePaths:  
#####nextLine:  [7 4]
Next A: 7 Next B: 4

pathA check#1: [3 7]
pathA check#2: [3 7]

#####PrePaths:  
#####nextLine:  [2 4 6]
Next A: 2 Next B: 4

pathA check#1: [3 7 2]
pathA check#2: [3 7 2]

Next A: 4 Next B: 6

pathA check#1: [3 4 4]
pathA check#2: [3 4 4]

#####PrePaths:  
#####nextLine:  [8 5 9 3]
Next A: 8 Next B: 5

pathA check#1: [3 7 2 8]
pathA check#2: [3 7 2 5]

Next A: 5 Next B: 9

pathA check#1: [3 7 4 5]
pathA check#2: [3 7 4 9]

Next A: 9 Next B: 3

pathA check#1: [3 4 6 9]
pathA check#2: [3 4 6 3]


Here you can see that for the last 4 times that I set pathA, it is initially set correctly, but then gets overwritten by pathB.

Does anyone have any thoughts on this?

EDIT:

As pointed out by the comments below, what was needed was to make new slices and copy data from the originals. This was done using code from http://blog.golang.org/go-slices-usage-and-internals modified slightly:

func AppendInt(slice []int, data ...int) []int {
    m := len(slice)
    n := m + len(data)
    if n > cap(slice) {
        newSlice := make([]int, (n+1)*2)
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0:n]
    copy(slice[m:n], data)
    return slice
}


I also changed the code on the other side, where I created the slices pathA and pathB. This changed to:

for i := 0; i 

EDIT2:

It's quite early in the morning here, and I flat out made a mistake in my first edit, I did not fully understand your solution, after a bit of hacking I got there in the end:

This code does not work (pathA gets overwritten):

for i := 0; i 

This code also does not work (pathA gets overwritten):

for i := 0; i 

However, if I mix the 2 scenarios above into the code below, it works fine (pathA does not get overwritten):

for i := 0; i 

So, my solution was to make a copy of the array, and have them both use different ones.