किसी भी विचार क्या ????होना चाहिए? वहाँ एक में निर्मित है? इस कार्य को पूरा करने का सबसे अच्छा तरीका क्या होगा?
(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
जवाबों:
निर्मित:
user> (def v ["one" "two" "three" "two"])
#'user/v
user> (.indexOf v "two")
1
user> (.indexOf v "foo")
-1
यदि आप सभी मैचों के लिए सूचकांकों के आलसी seq चाहते हैं:
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)
indexOfविधि है जिसे कहा जाता है, न कि स्ट्रिंग:#<Method public int clojure.lang.APersistentVector.indexOf(java.lang.Object)>
स्टुअर्ट हल्लोवे ने इस पोस्ट में बहुत अच्छा जवाब दिया है http://www.mail-archive.com/clojure@googlegroups.com/msg34159.html ।
(use '[clojure.contrib.seq :only (positions)])
(def v ["one" "two" "three" "two"])
(positions #{"two"} v) ; -> (1 3)
यदि आप firstपरिणाम पर पहले मूल्य का उपयोग करना चाहते हैं ।
(first (positions #{"two"} v)) ; -> 1
संपादित करें: क्योंकि clojure.contrib.seqमैं गायब हो गया हूं मैंने एक सरल कार्यान्वयन के उदाहरण के साथ अपना जवाब अपडेट किया है:
(defn positions
[pred coll]
(keep-indexed (fn [idx x]
(when (pred x)
idx))
coll))
clojure.contib.seq1.6 में क्लोजर कहां मिलेगा ? सूची में कोई पुस्तकालय नहीं: dev.clojure.org/display/community/Where+Did+Clojure.Contrib+Go
positions।
(defn find-thing [needle haystack]
(keep-indexed #(when (= %2 needle) %1) haystack))
लेकिन मैं आपको सूचकांकों के साथ फिडलिंग के खिलाफ चेतावनी देना चाहूंगा: सबसे अधिक बार यह कम मुहावरेदार, अजीब क्लोजर का उत्पादन करने वाला नहीं है।
क्लोजर के रूप में 1.4 clojure.contrib.seq (और इस प्रकार positionsफ़ंक्शन) उपलब्ध नहीं है क्योंकि यह एक अनुचर को याद कर रहा है:
http://dev.clojure.org/display/design/Where+Did+Clojure.Contrib+Go
स्रोत clojure.contrib.seq/positionsऔर इसके लिए निर्भरता clojure.contrib.seq/indexedहै:
(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)
यहाँ उपलब्ध है: http://clojuredocs.org/clojure_contrib/clojure.contrib.seq/formitions
मैं अपने ही सवाल का जवाब देने की कोशिश कर रहा था, लेकिन ब्रायन ने मुझे एक बेहतर जवाब दे दिया!
(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
यहाँ मेरा योगदान है, एक loopआईएनजी संरचना का उपयोग करना और nilविफलता पर लौटना ।
जब मैं कर सकता हूं तो मैं छोरों से बचने की कोशिश करता हूं, लेकिन यह इस समस्या के लिए उपयुक्त है।
(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)))))
मुझे हाल ही में कई बार अनुक्रमणिकाएं ढूंढनी पड़ीं या फिर मैंने चुना क्योंकि समस्या के करीब पहुंचने का एक और तरीका समझाना आसान था। जिस तरह से मुझे पता चला कि मेरी क्लोजर सूचियों में .indexOf (ऑब्जेक्ट ऑब्जेक्ट, इंट स्टार्ट) विधि नहीं थी। मैं इस तरह की समस्या से निपटा:
(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)))))