lepoetemaudit

let numberToTokiPona num =
    let rec addNum num str =
        if num >= 2 then addNum (num-2) (str ^ "twu ")
        else if num = 1 then addNum (num-1) (str ^ "wan ")
        else str
    in
    if num > 0 then addNum num ""
    else "ala";;

print_string (numberToTokiPona 19);;

lepoetemaudit

(defn numberToTokiPona [num]
  (clojure.string/join " "
    (loop [n num strs []]
      (cond
        (> n 1) (recur (- n 2) (conj strs "twu"))
        (= n 1) (recur (- n 1) (conj strs "wan"))
        :else strs))))

lepoetemaudit

tokiPona = lambda num: (num / 2) * "twu " + ("wan" if num % 2 else "")

lepoetemaudit

Sum

sum1(1, 2, 3) == 6

Fizzbuzz

1 1
2 2
3 Fizz

4 4

lepoetemaudit

"""
Extremely crude example of a timing attack
"""

import time
import timeit

actualPassword = '0BEA0239'

def checkpassword(passwd):

lepoetemaudit

let numberToTokiPona num =
    let rec addNum num str =
        if num >= 2 then addNum (num-2) (str + "twu ")
        else if num = 1 then addNum (num-1) (str + "wan ")
        else str
    if num > 0 then addNum num ""
    else "ala"

(numberToTokiPona 19) |> printfn "%s" 

lepoetemaudit

open System.Threading

type ChatMessage =
    | SendMessage of string
    | GetContent of AsyncReplyChannel<string list>


let agent = MailboxProcessor.Start(fun agent ->
    let rec loop (state : string list) = async {
        printfn "List length is now %d" state.Length

lepoetemaudit

open FSharp.Data
open System.Threading

["http://bbc.co.uk"; "http://www.google.co.uk"]
    |> List.map (fun str ->
        async {
            let! html = Http.AsyncRequestString(str)
            return sprintf "bbc len %d" html.Length 
        }
    )

lepoetemaudit

(defmacro pln [& args]
  (let [operator-count (dec (/ (count args) 2))
        operators (take operator-count args)
        values (drop operator-count args)
        op-vals (map vector operators (next values))]

    (loop [form (first values)
           op-vals op-vals]
      
      (if (not-empty op-vals)

lepoetemaudit

(defn- decode-huffman [nodes buffer]
  (string/join (loop [byte-pos 0 bits (first buffer)
                      node (last nodes)
                      bits-remaining 8 output []]
                 (if (= 0 bits-remaining)
                   (recur (inc byte-pos) (nth buffer (inc byte-pos)) node 8 output)

                   (let [next-node (if (bit-test bits 7) :right :left)]
                     (if (= 255 (:right node))
                       (if (not= (:value node) "|")