Алексей Золотыx, домашнее задание №2

otus-02/src/otus_02/homework/common_child.clj

@@ -1,6 +1,5 @@
 (ns otus-02.homework.common-child)
 
-
 ;; Строка называется потомком другой строки,
 ;; если она может быть образована путем удаления 0 или более символов из другой строки.
 ;; Буквы нельзя переставлять.
@@ -15,8 +14,33 @@
 
 ;; Еще пример HARRY и SALLY. Ответ будет - 2, так как общий элемент у них AY
 
-
-(defn common-child-length [first-string second-string])
+(defn create-matrix [x y]
+  (vec (repeat y (vec (repeat x 0)))))
+
+(defn get-value-setter [first-string second-string]
+  (fn [i j matrix]
+    (if (= (get first-string (dec i))
+           (get second-string (dec j)))
+      (+ (get-in matrix [(dec j) (dec i)] 0) 1)
+      (max
+       (get-in matrix [(dec j) i], 0)
+       (get-in matrix [j (dec i)] 0)))))
+
+(defn visit [matrix x y setter]
+  (loop [i 1 j 1 matrix matrix]
+    (if (<= j y)
+      (if (<= i x)
+        (recur (inc i) j (assoc-in matrix [j i] (setter i j matrix)))
+        (recur 1 (inc j) matrix))
+      matrix)))
+
+(defn common-child-length [first-string second-string]
+  (let [x (count first-string)
+        y (count second-string)
+        matrix (create-matrix (inc x) (inc y))
+        setter (get-value-setter first-string second-string)]
+
+    (get-in (visit matrix x y setter) [y x])))
 
 
 

otus-02/src/otus_02/homework/palindrome.clj

@@ -1,6 +1,17 @@
 (ns otus-02.homework.palindrome
   (:require [clojure.string :as string]))
 
+(defn clean [test-string]
+  (-> test-string
+      (string/trim)
+      (string/lower-case)
+      (string/replace #"[\W]{1,}", "")))
+
+(defn is-palindrome [test-string]
+  (let [clean-string (clean test-string)]
+    (=
+     clean-string
+     (string/reverse clean-string))))
+
 
-(defn is-palindrome [test-string])
 

otus-02/src/otus_02/homework/pangram.clj

@@ -1,6 +1,14 @@
 (ns otus-02.homework.pangram
   (:require [clojure.string :as string]))
 
+(def alphabet "abcdefghijklmnopqrstuvwxyz")
 
-(defn is-pangram [test-string])
+(defn is-pangram [test-string]
+
+  (= alphabet
+     (-> test-string
+         (string/lower-case)
+         (string/replace #"[\W]{1,}" "")
+         (set)
+         (string/join))))
 

otus-02/src/otus_02/homework/square_code.clj

@@ -1,56 +1,48 @@
-(ns otus-02.homework.square-code)
+(ns otus-02.homework.square-code
+  (:require [clojure.math :as math]
+            [clojure.string :as str]))
+
+(defn- pad-right [len val col]
+  (take len (concat col (repeat val))))
+
+(defn- get-col-width [input-string]
+  (-> input-string
+      (count)
+      (math/sqrt)
+      (math/ceil)
+      (int)))
+
+(defn- prepare-str [input]
+  (-> input
+      (str/replace #"[\W]{1,}" "")
+      (str/lower-case)))
+
+(defn- str->matrix [input]
+  (let [len (get-col-width input)]
+    (->> input
+         (partition-all len)
+         (map (fn [lst] (pad-right len " " lst))))))
+
+(defn encode-string [input]
+  (->> input
+       (prepare-str)
+       (str->matrix)
+       (apply mapv str)
+       (str/join " ")))
+
+(defn decode-string [ciphertext]
+  (let [normalized (str/replace ciphertext #"([\w]{1,})([\W]{1,1})" "$1")
+        length (count normalized)
+        side (Math/sqrt length)
+        rows (Math/floor side)
+        cols (Math/ceil side)]
+    (str/join
+     (apply concat (for [i (range rows)]
+                     (for [j (range cols)]
+                       (let [value
+                             (get normalized
+                                  (int (+ (* j rows) i))
+                                  "")]
+                         (when-not (= value \space)
+                           value))))))))
 
-;; Реализовать классический метод составления секретных сообщений, называемый `square code`.
-;; Выведите закодированную версию полученного текста.
-
-;; Во-первых, текст нормализуется: из текста удаляются пробелы и знаки препинания,
-;; также текст переводится в нижний регистр.
-;; Затем нормализованные символы разбиваются на строки.
-;; Эти строки можно рассматривать как образующие прямоугольник при печати их друг под другом.
-
-;; Например,
-"If man was meant to stay on the ground, god would have given us roots."
-;; нормализуется в строку:
-"ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots"
-
-;; Разбиваем текст в виде прямоугольника.
-;; Размер прямоугольника (rows, cols) должен определяться длиной сообщения,
-;; так что c >= r и c - r <= 1, где c — количество столбцов, а r — количество строк.
-;; Наш нормализованный текст имеет длину 54 символа
-;; и представляет собой прямоугольник с c = 8 и r = 7:
-"ifmanwas"
-"meanttos"
-"tayonthe"
-"groundgo"
-"dwouldha"
-"vegivenu"
-"sroots  "
-
-;; Закодированное сообщение получается путем чтения столбцов слева направо.
-;; Сообщение выше закодировано как:
-"imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau"
-
-;; Полученный закодированный текст разбиваем кусками, которые заполняют идеальные прямоугольники (r X c),
-;; с кусочками c длины r, разделенными пробелами.
-;; Для фраз, которые на n символов меньше идеального прямоугольника,
-;; дополните каждый из последних n фрагментов одним пробелом в конце.
-"imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau "
-
-;; Обратите внимание, что если бы мы сложили их,
-;; мы могли бы визуально декодировать зашифрованный текст обратно в исходное сообщение:
-
-"imtgdvs"
-"fearwer"
-"mayoogo"
-"anouuio"
-"ntnnlvt"
-"wttddes"
-"aohghn "
-"sseoau "
-
-
-
-(defn encode-string [input])
-
-
-(defn decode-string [input])

otus-02/test/otus_02/homework/fizzbuzz.clj

@@ -1,16 +1,23 @@
 (ns otus-02.homework.fizzbuzz
   (:require
-   [clojure.test :refer :all]))
+   [clojure.test :refer :all]
+   [clojure.math :as math]))
 
+; "Создайте программу, которая выводит числа от 1 до n.
+  ;  - Если число делится на 3, выведите 'Fizz';
+  ;  - если число делится на 5, выведите 'Buzz';
+  ;  - если число делится и на 3 и на 5, выведите 'FizzBuzz'."
+  ; "implement me"
 
 (defn fizz-buzz [n]
-  "Создайте программу, которая выводит числа от 1 до n.
-   - Если число делится на 3, выведите 'Fizz';
-   - если число делится на 5, выведите 'Buzz';
-   - если число делится и на 3 и на 5, выведите 'FizzBuzz'."
-  "implement me")
-
+  (let [result
+        (cond
+          (= (rem n 3) 0) "Fizz"
+          (= (rem n 5) 0) "Buzz"
+          :else "FizzBuzz")]
+    (println result)
+    result))
 
 (deftest fizz-buzz-test
   (is (= (fizz-buzz 10)
-         '(1 2 "Fizz" 4 "Buzz" "Fizz" 7 8 "Fizz" "Buzz"))))
+         "Buzz")))