Wie finde ich den Index eines Elements in einem Vektor?

Irgendwelche Ideen was ????sein soll? Gibt es eine eingebaute? Was wäre der beste Weg, um diese Aufgabe zu erfüllen?

(def v ["one" "two" "three" "two"])

(defn find-thing [ thing vectr ]
  (????))

(find-thing "two" v) ; ? maybe 1, maybe '(1,3), actually probably a lazy-seq

Eingebaut:

user> (def v ["one" "two" "three" "two"])
#'user/v
user> (.indexOf v "two")
1
user> (.indexOf v "foo")
-1

Wenn Sie eine faule Abfolge der Indizes für alle Übereinstimmungen wünschen:

user> (map-indexed vector v)
([0 "one"] [1 "two"] [2 "three"] [3 "two"])
user> (filter #(= "two" (second %)) *1)
([1 "two"] [3 "two"])
user> (map first *1)
(1 3)
user> (map first 
           (filter #(= (second %) "two")
                   (map-indexed vector v)))
(1 3)

Stuart Halloway hat in diesem Beitrag eine wirklich nette Antwort gegeben: http://www.mail-archive.com/[email protected]/msg34159.html .

(use '[clojure.contrib.seq :only (positions)])
(def v ["one" "two" "three" "two"])
(positions #{"two"} v) ; -> (1 3)

Wenn Sie den ersten Wert abrufen möchten, verwenden Sie einfach firstdas Ergebnis.

(first (positions #{"two"} v)) ; -> 1

EDIT: Weil clojure.contrib.seqverschwunden ist, habe ich meine Antwort mit einem Beispiel einer einfachen Implementierung aktualisiert:

(defn positions
  [pred coll]
  (keep-indexed (fn [idx x]
                  (when (pred x)
                    idx))
                coll))

(defn find-thing [needle haystack]
  (keep-indexed #(when (= %2 needle) %1) haystack))

Aber ich möchte Sie davor warnen, mit Indizes herumzuspielen: Meistens wird es weniger idiomatische, unangenehme Clojure produzieren.

Ab Clojure 1.4 ist clojure.contrib.seq (und damit die positionsFunktion) nicht verfügbar, da ein Betreuer fehlt: http://dev.clojure.org/display/design/Where+Did+Clojure.Contrib+Go

Die Quelle clojure.contrib.seq/positionsund Abhängigkeit clojure.contrib.seq/indexedist:

(defn indexed
  "Returns a lazy sequence of [index, item] pairs, where items come
  from 's' and indexes count up from zero.

  (indexed '(a b c d))  =>  ([0 a] [1 b] [2 c] [3 d])"
  [s]
  (map vector (iterate inc 0) s))

(defn positions
  "Returns a lazy sequence containing the positions at which pred
   is true for items in coll."
  [pred coll]
  (for [[idx elt] (indexed coll) :when (pred elt)] idx))

(positions #{2} [1 2 3 4 1 2 3 4]) => (1 5)

Hier verfügbar: http://clojuredocs.org/clojure_contrib/clojure.contrib.seq/positions

Ich habe versucht, meine eigene Frage zu beantworten, aber Brian hat mich mit einer besseren Antwort geschlagen!

(defn indices-of [f coll]
  (keep-indexed #(if (f %2) %1 nil) coll))

(defn first-index-of [f coll]
  (first (indices-of f coll)))

(defn find-thing [value coll]
  (first-index-of #(= % value) coll))

(find-thing "two" ["one" "two" "three" "two"]) ; 1
(find-thing "two" '("one" "two" "three")) ; 1

;; these answers are a bit silly
(find-thing "two" #{"one" "two" "three"}) ; 1
(find-thing "two" {"one" "two" "two" "three"}) ; nil

Hier ist mein Beitrag, eine loopStruktur zu verwenden und nilbei einem Fehler zurückzukehren.

Ich versuche, Schleifen zu vermeiden, wenn ich kann, aber es scheint für dieses Problem geeignet zu sein.

(defn index-of [xs x]
  (loop [a (first xs)
         r (rest xs)
         i 0]
    (cond
      (= a x)    i
      (empty? r) nil
      :else      (recur (first r) (rest r) (inc i)))))

Ich musste in letzter Zeit mehrmals Indizes finden oder entschied mich dafür, da es einfacher war, als einen anderen Weg zu finden, um das Problem anzugehen. Unterwegs stellte ich fest, dass meine Clojure-Listen nicht die Methode .indexOf (Object object, int start) hatten. Ich habe das Problem folgendermaßen behandelt:

(defn index-of
"Returns the index of item. If start is given indexes prior to
 start are skipped."
([coll item] (.indexOf coll item))
([coll item start]
  (let [unadjusted-index (.indexOf (drop start coll) item)]
    (if (= -1 unadjusted-index)
  unadjusted-index
  (+ unadjusted-index start)))))

Ich würde mit redu-kv gehen

(defn find-index [pred vec]
  (reduce-kv
    (fn [_ k v]
      (if (pred v)
        (reduced k)))
    nil
    vec))