গোলংয়ের স্লাইস থেকে কীভাবে একটি উপাদান মুছবেন

Question 1

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])
}

আমি এই কমান্ডটি স্লাইস থেকে কোনও উপাদান মুছতে ব্যবহার করছি তবে এটি কার্যকর হচ্ছে না, দয়া করে পরামর্শ দিন।

Question 2

অর্ডার বিষয়গুলি

আপনি যদি আপনার অ্যারেটি অর্ডার রাখতে চান, আপনাকে মুছে ফেলার সূচকটির ডানদিকে সমস্ত উপাদানকে একটি করে বামে স্থানান্তর করতে হবে। আশা করি, গোলং এ এটি সহজেই করা যায়:

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

তবে এটি অকার্যকর কারণ আপনি সমস্ত উপাদানকে সরিয়ে নিয়ে যেতে পারেন, যা ব্যয়বহুল।

অর্ডার গুরুত্বপূর্ণ নয়

যদি আপনি অর্ডার দেওয়ার বিষয়ে যত্নশীল না হন তবে আপনার স্লাইস শেষে যেটি দিয়ে মুছে ফেলা যায় এবং তারপরে এন -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.06ns লাগে। আমি সন্দেহ করি যে অভ্যন্তরীণভাবে, কেবল স্লাইসের দৈর্ঘ্য পরিবর্তন না করেই যান।

সম্পাদনা করুন 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]
}

এছাড়াও, এই উত্তরটি বাউন্ডস-চেকিং করে না । এটি ইনপুট হিসাবে একটি বৈধ সূচক আশা করে। এর অর্থ হল যে negativeণাত্মক মান বা সূচকগুলি লেন (গুলি) এর চেয়ে বড় বা সমান, আতঙ্কিত হতে পারে। স্লাইস এবং অ্যারে 0-ইনডেক্স করা হচ্ছে, অ্যারের এন-তম উপাদানটি সরানো ইনপুট এন -1 সরবরাহ করার জন্য বোঝায় । প্রথম উপাদানটি সরাতে , কল অপসারণ (গুলি, 0) , দ্বিতীয়টি সরাতে , কল সরান (গুলি, 1) , এবং আরও অনেক কিছু।

Question 3

স্লাইস থেকে একটি উপাদান সরিয়ে ফেলুন (একে 'রি-স্লাইসিং' বলা হয়):

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]
}

Question 4

মাইনর পয়েন্ট (কোড গল্ফ), তবে যেখানে অর্ডার বিবেচনা করে না সেখানে মানগুলি অদলবদল করার দরকার নেই। শেষ অবস্থানটির সদৃশ দিয়ে সরানো অ্যারে অবস্থানটি কেবল ওভাররাইট করুন এবং তারপরে একটি কাটা অ্যারেটি ফিরিয়ে দিন।

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

একই ফলাফল।

Question 5

এটি দেখতে কিছুটা অদ্ভুত তবে এখানে বেশিরভাগ উত্তরগুলি বিপদজনক এবং তারা আসলে কী করছে তা নিয়ে চকচকে। স্লাইস থেকে কোনও আইটেম সরানোর বিষয়ে জিজ্ঞাসা করা মূল প্রশ্নটির দিকে তাকিয়ে স্লাইসের একটি অনুলিপি তৈরি করা হচ্ছে এবং তারপরে এটি পূরণ করা হচ্ছে। এটি নিশ্চিত করে যে টুকরোগুলি আপনার প্রোগ্রামের চারপাশে পাস করার সাথে সাথে আপনি সূক্ষ্ম বাগগুলি প্রবর্তন করেন না।

এই থ্রেড এবং মূল পোস্টে ব্যবহারকারীদের উত্তরগুলির তুলনা করার জন্য এখানে কিছু কোড রয়েছে। এই কোডটি সহ চারদিকে গোলযোগের জন্য এখানে যাওয়ার খেলার মাঠ go

ভিত্তিক অপসারণ যোগ করুন

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]
}

মূল সরান সূচক সমাধানের সাথে প্রায় একই রকম তবে আমরা ফিরে আসার আগে যুক্ত করতে একটি নতুন স্লাইস তৈরি করি।

Question 6

এভাবেই তুমি মুছুন A থেকে ফালি 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]

Question 7

দ্য গো প্রোগ্রামিং ল্যাঙ্গুয়েজ বইটি থেকে

স্লাইসের মাঝামাঝি থেকে কোনও উপাদানটিকে অপসারণ করতে, অবশিষ্ট উপাদানগুলির ক্রম সংরক্ষণ করে, শূন্যস্থান পূরণের জন্য উচ্চতর সংখ্যাযুক্ত উপাদানগুলি একের পর এক স্লাইড করতে অনুলিপিটি ব্যবহার করুন:
func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

Question 8

টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো অপসারণ করতে। এটি অন্যের পাঠযোগ্যতায় সহায়তা করে। এবং অপরিবর্তনীয়।

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

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

    return newitems
}

Question 9

আপনি এই পদ্ধতিটি চেষ্টা করতে পারেন:

// 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"

Question 10

সম্ভবত এই কোড সাহায্য করবে।

এটি প্রদত্ত সূচকের সাহায্যে আইটেম মুছে ফেলে।

অ্যারে নেয় এবং সূচক মুছে ফেলার জন্য এবং একটি নতুন অ্যারে ফিরিয়ে দেয় অনেকটা অ্যাডেন্ড ফাংশনের মতো।

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

Question 11

এটি করার সর্বোত্তম উপায় হ'ল টিউ অ্যাড অ্যাপেন্ড ফাংশন:

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

Question 12

স্থান পরিবর্তন না করে এখানে একটি উপায় সন্ধান করুন ।

ক্রম পরিবর্তন

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]

Question 13

যদি না আপনি বিষয়বস্তু যত্ন নেন এবং আপনি স্লাইস অ্যাপেন্ড ব্যবহার করতে না পারেন তবে প্রতিটি একক উপাদান পরীক্ষা করার দরকার নেই। চেষ্টা কর

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")
}

Question 14

এখানে পয়েন্টারের সাথে খেলার মাঠের উদাহরণ রয়েছে। 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)
}