From the documentation:

Sscanf scans the argument string, storing successive space-separated values into successive arguments as determined by the format

It looks like you're doing Advent of Code though, and several of the "keys" have multiple words. I would suggest simply using strings.Split as in the following:

text := "Departure time: 10-20 or 22-23"
parts := strings.Split(text, ":")
key := parts[0]
var a, b, c, d int
fmt.Sscanf(parts[1], "%d-%d or %d-%d", &a, &b, &c, &d)
fmt.Println(key)
fmt.Println(a, b, c, d)

fmt.Sscanf documentation says: Sscanf scans the argument string, storing successive space-separated values into successive arguments as determined by the format

| character is not space and each format placeholder is independent of any other, so %s| does not mean match any string up to a first | but instead match any string not including space, and then a |.

You can process file line by line, split each line e.g using strings.Split() by | and then parse values into variables as you need:

row := "20220105|AACG|1805439|32577|3484265|B,Q,N"
tokens := strings.Split(row, "|")
if len(tokens) != 6 {
    log.Fatal("Bad line in file...")
}

// Do appropriate conversions...
date, err := strconv.Atoi(tokens[0])
if err != nil {
    log.Fatal("first token is not an integer")
}
symbol := tokens[1]
// ...

fmt.Println(date, symbol)

or as Volker pointed out in his comment you can use package encoding/csv and set its Reader Comma (separator) option to |:

f := `20220105|AA|1051302|4323|3132468|B,Q,N
20220105|AAA|61|0|62|Q`

r := csv.NewReader(strings.NewReader(f))
r.Comma = '|'
data, err := r.ReadAll()
if err != nil {
    log.Fatal(err)
}

// Process data, do appropriate conversions

fmt.Print(data)

%s is greedy and gobbles up to the next space, which means it eats up the colon. After processing the %s, it then tries to scan in the colon, but wait, that’s already been consumed, and the next character is actually a space, not a colon! So it fails.

In C you’d get around this by using %[^:] rather than %s, but it appears Go doesn’t support this. You might need to find some way to parse your string without Sscanf.

Your updated code was much easier to compile without the line numbers, but it was missing the package and import statements.

Looking at your code, I noticed a few things. Here's my revised version of your code.

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strconv"
    "strings"
    "container/vector"
)

func main() {
    n := scanf(os.Stdin)
    fmt.Println()
    fmt.Println(len(n), n)
}

func scanf(in io.Reader) []int {
    var nums vector.IntVector
    rd := bufio.NewReader(os.Stdin)
    str, err := rd.ReadString('\n')
    for err != os.EOF {
        fields := strings.Fields(str)
        for _, f := range fields {
            if i, err := strconv.Atoi(f); err == nil {
                nums.Push(i)
            }
        }
        str, err = rd.ReadString('\n')
    }
    return nums
}

I might want to use any input file for scanf(), not just Stdin; scanf() takes an io.Reader as a parameter.

You wrote: nums := new(vector.IntVector), where type IntVector []int. This allocates an integer slice reference named nums and initializes it to zero, then the new() function allocates an integer slice reference and initializes it to zero, and then assigns it to nums. I wrote: var nums vector.IntVector, which avoids the redundancy by simply allocating an integer slice reference named nums and initializing it to zero.

You didn't check the err value for strconv.Atoi(), which meant invalid input was converted to a zero value; I skip it.

To copy from the vector to a new slice and return the slice, you wrote:

r := make([]int, nums.Len())
for i := 0; i < nums.Len(); i++ {
    r[i] = nums.At(i)
}
return r

First, I simply replaced that with an equivalent, the IntVector.Data() method: return nums.Data(). Then, I took advantage of the fact that type IntVector []int and avoided the allocation and copy by replacing that by: return nums.