ponzao

;; without numbers
(def fizzbuzz
  (let [fizz (cycle [nil nil "fizz"])
        buzz (cycle [nil nil nil nil "buzz"])]
    (remove empty? (map str fizz buzz))))

;; with numbers
(defn fizzbuzz
  [n]
  (let [xs (range 1 (inc n))

ponzao

(ns core
  (:use quil.core))

(defn tick
  [state]
  (let [neighbors (fn [x y]
                    (for [xinc (range -1 (inc 1))
                          yinc (range -1 (inc 1)) :when (not (= 0 xinc yinc))]
                      [(+ x xinc) (+ y yinc)]))
        map-matrix (fn [f matrix]

ponzao

let rec cycle xs =
  Seq.concat (Seq.initInfinite (fun _ -> xs))
 

ponzao

(use '[clojure.string :only (join)])


(defn coder
  [dictionary]
  (let [mnemonics {\2 "ABC" \3 "DEF" \4 "GHI" \5 "JKL", 
                   \6 "MNO" \7 "PQRS" \8 "TUV" \9 "WXYZ"}
        char-code (into {} (mapcat (fn [[n cs]]
                                     (map #(vector % n) cs))
                                   mnemonics))

ponzao

(defn solve
  [grid]
  (remove nil?
          (run* [q]
            (macro/symbol-macrolet [_ (lvar)]
              (== q grid)
              (conde
                ((== grid [[q _ _]
                           [_ q _]
                           [_ _ q]]))

ponzao

(defn map-matrix
  [f colls]
  (vec (map-indexed (fn [y row]
                      (vec (map-indexed (fn [x value]
                                          (f value x y))
                                        row)))
                    colls)))

ponzao

(ns sudoku
  (:require [clojure.set :as set]))

(defn row-values
  [board [row _]]
  (set (get board row)))

(defn- transpose
  [matrix]
  (vec (apply map vector matrix)))

ponzao

let positions x (arr: 'a []) =
  let n = arr.Length - 1
  let idxs = [|0..n|] 
  Array.zip idxs arr
  |> Array.filter (fun (_, v) -> v = x)
  |> Array.map (fun (idx, _) -> idx)

positions 'b' [|'a';'b';'a';'a';'b'|]
// [|1; 4|]

ponzao

(fn best-hand
  [hand]
  (let [ranks (map second hand)
        suits (map first hand)
        rank-freqs (sort (vals (frequencies ranks)))]
    (letfn [(flush? [hand]
              (apply = suits))
            (straight? [hand]
              (let [straight-hands (set (map set (partition 5 1 [\A \2 \3 \4 \5
                                                                 \6 \7 \8 \9 \T

ponzao

(def vowels
  #{\a \e \i \o \u})

(defn count-vowels
  [s]
  (count (keep vowels (.toLowerCase s))))