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

nasser

(ns user
  (:use arcadia.core)
  (:import [UnityEngine
            Vector3
            Time
            Gizmos
            Color
            Debug
            Plane
            Mathf]))

nasser

(defn tri-strip
  ([size] (tri-strip 0 size))
  ([start size]
   (->> (range start (+ start size))
        (partition 4 1)
        (map (fn [[a b c d]] [a b c
                              c b d]))
        flatten)))

(defn tri-fan

nasser

#!/usr/bin/ruby
puts open("db/#{ARGV.first}").read

timsgardner

(defn fuzzy-finder-fn [name-fn resource-fn]
  (fn [string-or-regex]
    (let [f (if (instance? System.Text.RegularExpressions.Regex string-or-regex)
              #(re-find string-or-regex (name-fn %))
              (let [^String s string-or-regex]
                #(let [^String n (name-fn %)]
                   (.Contains n s))))]
      (filter f (resource-fn)))))

;; example:

nasser

(defmacro chance [& body]
  (let [r (gensym "chance")
        pairs (sort-by first (partition 2 body))
        odds (map first pairs)
        exprs (map last pairs)
        sum (apply + odds)
        fracs (map #(float (/ % sum)) odds)
        frac-pairs (partition 2 (interleave fracs exprs))]
    `(let [~r (rand)]
       (cond

nasser

(ns curve)

(defn power [x a]
  (Math/Pow x a))

(defmacro v* [a b] `(Vector2/op_Multiply ~a ~b))
(defmacro v+
  ([a] a)
  ([a b] `(Vector2/op_Addition ~a ~b))
  ([a b & vs] (reduce

nasser

(ns sliders)

(defmacro slider [l]
  (let [dashes (vec (repeat l "-"))]
    `(do ~@(map (fn [i]
                  `(defn
                     ~(symbol (clojure.string/join (assoc dashes i "*")))
                     []
                     ~(/ i (- l 1))))
                (range l)))))

nasser

Rejoyce

Rejoyce is a purely functional, persistent, concatenative language

It maintains an In queue and an Out stackThe In queue represents code yet to be executed, and is initially populated with the program to run

The Out stack represents data to be manipulated, and is initially empty

The two record the complete state of execution at any time

To evaluate a token, Rejoyce returns a completely new In and Out stack

alandipert

;; Copyright (c) Alan Dipert. All rights reserved.
;; The use and distribution terms for this software are covered by the
;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;; By using this software in any fashion, you are agreeing to be bound by
;; the terms of this license.
;; You must not remove this notice, or any other, from this software.

(defn paths
  "Enumerate paths into a nested map."
  ([root]