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

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))))

这基本上是在运行比较之前用尽可能多的nils 填充输入。我喜欢它的外观（它应该完全符合您的要求），但我不确定我是否会向任何人推荐它。 ;)

(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 的回答的 cmets 中所说的那样，我认为最没有创意的方法在这里是最好的：只需编写一个循环，列举所有案例，然后通过它。作为奖励，这种方法也适用于任意序列，可能是惰性的，因为我们不需要依赖任何特定于向量的技巧。

(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 的序列，然后删除所有前导 0。第一个非零元素是第一个不同的元素。