Bonjour,

Je commence à apprendre Go et je bloque sur des choses qui semble "basique" en Python (d'ou je viens :)). Je cherche à trier un array mais dans l'ordre décroissant. J'ai cru comprendre uq'il n'y avait pas de fonction reverse de base (déjà c'est surprenant) et je me suis dit que c'était la bonne occasion pour tester les pointeurs. 

Si je fais cette fonction :

import "sort"

func reverse(arr []int)[]int{ // fonction trouvée sur Stack Overflow
    for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
        arr[i], arr[j] = arr[j], arr[i]
    }
    return arr
}

func main() {
    nums := []int{1, 6, 8, 3, 2}
    sort.Ints(nums)
    nums = reverse(nums)
}

Cela fonctionne. Maintenant, si pour des raisons de performances je ne veux pas un second tableau mais modifier le arr, je pensais faire:

func reverse(arr *[]int){
    for i, j := 0, len(*arr)-1; i < j; i, j = i+1, j-1 {
        *arr[i], *arr[j] = *arr[j], *arr[i]
    }
}

func main() {
    nums := []int{1, 6, 8, 3, 2}
    sort.Ints(nums)
    reverse(&nums)
}

Cela ne marche pas. pourtant je dis bien que la fonction va recevoir un pointeur et je modifie bien les variables avec * ou j'ai raté qqch ? Au vu de l'erreur, je pense ne pas avoir saisi ce qui se passe quand on fait *qqch

invalid operation: arr[i] (type *[]int does not support indexing)

Je vous remercie d'avance,

Coni

Je débute sur Golang

Alors pour la réponse t'y étais presque, je pense que depuis tu as trouvé,

func reverse(arr *[]int){
    for i, j := 0, len(*arr)-1; i < j; i, j = i+1, j-1 {
        (*arr)[i], (*arr)[j] = (*arr)[j], (*arr)[i]
    }
}

Tu avais juste oublié les parenthèses, car en déréférençant, ce n'est pas arr que tu déréférençais, mais arr[i] ce qui n'est pas la même chose.

-
Edité par fred1599 22 avril 2020 à 15:48:19

Ah bien vu ! 

Au final j'avais retourné un nouveau slice avec la 1ere fonction de la question (c'est un petit peu gourmand en mémoire mais bon, ça restait un exercice). Il y a aussi moyen de reverse via une méthode ( sort.Sort(sort.Reverse(sort.IntSlice(s))) ) mais ça reste très lourd je trouve.

A l'instant t, ce langage a encore beaucoup de désavantages (voir trop) pour être réellement sympa (je vais surement mettre en pause le learning pour l'instant). Par contre les pipes, c'est vraiment le pied ! C'est simple comparé a tous les autres langages et ça permet de faire des choses sympas !

coni63 a écrit:

Ah bien vu ! 

Au final j'avais retourné un nouveau slice avec la 1ere fonction de la question (c'est un petit peu gourmand en mémoire mais bon, ça restait un exercice). Il y a aussi moyen de reverse via une méthode ( sort.Sort(sort.Reverse(sort.IntSlice(s))) ) mais ça reste très lourd je trouve.

Je ne connais pas assez le langage pour en dire plus, mais si tu le faisais manuellement, tu devrais aussi passer par un certains nombres d'itérations sur ton tableau.

coni63 a écrit:

A l'instant t, ce langage a encore beaucoup de désavantages (voir trop) pour être réellement sympa (je vais surement mettre en pause le learning pour l'instant).

Alors quels inconvénients par exemple ?

EDIT:

Sinon autre solution possible,

package main

import (
    "fmt"
    "sort"
)

type ArraySort struct {
    arr []int
    less func(i, j int) bool
}

func (m ArraySort) Len() int { return len(m.arr) }
func (m ArraySort) Swap(i, j int) { m.arr[i], m.arr[j] = m.arr[j], m.arr[i] }
func (m ArraySort) Less(i, j int) bool { return m.less(m.arr[i], m.arr[j]) }

func sortByInteger(i, j int) bool { return i < j }
func sortByIntegerRev(i, j int) bool { return i > j }

func main() {
    nums := []int{1, 6, 8, 3, 2}
    sort.Sort(ArraySort{nums, sortByIntegerRev})
    fmt.Println(nums)
}

-
Edité par fred1599 23 avril 2020 à 10:57:36

Bah ce sont majoritairement les choses qui ne sont pas accessibles de bases comme:

 - Min, Max n'existe pas pour des int (soit tu cast en float64) soit tu dois faire une fonction (certe simple mais bon à chaque fois c'est vite chiant)

 - le reverse d'un array ou même pour sort des objets (il n'y a pas d'equivalent à `arr.sort( key = lambda x:x.foo)` en python par exemple

 - comparer un flaot a un int n'est pas possible sans cast une des variables (ex 1 > 0.95) => float64(1) > 0.95 s'il est déclaré en float initialement

En fait le type de variable impacte beaucoup les capacités. C'est logique mais par exemple Java utilise les overload pour ça et ça fait plaisir. Comme j'utilisais LeetCode pour apprendre, j'ai surtout eu affaire à des problèmes d'algorithmiques et je le trouve très bof pour ça (bien que très performant).

Apres il faut aussi garder en tête que Go est fait pour du serveur. C'est donc assez peu courant de faire ce genre de choses. Il a des avantages certains pour le web comme la simplicité pour la concurrency.