Як видалити елемент із фрагмента в Golang

fmt.Println("Enter position to delete::")
fmt.Scanln(&pos)

new_arr := make([]int, (len(arr) - 1))
k := 0
for i := 0; i < (len(arr) - 1); {
    if i != pos {
        new_arr[i] = arr[k]
        k++
        i++
    } else {
        k++
    }
}

for i := 0; i < (len(arr) - 1); i++ {
    fmt.Println(new_arr[i])
}

Я використовую цю команду для видалення елемента з фрагмента, але він не працює, будь ласка, запропонуйте.

Порядок має значення

Якщо ви хочете зберегти свій масив упорядкованим, вам доведеться перенести всі елементи праворуч від індексу видалення на один вліво. Сподіваємось, це можна легко зробити в Golang:

func remove(slice []int, s int) []int {
    return append(slice[:s], slice[s+1:]...)
}

Однак це неефективно, оскільки ви можете в кінцевому підсумку перемістити всі елементи, що є дорогим.

Порядок не важливий

Якщо ви не дбаєте про замовлення, у вас є набагато швидша можливість поміняти елемент для видалення на той, що знаходиться в кінці фрагмента, а потім повернути перші елементи n-1:

func remove(s []int, i int) []int {
    s[len(s)-1], s[i] = s[i], s[len(s)-1]
    return s[:len(s)-1]
}

За допомогою методу розмноження спорожнення масиву з 1 000 000 елементів займає 224 с, а для цього - лише 0,06 нс. Я підозрюю, що внутрішньо go лише змінює довжину зрізу, не змінюючи його.

Редагувати 1

Короткі примітки на основі коментарів нижче (завдяки їм!).

Оскільки метою є видалення елемента, коли порядок не має значення, потрібен один обмін, другий буде витрачений даремно:

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    // We do not need to put s[i] at the end, as it will be discarded anyway
    return s[:len(s)-1]
}

Крім того, ця відповідь не виконує перевірку меж . В якості вхідних даних він очікує дійсний індекс. Це означає, що негативні значення або індекси, більші або рівні len (-ів), спричинять Go для паніки. Зрізи та масиви, які індексуються 0, видалення n-го елемента масиву означає надання вводу n-1 . Щоб видалити перший елемент, зателефонуйте видаленню (s, 0) , для видалення другого - виклику remove (s, 1) тощо, тощо.

Видаліть один елемент із фрагмента (це називається повторним нарізанням):

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(all) //[0 1 2 3 4 5 6 7 8 9]
    all = RemoveIndex(all, 5)
    fmt.Println(all) //[0 1 2 3 4 6 7 8 9]
}

Менша точка (код гольфу), але в тому випадку, коли порядок не має значення, вам не потрібно міняти місцями значення. Просто перезапишіть видалену позицію масиву дублікатом останньої позиції, а потім поверніть усічений масив.

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    return s[:len(s)-1]
}

Той самий результат.

Це трохи дивно бачити, але більшість відповідей тут небезпечні та затьмарюють те, що вони насправді роблять. Переглядаючи оригінальне запитання про видалення предмета зі зрізу, робиться копія зрізу, а потім він заповнюється. Це гарантує, що коли фрагменти передаються навколо вашої програми, ви не вводите тонких помилок.

Ось код, що порівнює відповіді користувачів у цій темі та оригінальний пост. Ось ігровий майданчик, щоб поспішати з цим кодом.

Додайте видалення на основі

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[999 1 2 3 4 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

У наведеному вище прикладі ви бачите, як я створюю зріз і заповнюю його вручну цифрами від 0 до 9. Потім ми видаляємо індекс 5 з усіх і призначаємо його для видалення індексу. Однак, коли ми збираємося роздруковувати все зараз, ми бачимо, що воно також було змінено. Це тому, що зрізи є вказівниками на базовий масив. Списання його на removeIndexпричини, які також allповинні бути модифіковані з різницею, allдовше на один елемент, до якого більше неможливо досягти removeIndex. Далі ми змінюємо значення в, removeIndexі ми бачимо, що воно також allзмінюється. Ефективна детальна деталізація цього питання.

У наступному прикладі я не буду розглядати, але він робить те саме для наших цілей. І лише ілюструє, що використання копії нічим не відрізняється.

package main

import (
    "fmt"
)

func RemoveCopy(slice []int, i int) []int {
    copy(slice[i:], slice[i+1:])
    return slice[:len(slice)-1]
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeCopy := RemoveCopy(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[0 1 2 3 4 6 7 8 9]

    removeCopy[0] = 999
    fmt.Println("all: ", all) //[99 1 2 3 4 6 7 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[999 1 2 3 4 6 7 8 9]
}

На запитання оригінальна відповідь

Дивлячись на оригінальне запитання, це не змінює фрагмент, з якого він вилучає елемент. Зробити оригінальну відповідь у цій темі найкращою на сьогодні для більшості людей, які переходять на цю сторінку.

package main

import (
    "fmt"
)

func OriginalRemoveIndex(arr []int, pos int) []int {
    new_arr := make([]int, (len(arr) - 1))
    k := 0
    for i := 0; i < (len(arr) - 1); {
        if i != pos {
            new_arr[i] = arr[k]
            k++
        } else {
            k++
        }
        i++
    }

    return new_arr
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    originalRemove := OriginalRemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[0 1 2 3 4 6 7 8 9]

    originalRemove[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[999 1 2 3 4 6 7 8 9]
}

Як бачите, цей результат діє так, як очікувало б більшість людей, і, ймовірно, те, чого хоче більшість людей. Модифікація originalRemoveне викликає змін, allа операція видалення індексу та його присвоєння також не спричиняє змін! Фантастично!

Цей код трохи довгий, хоча вищезазначене можна змінити на це.

Правильна відповідь

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    ret := make([]int, 0)
    ret = append(ret, s[:index]...)
    return append(ret, s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

Майже ідентичний оригінальному рішенню індексу видалення, однак ми робимо новий фрагмент, який слід додати до повернення.

Це, як ви Видалити З скибочки golang шлях . Вам не потрібно будувати функцію, яка вбудована в додаток. Спробуйте тут https://play.golang.org/p/QMXn9-6gU5P

z := []int{9, 8, 7, 6, 5, 3, 2, 1, 0}
fmt.Println(z)  //will print Answer [9 8 7 6 5 3 2 1 0]

z = append(z[:2], z[4:]...)
fmt.Println(z)   //will print Answer [9 8 5 3 2 1 0]

З книги Мова програмування Go

Щоб видалити елемент із середини зрізу, зберігаючи порядок решти елементів, використовуйте copy, щоб зсунути елементи з більшими номерами на один, щоб заповнити пробіл:

func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

Я використовую нижченаведений підхід, щоб видалити предмет у фрагменті. Це допомагає читати іншим. А також незмінний.

func remove(items []string, item string) []string {
    newitems := []string{}

    for _, i := range items {
        if i != item {
            newitems = append(newitems, i)
        }
    }

    return newitems
}

найкращий спосіб це зробити - використовувати функцію додавання:

package main

import (
    "fmt"
)

func main() {
    x := []int{4, 5, 6, 7, 88}
    fmt.Println(x)
    x = append(x[:2], x[4:]...)//deletes 6 and 7
    fmt.Println(x)
}

https://play.golang.org/p/-EEFCsqse4u

Можливо, ви можете спробувати цей метод:

// DelEleInSlice delete an element from slice by index
//  - arr: the reference of slice
//  - index: the index of element will be deleted
func DelEleInSlice(arr interface{}, index int) {
    vField := reflect.ValueOf(arr)
    value := vField.Elem()
    if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
        result := reflect.AppendSlice(value.Slice(0, index), value.Slice(index+1, value.Len()))
        value.Set(result)
    }
}

Використання:

arrInt := []int{0, 1, 2, 3, 4, 5}
arrStr := []string{"0", "1", "2", "3", "4", "5"}
DelEleInSlice(&arrInt, 3)
DelEleInSlice(&arrStr, 4)
fmt.Println(arrInt)
fmt.Println(arrStr)

Результат:

0, 1, 2, 4, 5
"0", "1", "2", "3", "5"

Можливо, цей код допоможе.

Він видаляє елемент із заданим індексом.

Бере масив та індекс для видалення та повертає новий масив, майже як функція додавання.

func deleteItem(arr []int, index int) []int{
  if index < 0 || index >= len(arr){
    return []int{-1}
  }

    for i := index; i < len(arr) -1; i++{
      arr[i] = arr[i + 1]

    }

    return arr[:len(arr)-1]
}

Тут ви можете пограти з кодом: https://play.golang.org/p/aX1Qj40uTVs

Знайдіть шлях сюди, не переїжджаючи.

• змінює порядок

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
a[i] = a[len(a)-1] // Copy last element to index i.
a[len(a)-1] = ""   // Erase last element (write zero value).
a = a[:len(a)-1]   // Truncate slice.

fmt.Println(a) // [A B E D]

• стежити за порядком

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
copy(a[i:], a[i+1:]) // Shift a[i+1:] left one index.
a[len(a)-1] = ""     // Erase last element (write zero value).
a = a[:len(a)-1]     // Truncate slice.

fmt.Println(a) // [A B D E]

Не потрібно перевіряти кожен окремий елемент, якщо ви не дбаєте про вміст і не можете використовувати додавання фрагмента. Спробуй

pos := 0
arr := []int{1, 2, 3, 4, 5, 6, 7, 9}
fmt.Println("input your position")
fmt.Scanln(&pos)
/* you need to check if negative input as well */
if (pos < len(arr)){
    arr = append(arr[:pos], arr[pos+1:]...)
} else {
    fmt.Println("position invalid")
}

ось приклад дитячого майданчика з покажчиками в ньому. https://play.golang.org/p/uNpTKeCt0sH

package main

import (
    "fmt"
)

type t struct {
    a int
    b string
}

func (tt *t) String() string{
    return fmt.Sprintf("[%d %s]", tt.a, tt.b)
}

func remove(slice []*t, i int) []*t {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

func main() {
    a := []*t{&t{1, "a"}, &t{2, "b"}, &t{3, "c"}, &t{4, "d"}, &t{5, "e"}, &t{6, "f"}}
    k := a[3]
    a = remove(a, 3)
    fmt.Printf("%v  ||  %v", a, k)
}