chase-lambert

(ns area
  (:require
    [clojure.math   :as math]
    [criterium.core :as crit]))

(defmulti area :shape)

(defmethod area :square [{:keys [side]}]
  (* side side))

chase-lambert

(ns repeated-groups
  (:require [clojure.test :refer [deftest is]))
  
(defn repeated-groups [nums]
  (->> nums
       (partition-by identity)
       (filter #(> (count %) 1))
       (into [])))
       
;; Using transducers instead which gives 

chase-lambert

(ns num-balanced
  (:require [clojure.test :refer [deftest is]))

(defn paren-as-num [c]
  (case c
    \(  1
    \) -1
    0))

(defn num-balanced [s-of-parens]

chase-lambert

(ns generate-arrays
  (:require [clojure.test :refer [deftest is]))

(defn generate-arrays [n]
  (mapv #(vec (range 1 (inc %))) (range 1 (inc n))))

(deftest generate-arrays-test
  (is (= (generate-arrays 4) [[1] [1 2] [1 2 3] [1 2 3 4]]))
  (is (= (generate-arrays 1) [[1]])))

chase-lambert

pub fn generate_arrays(n: i32) -> Vec<Vec<i32>> {
    (1..=n).map(|x| (1..=x).collect()).collect()
}

#[test]
fn generate_arrays_test() {
    assert_eq!(
        generate_arrays(4),
        vec![vec![1], vec![1, 2], vec![1, 2, 3], vec![1, 2, 3, 4]]
    );

chase-lambert

(ns print-ascii)

(defn print-ascii []                                                                         
  (doseq [i (range 0x20 0x7F)]                                                                      
    (print (char i))))
    
;; If you want to print in sections exactly as shown in the prompt
(defn print-ascii-sections []                                                                    
  (doseq [section (partition-all 16 (range 0x20 0x7F))]                                                   
    (println (apply str (map char section)))))

chase-lambert

(ns pass-doors
  (:require [clojure.test :refer [deftest is]))

(defn pass-doors [n number-of-passes]                                                            
  (let [initial (repeat n 1)                                                                     
        passes  (range number-of-passes)                                                         
        toggle-door     (fn [d] (if (zero? d) 1 0))                                                 
        create-sections (fn [doors pass]                                                          
                          (map vec (partition-all (inc pass) doors)))                             
        toggle-section  (fn [section pass]                                                        

chase-lambert

(ns truncate
  (:require [clojure.test :refer [deftest is]))

(defn truncate [s n]                                                                             
  (let [tokens (re-seq #"\W+|_|[a-zA-Z]+" s)                                                     
        word?  #(re-find #"\w+" %)                                                               
        truncate-w (fn [token]                                                                   
                     (if (and (word? token)                                                      
                              (> (count token) n))                                               
                       (subs token 0 n)                                                          

chase-lambert

(ns fib-like
  (:require [clojure.test :refer [deftest is]]))
  
(defn fibber [a b]                                                                               
  (lazy-seq                                                                                      
    (cons a (fibber b (+ a b)))))                                                                
                                                                                                 
(defn fib-like [a b n]                                                                           
  (take n                                                                                        
        (fibber a b)))                                                    

chase-lambert

(ns calculate-gpa
  (:require [clojure.test :refer [deftest is]]))

(def grade->points                                                                               
  {:A  4                                                                                         
   :A- 3.7                                                                                       
   :B+ 3.3                                                                                       
   :B  3                                                                                         
   :B- 2.7                                                                                       
   :C+ 2.3