I hereby claim:
- I am miner on github.
- I am miner (https://keybase.io/miner) on keybase.
- I have a public key whose fingerprint is DB15 4E49 B5BD BE5A 10B4 4437 6A9B 8B0A 4D6A 8900
To claim this, I am signing this object:
#!/bin/bash | |
# my git difftool, calls FileMerge with project as -merge target | |
# better than using opendiff | |
# | |
# cd to your project dir and and run difftool like this: | |
# git difftool -d -x gdiff | |
# find top level of git project | |
dir=$PWD | |
until [ -e "$dir/.git" ]; do |
;;; http://johnj.com/from-elegance-to-speed.html | |
;;; | |
;;; The author of the above blog post says that his `smt-8` was slow so he re-wrote it in | |
;;; Common Lisp and got nearly 300x improvement. I wrote some pure Clojure variations | |
;;; showing much improved performance over the original. | |
;;; | |
;;; Criterium for benchmarking: https://github.com/hugoduncan/criterium/ | |
(ns miner.smt | |
(:require [criterium.core :as cc])) |
;; http://rosettacode.org/wiki/Four_bit_adder | |
(ns miner.fourbit) | |
;; a bit is represented as a boolean (true/false) | |
;; a word is a big-endian vector of bits [true false true true] = 11 | |
;; maybe little endian is more convenient??? | |
(defn bvec |
;; inspired by https://twitter.com/puredanger/status/241282082268143619 | |
;; reduce-kv is faster than destructuring with maps | |
;; use (get m k) instead of (k m) to be safe with non-keyword keys | |
(defn sub= | |
"Like = for most things, but maps compare recursively by only the keys in a, so it returns true | |
if a is a 'submap' of b." | |
[a b] | |
(if (and (map? a) (map? b)) |
;;; 01/14/14 16:18 by miner -- Steve Miner revised this code to be more idiomatic Clojure. | |
;;; | |
; Short sidebar: Clojure has a special form for the efficient compilation of tail recursion. | |
; Something like this would work as a factorial function: | |
(defn fact2 [n] | |
(loop [n n acc 1] | |
(if (zero? n) acc (recur (dec n) (* n acc))))) | |
; We're not going to discuss `recur` any further as we're imagining a language that doesn't |
;; I posted an earlier version on my blog: | |
;; http://fnclojure.wordpress.com/2012/08/06/roman-numerals-in-clojure/ | |
;; This version is faster and more readable. | |
(defn range-down | |
"Returns a seq of integers from HIGH (exclusive) down to LOW (inclusive). | |
LOW defaults to 0. STEP is a positve decrement, defaults to 1. Like | |
`(reverse (range low high step))' but a bit faster." | |
([high] (range (dec high) -1 -1)) |
(ns miner.lucky | |
(:require [clojure.data.avl :as avl])) | |
;; http://en.wikipedia.org/wiki/Lucky_number | |
(defn lucky-avl | |
([max] (lucky-avl 1 (apply avl/sorted-set (range 1 max 2)))) | |
([i avl] | |
(let [n (nth avl i nil)] | |
(if (and n (<= n (count avl))) |
I hereby claim:
To claim this, I am signing this object:
(ns miner.dijkstra-primes) | |
;; ---------------------------------------------------------------------- | |
;; http://heinrichhartmann.com/2016/04/03/Dijkstra's-Prime-Number-Algorithm.html | |
;; https://github.com/HeinrichHartmann/DijkstraPrimes/blob/master/Primes.lua | |
;; Converted to Clojure by SEM. Note that there are lots of shadowing and recursive calls in | |
;; the Clojure code to avoid the mutation in the original code. The Clojure loops are a bit | |
;; ugly. Not sure if this is the best way to do things. However, the performance is pretty | |
;; good. |
(ns miner.bowling) | |
;; http://codingdojo.org/cgi-bin/index.pl?KataBowling | |
;; https://www.javacodegeeks.com/2016/05/bowling-kata-clojure-f-scala.html | |
;; game is a string, encoding balls rolled | |
;; X for strike | |
;; / for spare | |
;; - for a miss or gutter ball | |
;; 1-9 for that many pins |