martintrojer

import scala.util.parsing.combinator._

class JSON extends JavaTokenParsers {

  def obj: Parser[Map[String, Any]] = "{" ~> repsep(member, ",") <~ "}" ^^ (Map() ++ _)

  def arr: Parser[List[Any]] = "[" ~> repsep(value, ",") <~ "]"

  def member: Parser[(String, Any)] = stringLiteral ~ ":" ~ value ^^
                                      { case name ~ ":" ~ value => (name, value) }

martintrojer

object queens extends App {

  def queens(n: Int): List[List[(Int, Int)]] = {
    def placeQueens(k: Int): List[List[(Int, Int)]] = {
      if (k == 0)
        List(List())
      else for {
        queens <- placeQueens(k - 1)
        col <- 1 to n
        queen = (k, col)

martintrojer

object exprPattern extends App {
  sealed trait Expr
  case class Add(e1: Expr, e2: Expr) extends Expr
  case class Sub(e1: Expr, e2: Expr) extends Expr
  case class Num(n: Int) extends Expr

  def value(e: Expr): Int = e match {
    case Add(e1, e2) => value(e1) + value(e2)
    case Sub(e1, e2) => value(e1) - value(e2)
    case Num(n) => n

martintrojer

object BST extends App{

  case class Tree[T](left: Option[Tree[T]], right: Option[Tree[T]], value: T) {
    def toList(): List[T] = {
      def tol: (Tree[T] => List[T]) = {
        case Tree(Some(l), _, v) => tol(l) ::: List(v)
        case Tree(None, Some(r), v) => v :: tol(r)
        case Tree(None, None, v) => List(v)
      }
      tol(this)

martintrojer

;; [commons-codec "1.7"]

(ns b64uuid
  (:import [java.util UUID]
           [java.nio ByteBuffer]
           [org.apache.commons.codec.binary Base64]))

(defn uuid->b64 [^UUID uuid]
  (let [ba (-> (ByteBuffer/wrap (make-array Byte/TYPE 16))
               (.putLong (.getMostSignificantBits uuid))

martintrojer

;; filter keys and values in json-like nested maps and vectors
(defn filter-map-entries [pred m]
  (loop [acc {}, [[k v] & tail] (if (map? m) (seq m) (map seq m))]
    (if k
      (cond (pred [k k]) (recur (conj acc [k v]) tail)
            (map? v) (let [submap (filter-map-entries pred v)]
                       (if (empty? submap)
                         (recur acc tail)
                         (recur (conj acc [k submap]) tail)))
            (vector? v) (let [ms (->> v (map #(if (coll? %)

martintrojer

(defn size [o]
  (-> o pr-str count))

(defn col-size [c]
  (let [s (if (map? c) (seq c) (map-indexed vector c))]
    (->> s
         (map (fn [[k v]] [k (size v)]))
         (sort-by second)
         reverse)))

martintrojer

(ns pdftstr.core
  (:import [com.snowtide.pdf OutputTarget PDFTextStream]))

(defn get-text [filename]
  (with-open [pdfts (PDFTextStream. filename)]
    (let [txt (StringBuilder. 1024)]
      (.pipe pdfts (OutputTarget. txt))
      (str txt))))

(get-text "kalle.pdf")

martintrojer

;;http://snellm.github.io/cutlet/
 
(ns cljutlet.core
  (:use [clojure.data.zip.xml])
  (:require [clojure.xml :as xml]
            [clojure.zip :as zip]))

(def data (zip/xml-zip (xml/parse "people.xml")))

(for [p (xml-> data :person)]

martintrojer

(use 'frinj.repl)
(override-operators!)
 
(fj :inch :to :cm)
 
(fj :centi)
(fj :yottagrams)
(fj :centimeter)
(fj :c)
(fj :mm)