Comment puis-je inverser un tableau en Aller?

Normalement, pour trier un tableau d'entiers vous envelopper dans une IntSlice, qui définit les méthodes Len, Less, et Swap. Ces méthodes sont à leur tour utilisés par sort.Sort. Ce sort.Reverse n'est qu'il faut un type existant qui définit Len, Less, et Swap, mais il remplace le Less méthode avec un nouveau qui est toujours l'inverse de la sous-jacentes Less:

type reverse struct {
    //This embedded Interface permits Reverse to use the methods of
    //another Interface implementation.
    Interface
}

//Less returns the opposite of the embedded implementation's Less method.
func (r reverse) Less(i, j int) bool {
    return r.Interface.Less(j, i)
}

//Reverse returns the reverse order for data.
func Reverse(data Interface) Interface {
    return &reverse{data}
}

Donc, lorsque vous écrivez sort.Reverse(sort.IntSlice(s)), ce qui se passe, c'est que vous êtes l'obtention de cette nouvelle, 'modified' IntSlice qui a il est Less méthode remplacé. Donc, si vous appelez sort.Sort sur elle, qui appelle Less, il sera triée dans l'ordre décroissant.

Je suis à 2 ans de retard, mais juste pour le plaisir et intérêt que je voudrais contribuer à une "saugrenue" de la solution.

En supposant que la tâche est vraiment inverser une liste, puis pour les performances brutes bgp's solution est probablement imbattable. Il fait le travail tout simplement et efficacement par le remplacement des éléments de tableau de l'avant à l'arrière, une opération qui est efficace dans la ram de la structure des tables et les tranches.

Dans les langages de Programmation Fonctionnelle, la idiomatiques approche serait impliquent souvent la récursivité. Cela semble un peu étrange au départ, ont atroce de la performance. Cela dit, voici une récursif tableau d'inversion de la fonction (dans un petit programme de test):

package main

import (
    "fmt"
)

func main() {
    myInts := []int{ 8, 6, 7, 5, 3, 0, 9 }
    fmt.Printf("Ints %v reversed: %v\n", myInts, reverseInts(myInts))
}

func reverseInts(input []int) []int {
    if len(input) == 0 {
        return input
    }
    return append(reverseInts(input[1:]), input[0]) 
}

De sortie:

Ints [8 6 7 5 3 0 9] reversed: [9 0 3 5 7 6 8]

Encore une fois, c'est pour le plaisir et non de production. Non seulement c'est lent, mais il est en dépassement de capacité de la pile si la liste est trop grande. Je viens de tester, et il va inverser une liste de 1 million de ints mais se bloque sur 10 millions de dollars.

Si vous voulez inverser la matrice, vous pouvez simplement aller à travers elle dans l'ordre inverse. Depuis il n'y a pas de "reverse gamme" primitive dans la langue (du moins pas encore), vous devez faire quelque chose comme ceci (http://play.golang.org/p/AhvAfMjs_7):

s := []int{5, 2, 6, 3, 1, 4}
for i := len(s) - 1; i >= 0; i-- {
    fmt.Print(s[i])
    if i > 0 {
        fmt.Print(", ")
    }
}
fmt.Println()

Quant à savoir si il est difficile de comprendre ce sort.Reverse(data Interface) Interface fait, je pensais la même chose jusqu'à ce que j'ai vu dans le code source de "http://golang.org/src/pkg/sort/sort.go".

Il fait juste les comparaisons nécessaires pour le tri à être "l'autre sens".

func Reverse(data Interface) Interface

Cela signifie qu'il faut un sort.Interface et renvoie une autre sort.Interface -- il ne fait pas le tri lui-même. Par exemple, si vous passez dans sort.IntSlice (qui est essentiellement un []int qui peut être transmis à sort.Sort de faire le tri dans l'ordre croissant), vous aurez une nouvelle sort.Interface qui trie les entiers dans l'ordre décroissant à la place.

Par ailleurs, si vous cliquez sur le nom de la fonction dans la documentation, il relie directement à la source pour Reverse. Comme vous pouvez le voir, c'est juste enveloppe le sort.Interface que vous passez, alors la valeur retournée par Reverse obtient toutes les méthodes de l'original sort.Interface. La seule méthode qui est différente, c'est le Less méthode qui renvoie l'inverse de la Less méthode sur l'embedded sort.Interface. Voir cette partie de la langue spec pour plus de détails sur les champs.

Ici est un simple Aller-solution qui utilise un système efficace (pas de mémoire supplémentaire) approche inverse d'une matrice:

i := 0
j := len(nums) - 1
for i < j {
    nums[i], nums[j] = nums[j], nums[i]
    i++
    j--
}

L'idée est que l'inversion d'une matrice est équivalente à l'échange de chaque élément avec son image dans un miroir à travers le centre.

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

Voici ma solution pour inverser un tableau:

func reverse_array(array []string) []string {
    lenx := len(array) //lenx holds the original array length
    reversed_array := make([]string, lenx) //creates a slice that refer to a new array of length lenx

    for i := 0; i < lenx; i++ {
        j := lenx - (i + 1) //j initially holds (lenx - 1) and decreases to 0 while i initially holds 0 and increase to (lenx - 1)
        reversed_array[i] = array[j]
    }

    return reversed_array
}

Vous pouvez essayer cette solution sur la route de l'aire de jeux la aller de l'aire de jeux

package main

import "fmt"

func main() {
    array := []string{"a", "b", "c", "d"}

    fmt.Println(reverse_array(array)) //prints [d c b a]
}