स्लाइस

Question

के सभी क्रमपरिवर्तन प्राप्त करें मैं सोच रहा था कि गो में वर्णों से भरे हुए टुकड़े के सभी क्रमपरिवर्तनों को खोजने का कोई तरीका है या नहीं?

पायथन में आप itertools.product का उपयोग किसी सूची या वर्ण या पूर्णांक के साथ कर सकते हैं, और आप सभी संभावित क्रमिकरण प्राप्त कर सकते हैं।

मैंने देखा है कि वहां कोई पैकेज है या नहीं, और मुझे लगता है कि कोई नहीं ढूंढ सकता। किसी भी मदद का स्वागत किया जाएगा। कुछ भी

Answer 1

परम्युटेशन्स sort.Interface को लागू करने: Permutation{First,Next}

Answer 2

यहाँ एक क्रमचय समारोह मैं लिखा है की एक कार्यान्वयन है ...

https://github.com/itcraftsman/GoPermutation

func permutate(slice [][]int) (permutations [][][]int){ 
    f := fac(len(slice)) 
    for i := 0; i < len(slice); i++ { 
     elem, s := splice(slice, i) 
     pos := 0 
     for count := 0; count < (f/len(slice)); count++{ 
      if pos == (len(s) -1) { 
       pos = 0 
      } 
      s = swap(s, pos, pos +1) 
      permutation := make([][]int, len(slice)) 
      permutation = s 
      permutation = append(permutation, elem) 
      permutations = append(permutations, permutation) 
      pos++ 
     } 
    } 
    return 
} 

यह इनपुट के रूप में एक 2 डी टुकड़ा लेता है और एक 3 डी स्लाइस देता है, लेकिन आप कोड को आसानी से बदल सकते हैं ताकि फ़ंक्शन इनपुट के रूप में एक साधारण टुकड़ा ले ले और सभी क्रमपरिवर्तनों के साथ 2 डी टुकड़ा वापस कर सके

Answer 3

वास्तव में यह सुनिश्चित नहीं है कि यह आपके प्रश्न का उत्तर देता है लेकिन यह नीचे दिए गए आउटपुट को खोजने के लिए एक सरल पुनरावर्ती कार्यान्वयन है।

package main 

import "fmt" 

func main() { 
    values := [][]int{} 

    // These are the first two rows. 
    row1 := []int{1, 2, 3} 
    row2 := []int{4, 5, 6} 
    row3 := []int{7, 8, 9} 

    // Append each row to the two-dimensional slice. 
    values = append(values, row1) 
    values = append(values, row2) 
    values = append(values, row3) 


    fmt.Println(getPermutation(values)) 
} 

func getPermutation(vids [][]int) [][]int { 
    toRet := [][]int{} 

    if len(vids) == 0 { 
     return toRet 
    } 

    if len(vids) == 1 { 
     for _, vid := range vids[0] { 
      toRet = append(toRet, []int{vid}) 
     } 
     return toRet 
    } 

    t := getPermutation(vids[1:]) 
    for _, vid := range vids[0] { 
     for _, perm := range t { 
      toRetAdd := append([]int{vid}, perm...) 
      toRet = append(toRet, toRetAdd) 
     } 
    } 

    return toRet 
} 

https://play.golang.org/p/f8wktrxkU0

ऊपर टुकड़ा के आउटपुट:

[[1 4 7] [1 4 8] [1 4 9] [1 5 7] [1 5 8] [1 5 9] [1 6 7] [1 6 8] [1 6 9] [2 4 7] [2 4 8] [2 4 9] [2 5 7] [2 5 8] [2 5 9] [2 6 7] [2 6 8] [2 6 9] [3 4 7] [3 4 8] [3 4 9] [3 5 7] [3 5 8] [3 5 9] [3 6 7] [3 6 8] [3 6 9]]