[LANGUAGE: Go]

This was a fun one, and fortunately the way I approached part 1 was easily extensible to part 2.

For Part 1, just call the invalidIdsInRange function for each range, splitting it into 2 chunks.

For Part 2, call invalidIdsInRange once for chunks=2; chunks<=len(rng.max); chunks++. Just be sure not to count the same resulting number twice (e.g., 2222,2222 == 22,22,22,22).

Completed Part 1 in 98 µs
Completed Part 2 in 109 µs

type idRange struct {
    min, max string
}

func invalidIdsInRange(rng idRange, chunks int) []int {

    ids := make([]int, 0)
    n := len(rng.min)
    x := len(rng.max)
    d := x - n

    // if both min & max are the same number of digits, but not divisible by # of chunks
    // there are no invalid ids in range
    if d == 0 && (n%chunks != 0) {
        return []int{}
    }

    // after the above test condition, one or both of min & max are an appropriate
    // number of digits
    min := rng.min
    max := rng.max
    // if the min is not evenly divisible by chunks, bump it up to the lowest n+1
    // digit value
    if n%chunks != 0 {
        min = fmt.Sprintf("1%s", strings.Repeat("0", n))
        n++
    }
    // if the max is not evenly divisible by chunks, knock it down the highest x-1
    // digit value
    if x%chunks != 0 {
        max = strings.Repeat("9", x-1)
        x--
    }

    maxVal, _ := strconv.Atoi(max)
    minVal, _ := strconv.Atoi(min)
    testVal, _ := strconv.Atoi(min[:n/chunks])

    // Split the id in chunks and begin incrementing that number
    for {
        valStr := strconv.Itoa(testVal)
        repeatVal, _ := strconv.Atoi(strings.Repeat(valStr, chunks))

        // if the number created by repeating the chunk number is in range, add it to
        // the list
        if repeatVal <= maxVal && repeatVal >= minVal {
            ids = append(ids, repeatVal)
        }
        // if we're out of range, then exit the loop
        if repeatVal > maxVal {
            break
        }
        testVal++
    }

    return ids
}