ericnormand/00 Symmetry.md

## 00 Symmetry.md

      
    Raw
  

              00 Symmetry.md
            
          
    Symmetry
We need to classify patterns into four different categories:

horizontally symmetrical
vertically symmetrical
perfect (both vertically and horizontally symmetrical)
imperfect (neither vertically nor horizontally symmetrical)

Patterns are two-dimmensional. We will represent them with vectors of vectors. Each inner vector is a row.
Write a function classify that takes a pattern and returns one of :vertical, :horizontal, :perfect, or :imperfect.
Examples
(classify [["a" "b" "a"]
           ["x" "y" "x"]]) ;=> :horizontal
(classify [["a" "b" "c"]]) ;=> :vertical ;; trivially so
(classify [["a" "b" "a"]
           ["y" "X" "y"]
           ["a" "b" "a"]]) ;=> :perfect
UPDATE: I have horizontal and vertical switched accidentally, but I won't change it since people have already submitted.
Thanks to this site for the challenge idea where it is considered Expert level in JavaScript.

  
## Alan Thompson.clj
(ns tst.demo.core
  (:use tupelo.core tupelo.test)
  (:require
    [schema.core :as s]
    [tupelo.array :as tar]))

(def ArrayClass (s/constrained s/Keyword #{:horizontal :vertical :perfect :imperfect}))
(s/defn classify :- ArrayClass
  [edn-data :- [[s/Any]]]
  (let [array      (tar/rows->array edn-data) ; verifies rectangular (non-ragged)
        sym-horiz? (= array (tar/flip-lr array))
        sym-vert?  (= array (tar/flip-ud array))
        result     (cond
                     (and sym-horiz? sym-vert?) :perfect
                     sym-vert? :vertical
                     sym-horiz? :horizontal
                     :else :imperfect)]
    result))

(dotest
  (is= (classify [["a" "b" "a"]
                  ["x" "y" "x"]]) :horizontal)
  (is= (classify [["a" "b" "c"]]) :vertical)
  (is= (classify [["a" "b" "a"]
                  ["y" "X" "y"]
                  ["a" "b" "a"]]) :perfect)
  (is= (classify [["a" "b" "a"]
                  ["y" "X" "y"]
                  ["666" "b" "a"]]) :imperfect))

## Daniel Gaspani.clj
(defn sym-h? [xs]
  (every? #(= % (reverse %)) xs))

(defn sym-v? [xs]
  (if (empty? xs)
    true
    (-> (apply mapv vector xs)
        (sym-h?))))

(defn classify [xs]
  (let [sym-h (sym-h? xs)
        sym-v (sym-v? xs)]
    (cond
      (and sym-h sym-v) :perfect
      sym-h :horizontal
      sym-v :vertical
      :else :imperfect)))

## James Elliott.clj
(defn symmetrical?
  "Checks whether a sequence is equal to its reverse."
  [s]
  (= s (reverse s)))

(defn classify
  [ss]
  (let [horizontal? (every? symmetrical? ss)]
    (if (symmetrical? ss)
      (if horizontal? :perfect :vertical)
      (if horizontal? :horizontal :imperfect))))

## JF Rompre.clj
(ns functional-tv-puzzles.-2020.patterns-378)

;; Solution 1
(defn symmetric? [vovs]
  (let [siz (count vovs)
        mid (quot siz 2)]
    (->> vovs
         (split-at mid)
         ((fn [[front back]]
            [(reverse front), (drop (if (odd? siz) 1 0) back)]))
         (apply map vector)
         (every? #(apply = %)))))

(defn classify [vovs]
  (let [rows vovs
        horiz? (symmetric? rows)
        cols (when (seq vovs) (apply mapv vector vovs))
        vert? (symmetric? cols)]
    (cond
      (not cols) :perfect
      (and horiz? vert?) :perfect
      horiz? :horizontal
      vert? :vertical
      :else :imperfect)))

;; Solution  2
(defn ->1d [row col rowsiz]
  (-> row (* rowsiz) (+ col)))

(defn mirrors [i rowsiz numrows]
  (let [r (quot i rowsiz)
        c (rem i rowsiz)
        r' (- numrows r 1)
        c' (- rowsiz c 1)]
    [(->1d r' c rowsiz) (->1d r c' rowsiz)]))

(defn classify-2 [vovs]
  (let [ {:keys [horiz? vert?] :as result}
        (transduce (comp cat (map-indexed vector))
                   (completing
                    (fn [{:keys [horiz? vert? peers rowsiz numrows] :as acc}
                         [i v :as iv]]

                      (let [[row-pidx col-pidx] (mirrors i rowsiz numrows)
                            row-peer (get peers row-pidx)
                            col-peer (get peers col-pidx)
                            horiz?' (when horiz? (if row-peer (= v row-peer) true))
                            vert?' (when vert? (if col-peer (= v col-peer) true))]

                        (if
                            (= [false false] [horiz?' vert?']) (reduced :imperfect)
                            (-> acc
                                (assoc-in [:peers i] v)
                                (assoc :horiz? horiz?')
                                (assoc :vert? vert?'))))))

                   {:horiz? true :vert? true
                    :rowsiz (count (first vovs))
                    :numrows (count vovs)}

                   vovs)]
    (cond
      (and horiz? vert?) :perfect
      horiz? :horizontal
      vert? :vertical
      :else :imperfect)))


## Jonathan Chen.clj
(defn horizontal-symmetry? [row]
  (= row
     (reverse row)))

(defn fully-horizontal? [matrix]
  (as-> matrix $
    (map horizontal-symmetry? $)
    (set $)
    (contains? $ false)
    (not $)))

(defn vertical-symmetry? [matrix]
  (= matrix
     (reverse matrix)))

(defn classify [matrix]
  (let [vertical?   (vertical-symmetry? matrix)
        horizontal? (fully-horizontal? matrix)]
    (cond
      (and vertical? horizontal?) :perfect
      vertical?                   :vertical
      horizontal?                 :horizontal
      :else                       :imperfect)))

## Juan Monetta.clj
(defn classify [mat]
  (let [symetric-seq? #(= % (reverse %))
        transpose #(apply map vector %)
        h-symetric? (every? symetric-seq? mat)
        v-symetric? (every? symetric-seq? (transpose mat))]
    (cond
      (and h-symetric? v-symetric?) :perfect
      h-symetric?                   :horizontal
      v-symetric?                   :vertical
      :else                         :imperfect)))

## Mark Champine.clj
(defn classify [mx]
  (let [sym1? #(= (seq %) (reverse %))
        allsym? #(every? true? (map sym1? %))
        hsym? (allsym? mx)
        vsym? (allsym? (apply map vector mx))
        perf? (and hsym? vsym?)]
    (cond
      perf? :perfect
      hsym? :horizontal
      vsym? :vertical
      :else :imperfect)))

## ninjure.clj
(defn classify [rows]
  (let [symmetrical? (fn [rows] (every? #(= % (reverse %)) rows))
        columns (apply map vector rows)]
    (case [(symmetrical? rows) (symmetrical? columns)]
      [true  true]  :perfect
      [true  false] :horizontal
      [false true ] :vertical
      :imperfect)))

## Paul A Roush.clj
(defn rows [grid]
  grid)

(defn cols [grid]
  (loop [res  []
         rows grid]
    (if (empty? (first rows))
      res
      (recur (conj res (map first rows))
             (map rest  rows)))))

(defn classify [grid]
  (let [symmetric? (fn [vals] (= vals (reverse vals)))
        h-sym? (every? symmetric? (rows grid))
        v-sym? (every? symmetric? (cols grid))]
    (cond
      (and h-sym? v-sym?) :perfect
      h-sym?              :horizontal
      v-sym?              :vertical
      :else               :imperfect)))

## Steffan Westcott.clj
(defn symmetrical? [xs]
  (= xs (reverse xs)))

(defn classify [rows]
  (let [vertical? (symmetrical? rows)
        horizontal? (every? symmetrical? rows)]
    (cond
      (and vertical? horizontal?) :perfect
      vertical? :vertical
      horizontal? :horizontal
      :else :imperfect)))
	(ns tst.demo.core
	(:use tupelo.core tupelo.test)
	(:require
	[schema.core :as s]
	[tupelo.array :as tar]))

	(def ArrayClass (s/constrained s/Keyword #{:horizontal :vertical :perfect :imperfect}))
	(s/defn classify :- ArrayClass
	[edn-data :- [[s/Any]]]
	(let [array (tar/rows->array edn-data) ; verifies rectangular (non-ragged)
	sym-horiz? (= array (tar/flip-lr array))
	sym-vert? (= array (tar/flip-ud array))
	result (cond
	(and sym-horiz? sym-vert?) :perfect
	sym-vert? :vertical
	sym-horiz? :horizontal
	:else :imperfect)]
	result))

	(dotest
	(is= (classify [["a" "b" "a"]
	["x" "y" "x"]]) :horizontal)
	(is= (classify [["a" "b" "c"]]) :vertical)
	(is= (classify [["a" "b" "a"]
	["y" "X" "y"]
	["a" "b" "a"]]) :perfect)
	(is= (classify [["a" "b" "a"]
	["y" "X" "y"]
	["666" "b" "a"]]) :imperfect))
	(defn sym-h? [xs]
	(every? #(= % (reverse %)) xs))

	(defn sym-v? [xs]
	(if (empty? xs)
	true
	(-> (apply mapv vector xs)
	(sym-h?))))

	(defn classify [xs]
	(let [sym-h (sym-h? xs)
	sym-v (sym-v? xs)]
	(cond
	(and sym-h sym-v) :perfect
	sym-h :horizontal
	sym-v :vertical
	:else :imperfect)))
	(defn symmetrical?
	"Checks whether a sequence is equal to its reverse."
	[s]
	(= s (reverse s)))

	(defn classify
	[ss]
	(let [horizontal? (every? symmetrical? ss)]
	(if (symmetrical? ss)
	(if horizontal? :perfect :vertical)
	(if horizontal? :horizontal :imperfect))))
	(ns functional-tv-puzzles.-2020.patterns-378)

	;; Solution 1
	(defn symmetric? [vovs]
	(let [siz (count vovs)
	mid (quot siz 2)]
	(->> vovs
	(split-at mid)
	((fn [[front back]]
	[(reverse front), (drop (if (odd? siz) 1 0) back)]))
	(apply map vector)
	(every? #(apply = %)))))

	(defn classify [vovs]
	(let [rows vovs
	horiz? (symmetric? rows)
	cols (when (seq vovs) (apply mapv vector vovs))
	vert? (symmetric? cols)]
	(cond
	(not cols) :perfect
	(and horiz? vert?) :perfect
	horiz? :horizontal
	vert? :vertical
	:else :imperfect)))

	;; Solution 2
	(defn ->1d [row col rowsiz]
	(-> row (* rowsiz) (+ col)))

	(defn mirrors [i rowsiz numrows]
	(let [r (quot i rowsiz)
	c (rem i rowsiz)
	r' (- numrows r 1)
	c' (- rowsiz c 1)]
	[(->1d r' c rowsiz) (->1d r c' rowsiz)]))

	(defn classify-2 [vovs]
	(let [ {:keys [horiz? vert?] :as result}
	(transduce (comp cat (map-indexed vector))
	(completing
	(fn [{:keys [horiz? vert? peers rowsiz numrows] :as acc}
	[i v :as iv]]

	(let [[row-pidx col-pidx] (mirrors i rowsiz numrows)
	row-peer (get peers row-pidx)
	col-peer (get peers col-pidx)
	horiz?' (when horiz? (if row-peer (= v row-peer) true))
	vert?' (when vert? (if col-peer (= v col-peer) true))]

	(if
	(= [false false] [horiz?' vert?']) (reduced :imperfect)
	(-> acc
	(assoc-in [:peers i] v)
	(assoc :horiz? horiz?')
	(assoc :vert? vert?'))))))

	{:horiz? true :vert? true
	:rowsiz (count (first vovs))
	:numrows (count vovs)}

	vovs)]
	(cond
	(and horiz? vert?) :perfect
	horiz? :horizontal
	vert? :vertical
	:else :imperfect)))
	(defn horizontal-symmetry? [row]
	(= row
	(reverse row)))

	(defn fully-horizontal? [matrix]
	(as-> matrix $
	(map horizontal-symmetry? $)
	(set $)
	(contains? $ false)
	(not $)))

	(defn vertical-symmetry? [matrix]
	(= matrix
	(reverse matrix)))

	(defn classify [matrix]
	(let [vertical? (vertical-symmetry? matrix)
	horizontal? (fully-horizontal? matrix)]
	(cond
	(and vertical? horizontal?) :perfect
	vertical? :vertical
	horizontal? :horizontal
	:else :imperfect)))
	(defn classify [mat]
	(let [symetric-seq? #(= % (reverse %))
	transpose #(apply map vector %)
	h-symetric? (every? symetric-seq? mat)
	v-symetric? (every? symetric-seq? (transpose mat))]
	(cond
	(and h-symetric? v-symetric?) :perfect
	h-symetric? :horizontal
	v-symetric? :vertical
	:else :imperfect)))
	(defn classify [mx]
	(let [sym1? #(= (seq %) (reverse %))
	allsym? #(every? true? (map sym1? %))
	hsym? (allsym? mx)
	vsym? (allsym? (apply map vector mx))
	perf? (and hsym? vsym?)]
	(cond
	perf? :perfect
	hsym? :horizontal
	vsym? :vertical
	:else :imperfect)))
	(defn classify [rows]
	(let [symmetrical? (fn [rows] (every? #(= % (reverse %)) rows))
	columns (apply map vector rows)]
	(case [(symmetrical? rows) (symmetrical? columns)]
	[true true] :perfect
	[true false] :horizontal
	[false true ] :vertical
	:imperfect)))
	(defn rows [grid]
	grid)

	(defn cols [grid]
	(loop [res []
	rows grid]
	(if (empty? (first rows))
	res
	(recur (conj res (map first rows))
	(map rest rows)))))

	(defn classify [grid]
	(let [symmetric? (fn [vals] (= vals (reverse vals)))
	h-sym? (every? symmetric? (rows grid))
	v-sym? (every? symmetric? (cols grid))]
	(cond
	(and h-sym? v-sym?) :perfect
	h-sym? :horizontal
	v-sym? :vertical
	:else :imperfect)))
	(defn symmetrical? [xs]
	(= xs (reverse xs)))

	(defn classify [rows]
	(let [vertical? (symmetrical? rows)
	horizontal? (every? symmetrical? rows)]
	(cond
	(and vertical? horizontal?) :perfect
	vertical? :vertical
	horizontal? :horizontal
	:else :imperfect)))