Лучший способ нарезать отсортированный ломтик

Question

Я хочу вырезать массив целых чисел перед указанным значением и вернуть массив, содержащий эти значения и оставшиеся значения в массиве. Мы можем предположить, что массив отсортирован. Это то, что я до сих пор:

func cutIntArrBefore(arr1 []int, n int) ([]int, []int) {
    arr2 := make([]int, 0, len(arr1))
    sliceIndex := 0


    for i, num := range arr1 {
        if num < n {
            arr2 = append(arr2, num)
            sliceIndex = i
        }
    }

    sliceIndex = sliceIndex + 1
    if sliceIndex >= len(arr1) {
        return arr2, nil
    } else {
        arr1 := arr1[sliceIndex:]   
        return arr2, arr1
    }
}

тестовый код:

func main() {
    var arr1, arr2, arr3 []int
    arr1 = []int{1,2,3,4,5,6,7,8}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{1,5}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{1}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{5}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{5,6}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{5,5}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)

    arr1 = []int{7,7,7}
    arr2, arr3 = cutIntArrBefore(arr1, 5)
    fmt.Printf("(%+v) = %+v, %+v\n", arr1, arr2, arr3)
}

вывод:

([1 2 3 4 5 6 7 8]) = [1 2 3 4], [5 6 7 8]
([1 5]) = [1], [5]
([1]) = [1], []
([5]) = [], []
([5 6]) = [], [6]
([5 5]) = [], [5]
([7 7 7]) = [], [7 7]

К сожалению, как вы можете видеть, если первый элемент находится после указанного значения, он пропускается. Я хочу сделать это максимально элегантно. Я надеюсь, что есть другой способ без необходимости создания двух массивов или добавления другого оператора if.

Answer 1

Ваша реализация содержит ошибку, которая может быть легко устранена путем использования индекса крайнего левого целевого значения в качестве точки поворота с использованием выражений срезов arr[:i] и arr[i:].

Также рассмотрите возможность использования sort.SearchInts(...), чтобы найти целевой индекс за O(lg(n)) время вместо O(n). Использование встроенной функции также, вероятно, улучшит удобочитаемость и удобство сопровождения кода.

Например ( Go Playground ):

func cutBefore(xs []int, x int) ([]int, []int) {
  i := sort.SearchInts(xs, x)
  return xs[:i], xs[i:]
}

func main() {
  xss := [][]int{
    {1, 2, 3, 4, 5, 6, 7, 8},
    {1, 5},
    {1},
    {5},
    {5, 6},
    {5, 5},
    {7, 7, 7},
  }
  for _, xs := range xss {
    fmt.Println(cutBefore(xs, 5))
  }
  // [1 2 3 4] [5 6 7 8]
  // [1] [5]
  // [1] []
  // [] [5]
  // [] [5 6]
  // [] [5 5]
  // [] [7 7 7]
}