Nathan Donolli ndonolli

## binary-search.clj
(defn binary-search [target coll]
  (loop [tree coll]
    (let [idx (int (/ (count tree) 2))
          node (nth tree idx)]
      (cond
        (= target node) true
        (= 1 (count tree)) false
        (< target node) (recur (subvec tree 0 idx))
        (> target node) (recur (subvec tree idx (count tree)))))))

## factors-string.clj
(defn factors->string [factors]
  (->> (frequencies factors)
       (map (fn [[n exp]]
              (if (= 1 exp) (str n) (str n "^" exp))))
       (interpose " x ")
       (cons (str (apply * factors) " = "))
       (apply str)))

## uniques.clj
(defn uniques [coll]
  (let [freqs (frequencies coll)]
    (filter #(= 1 (get freqs %)) coll)))

## contraindications.clj
(defn contraindications [meds pairs]
  (let [meds-set (set (map :rxNorm meds))
        contains-pair? (partial every? meds-set)]
    (->> pairs (filter contains-pair?) not-empty)))

## sudoku-validator.clj
(defn valid-set? [s]
  (= (sort s) (range 1 10)))

(defn rotate [matrix]
  (apply map list matrix))

(defn rows [matrix] matrix)

(defn cols [matrix] (rotate matrix))

## tic-tac-toe.clj
(defn check-path-win
  "Checks a path for a win"
  [s]
  (if (apply = s)
    (first s)
    nil))

(defn check-win-direction
  "Checks a sequence of paths in a particular direction for a win"
  [dir-seq]

## anagrams.clj
; Write a function to determine if two words are anagrams.
(defn is-anagram [target src]
  (if (string? target)
    (if (= target src)
      false
      (is-anagram (frequencies target) src))
    (= target (frequencies src))))

; Given a dictionary of words (such as this one), find all of the anagrams for a target word.
; Assumption: dictionary of words is a collection

## remove-at.clj
(defn remove-at [n xs]
  (let [removed (flatten (conj (drop (+ n 1) xs)(take n xs)))]
    (if (vector? xs)
      (vec removed)
      removed)))

## index.html
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>JS Bin</title>
</head>
<body>

<script id="jsbin-javascript">

## index.html
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>JS Bin</title>
</head>
<body>

<script id="jsbin-javascript">
	(defn binary-search [target coll]
	(loop [tree coll]
	(let [idx (int (/ (count tree) 2))
	node (nth tree idx)]
	(cond
	(= target node) true
	(= 1 (count tree)) false
	(< target node) (recur (subvec tree 0 idx))
	(> target node) (recur (subvec tree idx (count tree)))))))
	(defn factors->string [factors]
	(->> (frequencies factors)
	(map (fn [[n exp]]
	(if (= 1 exp) (str n) (str n "^" exp))))
	(interpose " x ")
	(cons (str (apply * factors) " = "))
	(apply str)))
	(defn uniques [coll]
	(let [freqs (frequencies coll)]
	(filter #(= 1 (get freqs %)) coll)))
	(defn contraindications [meds pairs]
	(let [meds-set (set (map :rxNorm meds))
	contains-pair? (partial every? meds-set)]
	(->> pairs (filter contains-pair?) not-empty)))
	(defn valid-set? [s]
	(= (sort s) (range 1 10)))

	(defn rotate [matrix]
	(apply map list matrix))

	(defn rows [matrix] matrix)

	(defn cols [matrix] (rotate matrix))
	(defn check-path-win
	"Checks a path for a win"
	[s]
	(if (apply = s)
	(first s)
	nil))

	(defn check-win-direction
	"Checks a sequence of paths in a particular direction for a win"
	[dir-seq]
	; Write a function to determine if two words are anagrams.
	(defn is-anagram [target src]
	(if (string? target)
	(if (= target src)
	false
	(is-anagram (frequencies target) src))
	(= target (frequencies src))))

	; Given a dictionary of words (such as this one), find all of the anagrams for a target word.
	; Assumption: dictionary of words is a collection
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width">
	<title>JS Bin</title>
	</head>
	<body>

	<script id="jsbin-javascript">