Question

它的工作原理如下：

pcc.core=> (compare [4] [2 2])
-1
pcc.core=> (compare [4 0] [2 2])
1

我想要一个带有“字符串语义”的矢量比较器：

pcc.core=> (compare-like-strings [4] [2 2])
1 ;; or 2, for that matter
pcc.core=> (compare-like-strings [4 0] [2 2])
1

有没有轻量级的，很好的方式来获得我想要的东西？

Answer 1

怎么样：

(defn compare-like-strings [[x & xs] [y & ys]]
  (let [c (compare x y)]
    (if (and (zero? c) (or xs ys))
      (recur xs ys)
      c)))

Answer 2

到目前为止

(defn cmpv-int
  "Compare vectors of integers using 'string semantics'"
  [vx vy]
  (let [res (first (drop-while zero? (map compare vx vy)))
        diffenence (- (count vx) (count vy))]
     (if res res diffenence)
    )
  )

基于Fabian方法。

Answer 3

为什么不使用subvec？

(defn compare-like-strings
  [vec1 vec2]
  (let [len (min (count vec1) (count vec2))]
    (compare (subvec vec1 0 len)
             (subvec vec2 0 len))))

Answer 4

如果两个向量的长度相同，则比较似乎有效，所以让我提供：

(defn compare-vectors
  [a b]
  (compare
    (reduce conj a (map #{} b))
    (reduce conj b (map #{} a))))

这基本上是在运行比较之前根据需要用尽可能多的nil填充输入。我喜欢它的外观（它应该完全符合你的要求），但我并不特别确定我会推荐给任何人。 ;）

(compare-vectors [2 2] [2 2]) ;; => 0
(compare-vectors [4 2] [2 2]) ;; => 1
(compare-vectors [2 2] [4 2]) ;; => -1
(compare-vectors [4]   [2 2]) ;; => 1

编辑：我可能不会 - 效率非常低。

Answer 5

正如我在对Diego的答案的评论中所说的那样，我认为最不具创造性的方法在这里是最好的：只需编写一个循环，枚举所有案例，并轻视它。作为奖励，这种方法也适用于任意序列，可能是懒惰的，因为我们不需要依赖任何特定于矢量的技巧。

(defn lexicographic-compare
  ([xs ys]
     (lexicographic-compare compare xs ys))
  ([compare xs ys]
     (loop [xs (seq xs) ys (seq ys)]
       (if xs
         (if ys
           (let [c (compare (first xs) (first ys))]
             (if (not (zero? c))
               c
               (recur (next xs), (next ys))))
           1)
         (if ys
           -1
           0)))))

Answer 6

也许是这样的？

(defn compare-like-strings [a b]
  (let [res (first (drop-while zero? (map compare a b)))]
    (if (nil? res)
      0
      res)))

想法是进行成对比较，返回-1,0或1的seq，然后删除所有前导0。第一个非零元素是第一个不同的元素。

Clojure，比较整数向量：为什么“更长”的向量总是“更大”？有补救措施吗？

6 个答案: