miner

(ns sudoku
  (:refer-clojure :exclude [==])
  (:use clojure.core.logic))

(defn get-square [rows x y]
  (for [x (range x (+ x 3))
        y (range y (+ y 3))]
    (get-in rows [x y])))

(defn init [vars hints]

miner

(ns miner.roman
  (:require [clojure.test :refer :all]))

;; inspired by 
;; http://www.jayway.com/2012/08/04/a-decimal-to-roman-numeral-converter-in-just-a-few-lines/

(def roman-map {1000 "M" 900 "CM" 500 "D" 400 "CD"
                100 "C" 90 "XC" 50 "L" 40 "XL"
                10 "X" 9 "IX" 5 "V" 4 "IV" 1 "I"})

miner

(ns miner.infix)

;; Inspired by the excellent book "The Joy of Clojure".
;; http://fogus.me/fun/unfix/infix-src.html
;; 
;; Converted to be used as a data-reader by Steve Miner.  The main change is to preserve
;; the prefix forms rather than calculating the result.  Also, the reader gets symbols, not
;; the actual functions.

(def && #(and % %2))

miner

(defn digits [n]
  {:pre [(int? n) (>= n 0)]}
  (loop [digs () remainder n]
    (if (< remainder 10)
      (conj digs remainder)
      (recur (conj digs (rem remainder 10)) (quot remainder 10)))))

(defn digits+rev [n]
  (let [ds (digits n)]
    (concat ds (reverse ds))))

miner

;; map-alt is like the map xform but calls the funtions in an alternating order
;; (f i0) (g i1) (h i2) (f i3) ...
;;
;; In other words, map-alt spreads fn calls across elements, whereas (mapcat (juxt ...)) calls all
;; fns on each element.

(defn map-alt
  ([] (map identity))

  ([f] (map f))

miner

(ns miner.pal
  (:require [criterium.core :as crit]
            [clojure.string :as str]))
            

;; An exercise from Apropos Clojure #18 video cast:
;; https://www.youtube.com/watch?v=elF9BPa0Np4
;;
;; Their solution is something like this...

miner

#!/bin/bash
# launch a clojure plain repl but with options and classpath matching project.clj
# Except when project.clj changes (and on first launch), lein is not called.

if [ ! -f "project.clj" ]; then
  echo "No project.clj"
  exit 1
fi

# stat (mostly) protects against staleness of copied project dir

miner

(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.

miner

Keybase proof

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:

miner

(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)))