求（L，t）-团

Question

I'm trying to find clumps in Clojure. Basically, I need to find all k-length substrings that occur in a window of size L in a genome that occurs t times. I've implemented what I think the solution is, however I believe there might be bugs in it since the system (beta.stepic.org) I'm using to confirm tells me so. Can you guys spot where I'm messing up? My solution goes as follows, find all top ranking k-mers (k-length substrings) and find their starting indices. Afterwards, I partition in groups of t, which means this is the amount of times they occur and basically do a difference of the last and first item in a partitioned group with an offset of k (since all k-mers should fit in the L-window and this would account for the last k-mer by extending it). The indices are in ascending order. Where's the bug?

Clump Finding Problem: Find patterns forming clumps in a string.

 Input: A string Genome, and integers k, L, and t.
 Output: All distinct k-mers forming (L, t)-clumps in Genome.

Sample Input :

genome: CGGACTCGACAGATGTGAAGAACGACAATGTGAAGACTCGACACGACAGAGTGAAGAGAAGAGGAAACATTGTAA

 k: 5 
 L: 50 
 t: 4

Sample Output :

CGACA GAAGA

(defn get-indices [source target]
  "Returns the indices for the substring target
   found in source in ascending order. This includes overlaps."
  (let
    [search   (java.util.regex.Pattern/compile (str "(?=(" target "))"))
     matcher  (re-matcher search source)
     not-nil? (complement nil?)]

    (defn inner [matcher]
      (if (not-nil? (re-find matcher))
        (cons (.start matcher) (inner matcher))))
          (inner matcher)))

(defn get-frequent-kmer [source k]
  "Gets the most frequenct k-mers of size k from source"
  (let [max-val (val (apply max-key val (frequencies (partition k 1 source))))]
    (map first (filter #(= (val %) max-val)
      (frequencies (map (partial apply str) (partition k 1 source)))))))


(defn find-clumps [genome k L t]
  (for [k-mer (get-frequent-kmer genome k)]
    (let [indices (get-indices genome k-mer)]
      (if (some true? (map #(<= (+ k (- (last %) (first %))) L)
        (partition t 1 indices))) k-mer))))

Answer 1

Besides code style which has a couple things that can be improved, main problem I see is you're filtering k-mers on max-key val and you're not considering t at all on the initial filtering.

When you find the most frequent l-mers of size k you're just keeping the longer ones:

  (apply max-key val (frequencies (partition k 1 source)))

Since you filter by max-val

  (filter #(= (val %) max-val)

And you're only analyzing those:

  (for [k-mer (get-frequent-kmer genome k)]

The problem is that if t is 4, but you have some 5-mers with more than 4 repeats, you're leaving the ones repeated 4 times out of the equation.

Answer 2

Here is some working code:

(defn k-mers 
  "Returns a seq of all k-mers in text."
  [k text]
  (map #(apply str %) (partition k 1 text)))

(defn most-frequent-k-mers 
  "Returns a seq of k-mers in text appearing at least t times."
  [k t text]
  (->> (k-mers k text)
       (frequencies)
       (filter #(<= t (second %)))
       (map first)))

(defn find-clump
  "Finds k-mers forming (L, t) clumps in text."
  [k L t text]
  (let [windows (partition L 1 text)]
    (->> windows 
         (map #(most-frequent-k-mers k t %))
         (map set)
         (apply clojure.set/union))))

I think you should start from here.