chase-lambert

(ns score-word-game
  (:require [clojure.test :refer [deftest is]]))

(defn score-word-game [word-list letter-scores]
  (let [word-score (fn [word]
                    (let [letter-score (reduce + (map letter-scores word))]
                      (* (count word) letter-score)))]
    (apply max-key word-score word-list)))

(deftest score-word-game-test

chase-lambert

(ns separate-and-sort
  (:require [clojure.test :refer [deftest is]]))

(defn separate-and-sort [nums]
  (let [nums (sort (remove zero? nums))]
    (reduce (fn [[evens odds] n]
              (if (even? n)
                [(conj evens n) odds]
                [evens (conj odds n)]))
            [[] []]

chase-lambert

(ns min-subs
  (:require [clojure.test :refer [deftest is]]))

(defn min-subs [nums k]
  (let [subarrays (partition k 1 nums)]
    (reduce (fn [min-array next-array]
              (let [[sum-a sum-b]
                    (map (partial apply +) [min-array next-array])]
                (if (< sum-a sum-b)
                  min-array

chase-lambert

(ns faulty-keeb
  (:require [clojure.test :refer [deftest is]]))

(defn faulty-keeb [s]
  (let [vowels #{\a \e \i \o \u \A \E \I \O \U}
        vowel? (fn [c] (vowels c))]
    (reduce (fn [acc c]
              (if (vowel? c)
                (apply str (reverse acc))
                (str acc c)))

chase-lambert

(ns maximum-profit
  (:require [clojure.test :refer [deftest is]))
  
(defn maximum-profit [prices]
  (loop [n (first prices)
         xs (rest prices)
         acc []]
    (if (seq xs)
      (let [max-profit (apply max
                              (map #(- % n) xs))]

chase-lambert

(ns explode-string
  (:require 
   [clojure.string :as string]
   [clojure.test   :refer [deftest is]))

(defn explode-string [s]
  (->> (group-by identity s)
       vals
       (map (partial apply str))
       (remove string/blank?)

chase-lambert

pub fn binary_pal(n: i32) -> bool {
    let s = format!("{n:b}");

    s == s.chars().rev().collect::<String>()
}

#[test]
fn binary_pal_test() {
    assert_eq!(binary_pal(5), true);
    assert_eq!(binary_pal(10), false);

chase-lambert

(ns roll-dice
  (:require 
   [clojure.string :as string]
   [clojure.test :refer [deftest is]))

(defn roll-dice [dice-str]
  (let [roll-die (fn [die-size]
                   (inc (rand-int die-size)))]
    (->> (string/split dice-str #"\+") ;; ["1d8" "2d10"]
         (map #(string/split % #"d"))  ;; (["1" "8"] ["2" "10"])

chase-lambert

(ns scramble
  (:require [clojure.string :as string]))

(defn scramble-word [w]
  (let [middle-letters (subs w 1 (dec (count w)))
        mixed-middle   (shuffle (seq middle-letters))]
    (str (first w) (apply str mixed-middle) (last w))))

(defn scramble [s]
  (string/join " "

chase-lambert

#!/usr/bin/env bb

;; You need to have an OpenAI API key and set it like:
;; export OPENAI_API_KEY=<your key> in your .bashrc
;;
;; Make sure you have babashka installed
;; https://github.com/babashka/babashka#installation
;;
;; One way to run this is to install bbin
;; https://github.com/babashka/bbin