Implementation of merge sort and bubble sort
I don't see any major problems but there are a number of (really very minor) little nits.

First, the trend seems to be for people to like very few blank lines.  I think this trend is driven by the prevalence of syntax highlighting.  I recently I had the occasion to program on a machine without syntax highlighting and found that I wanted more blank lines again for readability.  Anecdotes aside though, try using fewer blank lines and see if you like it after you get used to it.

In your first if statement, you could use the "simple statement" form

if _, err := fmt.Scanf("%d", &amp;n); err != nil {
    fmt.Println("Error:", err)
    return
}


Most Go programmers like that this form more clearly associates the if statement with the code that is being tested and that the scope of err here is limited to the if body.  It also saves a line of screen real estate.

Consider replacing sequences of if statements with a single switch statement.

switch _, err := fmt.Scanf("%d", &amp;n); {
case err != nil:
    fmt.Println("Error:", err)
    return
case n &gt; 1000:
    fmt.Println("Error:", n, "&gt; 1000 - too long!")
    return
case n &lt; 1:
    fmt.Println("Error:", n, "&lt; 1")
    return
}


The usual arguments for preferring switch over a chain of ifs are that the logic is easier to follow and the code is more readable.  As with the simple statement form of if, this form also restricts variable scope and tends to need few lines on the screen.

array := make([]int, n) presents some issues.

The word "array" has a general meaning in computing, but has a specific meaning in Go.  Some Go programmers are bothered when Go slices are incorrectly called arrays.  It's disturbing in the way something like var integer float64 would be.  You might still argue that array is appropriate here because it identifies the conceptual thing you have obtained from the user and retains the language of the user interface.  Or in the interest of code readability, you might consider other names, or consider different terminology in the user interface.

In BubbleSort, you can replace

array := make([]int, len(inputArray))
copy(array, inputArray)


with

array := append([]int{}, inputArray...)


if you like.  The first form is easy to understand and is arguably more readable.  The second form is a little tricky but is listed on Slice Tricks on the Go Wiki and I think is pretty common.

It looks like your for loops in BubbleSort could use the range clause form.

And then you have some if statements with unnecessary parentheses.  Otherwise looks great.