Получить все движущиеся k-размерные разделы строки

Question

Я пытаюсь получить все «движущиеся» разделы размером k строки. В принципе, я хочу переместить окно размером k вдоль строки и получить это k-слово.

Вот пример,

к: 3

Входной: ABDEFGH

Выход: ABD, EFG, BDE, FGH, DEF

Моя идея была ходить по входу, отбрасывать голову и перегородку, а затем снова отбрасывать голову из предыдущей (теперь безголовой) последовательности, b ut Я точно не знаю, как это сделать ... Кроме того, может быть, есть лучший способ сделать это? Ниже приведена идея, которую я имел в виду.

(#(partition k input) (collection of s where head was consecutively dropped)) 

Answer 1

Строки в Clojure можно рассматривать как seqs символов, поэтому вы можете разбить их непосредственно. Для того, чтобы получить последовательность перекрывающихся разделов, используйте версию, которая принимает размер и шаг:

user> (partition 3 1 "abcdef") 
((\a \b \c) (\b \c \d) (\c \d \e) (\d \e \f)) 

Чтобы поместить последовательность символов обратно в строку, просто применить str к нему:

user> (apply str '(\a \b \c)) 
"abc" 

К все это вместе:

user> (map (partial apply str) (partition 3 1 "abcdef")) 
("abc" "bcd" "cde" "def") 

Answer 2

(defn moving-partition 
    [input k] 
    (map #(.substring input % (+ k %)) 
     (range (- (count input) (dec k))))) 

Answer 3

Вот реализации partition в d partition-all для строк, возвращая ленивый ряд строк, делая расщепление, используя subs. Если вам нужна высокая производительность при строковых преобразованиях, они будут значительно быстрее (в среднем в 8 раз быстрее, см. Ниже критерии критерия), чем создание char-seqs.

(defn partition-string 
    "Like partition, but splits string using subs and returns a 
    lazy-seq of strings." 
    ([n s] 
    (partition-string n n s)) 
    ([n p s] 
    (lazy-seq 
     (if-not (< (count s) n) 
     (cons 
     (subs s 0 n) 
     (->> (subs s p) 
       (partition-string n p))))))) 

(defn partition-string-all 
    "Like partition-all, but splits string using subs and returns a 
    lazy-seq of strings." 
    ([n s] 
    (partition-string-all n n s)) 
    ([n p s] 
    (let [less (if (< (count s) n) 
        (count s))] 
     (lazy-seq 
     (cons 
     (subs s 0 (or less n)) 
     (if-not less 
      (->> (subs s p) 
       (partition-string-all n p)))))))) 

;; Alex answer: 
;; (let [test-str "abcdefghijklmnopqrstuwxyz"] 
;; (criterium.core/bench 
;; (doall 
;;  (map (partial apply str) (partition 3 1 test-str))))) 
;; WARNING: Final GC required 1.010207840526515 % of runtime 
;; Evaluation count : 773220 in 60 samples of 12887 calls. 
;; Execution time mean : 79.900801 µs 
;; Execution time std-deviation : 2.008823 µs 
;; Execution time lower quantile : 77.725304 µs (2.5%) 
;; Execution time upper quantile : 83.888349 µs (97.5%) 
;; Overhead used : 17.786101 ns 

;; Found 3 outliers in 60 samples (5.0000 %) 
;; low-severe 3 (5.0000 %) 
;; Variance from outliers : 12.5585 % Variance is moderately inflated by outliers 

;; KobbyPemson answer: 
;; (let [test-str "abcdefghijklmnopqrstuwxyz"] 
;; (criterium.core/bench 
;; (doall 
;;  (moving-partition test-str 3)))) 
;; WARNING: Final GC required 1.674347646128195 % of runtime 
;; Evaluation count : 386820 in 60 samples of 6447 calls. 
;; Execution time mean : 161.928479 µs 
;; Execution time std-deviation : 8.362590 µs 
;; Execution time lower quantile : 154.707888 µs (2.5%) 
;; Execution time upper quantile : 184.095816 µs (97.5%) 
;; Overhead used : 17.786101 ns 

;; Found 3 outliers in 60 samples (5.0000 %) 
;; low-severe  2 (3.3333 %) 
;; low-mild   1 (1.6667 %) 
;; Variance from outliers : 36.8985 % Variance is moderately inflated by outliers 

;; This answer 
;; (let [test-str "abcdefghijklmnopqrstuwxyz"] 
;; (criterium.core/bench 
;; (doall 
;;  (partition-string 3 1 test-str)))) 
;; WARNING: Final GC required 1.317098148979236 % of runtime 
;; Evaluation count : 5706000 in 60 samples of 95100 calls. 
;; Execution time mean : 10.480174 µs 
;; Execution time std-deviation : 240.957206 ns 
;; Execution time lower quantile : 10.234580 µs (2.5%) 
;; Execution time upper quantile : 11.075740 µs (97.5%) 
;; Overhead used : 17.786101 ns 

;; Found 3 outliers in 60 samples (5.0000 %) 
;; low-severe 3 (5.0000 %) 
;; Variance from outliers : 10.9961 % Variance is moderately inflated by outliers