Rückseite einer Karte in <Wert -, Schlüssel - > format in Golang

Habe ich eine Karte für mein Programm sieht wie folgt aus:

fruit_map := map[string]string {
    "apple": "likey",
    "orange": "no likey",
}

Möchte ich umkehren so dass es liest die folgenden:

{
    "likey": "apple",
    "no likey": "orange",
}

Gibt es keine doppelten Werte. Auch meine Karte ist klein - etwa 200 Schlüssel. Ich fand keine integrierte Methode zum umkehren einer Karte wie dieser. Gibt es eine Möglichkeit, dies zu tun fallen? Ich bin nicht viel Mühe gemacht über Raum Komplexität, aber die Lösung muss schnell sein.

Dank.

InformationsquelleAutor jyotiska | 2014-04-21

go map

3

Schreiben Sie eine for - Schleife zur Iteration über die Schlüssel-Wert-paar der original-Karte, und setzen Sie Sie in eine neue map (siehe Funktion reverseMap)

Code@http://play.golang.org/p/mCFmRT8nzP
```
package main

import (
    "fmt"
)

func main() {
    fruit_map := map[string]string{
        "apple":  "likey",
        "orange": "no likey",
    }

    reversedMap := reverseMap(fruit_map)
    fmt.Println(reversedMap)
}

func reverseMap(m map[string]string) map[string]string {
    n := make(map[string]string)
    for k, v := range m {
        n[v] = k
    }
    return n
}
```
Ausgabe:
```
map[likey:apple no likey:orange]
```
BTW, es ist nicht idiomatisch, um Namen gehen Variablen wie fruit_map Sie wirklich verwenden sollten, Kamel-Fall, wie fruitMap.
- Da Sie erwarten, dass die Größe der Karte m identisch ist, die Größe der Karte m (vorausgesetzt, dass keine doppelten Werte), die Sie vielleicht nutzen wollen: n := make(map[string]string, len(m)) zu speichern, ausreichend Platz und vermeiden Umschichtungen während der Schleife.
InformationsquelleAutor Mingyu

Den anderen Antworten bieten die einfache Lösung basiert auf Umgang mit der Karte direkt.

Ist eine alternative Lösung zu Kapseln eine bidirektionale map als ein eigenständiges Dienstprogramm, das hat den Vorteil, dass Sie schreiben konnte, Gründliche unit-tests für Sie und dann in der Lage sein auf Sie verlassen, um richtig funktionieren über ein einfaches API.

Hier mein Beispiel implementation (das ist unvollständig, und die haben noch nicht die notwendigen unit-tests):

Paket main

import (
    "fmt"
)

func main() {
    biMap := NewBiMap()
    biMap.Put("apple", "likey")
    biMap.Put("orange", "no likey")
    v, _ := biMap.GetByValue("no likey")
    fmt.Println(v)
}

type BiMap struct {
    ab map[string]string
    ba map[string]string
}

func NewBiMap() *BiMap {
    return &BiMap{make(map[string]string), make(map[string]string)}
}

func (m *BiMap) Put(key, value string) *BiMap {
    m.ab[key] = value
    m.ba[value] = key
    return m
}

func (m *BiMap) GetByKey(key string) (value string, exists bool) {
    value, exists = m.ab[key]
    return
}

func (m *BiMap) GetByValue(value string) (key string, exists bool) {
    key, exists = m.ba[value]
    return
}

func (m *BiMap) Len() int {
    return len(m.ab)
}

func (m *BiMap) DeleteKey(key string) *BiMap {
    value, exists := m.ab[key]
    if exists {
        delete(m.ab, key)
        delete(m.ba, value)
    }
    return m
}

func (m *BiMap) DeleteValue(value string) *BiMap {
    key, exists := m.ba[value]
    if exists {
        delete(m.ab, key)
        delete(m.ba, value)
    }
    return m
}

InformationsquelleAutor Rick-777

Du hast Recht, es gibt nichts, built-in, um dies zu erreichen, aber es ist wirklich einfach:

package main

import "fmt"

func main() {

    fruit_map := map[string]string{
        "apple":  "likey",
        "orange": "no likey",
    }

    //create your new empty map that will hold your reversed contents.
    reversed_fruit_map := make(map[string]string)

    for k, v := range fruit_map{
        reversed_fruit_map[v] = k
    }

    fmt.Println(reversed_fruit_map)
}

Diese Ausgänge die folgende:

map[likey:apple no likey:orange]

Check it out auf der Spielplatz. Wenn dies üblich ist, können Sie immer zu extrahieren in eine eigene Funktion.

InformationsquelleAutor Ralph Caraveo

Gibt es nicht eine integrierte Funktion zu tun, aber es ist einfach genug, mit ein for Schleife.

fruit_map := map[string]string {
    "apple": "likey",
    "orange": "no likey",
}

reversed_map := make(map[string]string)

for key,value := range fruit_map {
    reversed_map[value] = key
}

finden Sie unter: http://play.golang.org/p/BQjqUsf9aU

InformationsquelleAutor dethtron5000

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.