diff options
| author | Mark Engelberg <mark.engelberg@gmail.com> | 2009-02-28 17:22:18 +0000 |
|---|---|---|
| committer | Mark Engelberg <mark.engelberg@gmail.com> | 2009-02-28 17:22:18 +0000 |
| commit | 153681b4ed497361fbbbf0bc8a9ca5190363a630 (patch) | |
| tree | 7b116351112130d525801cd544e02adf68bff57f /src/clojure/contrib/combinatorics.clj | |
| parent | d7e521dceaa63a3da50c531e22e1ec319150c619 (diff) | |
Fiddled with the location of some of the calls to lazy-seq.
Diffstat (limited to 'src/clojure/contrib/combinatorics.clj')
| -rw-r--r-- | src/clojure/contrib/combinatorics.clj | 52 |
1 files changed, 26 insertions, 26 deletions
diff --git a/src/clojure/contrib/combinatorics.clj b/src/clojure/contrib/combinatorics.clj index d4f63cf5..8303aebc 100644 --- a/src/clojure/contrib/combinatorics.clj +++ b/src/clojure/contrib/combinatorics.clj @@ -65,21 +65,22 @@ On my own computer, I use versions of all these algorithms that return sequences (defn- index-combinations
[n cnt]
- (let [c (vec (cons nil (for [j (range 1 (inc n))] (+ j cnt (- (inc n)))))),
- iter-comb
- (fn iter-comb [c j]
- (if (> j n) nil
- (let [c (assoc c j (dec (c j)))]
- (if (< (c j) j) [c (inc j)]
- (loop [c c, j j]
- (if (= j 1) [c j]
- (recur (assoc c (dec j) (dec (c j))) (dec j)))))))),
- step
- (fn step [c j]
- (cons (rseq (subvec c 1 (inc n)))
- (lazy-seq (let [next-step (iter-comb c j)]
- (when next-step (step (next-step 0) (next-step 1)))))))]
- (lazy-seq (step c 1))))
+ (lazy-seq
+ (let [c (vec (cons nil (for [j (range 1 (inc n))] (+ j cnt (- (inc n)))))),
+ iter-comb
+ (fn iter-comb [c j]
+ (if (> j n) nil
+ (let [c (assoc c j (dec (c j)))]
+ (if (< (c j) j) [c (inc j)]
+ (loop [c c, j j]
+ (if (= j 1) [c j]
+ (recur (assoc c (dec j) (dec (c j))) (dec j)))))))),
+ step
+ (fn step [c j]
+ (cons (rseq (subvec c 1 (inc n)))
+ (lazy-seq (let [next-step (iter-comb c j)]
+ (when next-step (step (next-step 0) (next-step 1)))))))]
+ (step c 1))))
(defn combinations
"All the unique ways of taking n different elements from items"
@@ -104,19 +105,18 @@ On my own computer, I use versions of all these algorithms that return sequences (let [v-original-seqs (vec seqs)
step
(fn step [v-seqs]
- (lazy-seq
- (let [increment
- (fn [v-seqs]
- (loop [i (dec (count v-seqs)), v-seqs v-seqs]
- (if (= i -1) nil
- (if-let [rst (next (v-seqs i))]
- (assoc v-seqs i rst)
- (recur (dec i) (assoc v-seqs i (v-original-seqs i)))))))]
- (when v-seqs
+ (let [increment
+ (fn [v-seqs]
+ (loop [i (dec (count v-seqs)), v-seqs v-seqs]
+ (if (= i -1) nil
+ (if-let [rst (next (v-seqs i))]
+ (assoc v-seqs i rst)
+ (recur (dec i) (assoc v-seqs i (v-original-seqs i)))))))]
+ (when v-seqs
(cons (map first v-seqs)
- (step (increment v-seqs)))))))]
+ (lazy-seq (step (increment v-seqs)))))))]
(when (every? first seqs)
- (step v-original-seqs))))
+ (lazy-seq (step v-original-seqs)))))
(defn selections
|