jliszka

N=4

def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

class Q(object):
	def __init__(self, p, q=1):

jliszka

<?hh // strict
use namespace \HH\Lib\{C, Regex, Str, Vec, Math};

/*
  "(3 + 4) - sin(3.14 / 2) * 3 * 2"
  <exp> ::=
      <product> "+" <exp>
	| <product> "-" <exp>
	| <product>

jliszka

// Multinomial formula
def multi(ks: Vector[Int]): Double = {
    (1 to ks.sum)
        .map(_ / ks.size.toDouble)
        .zip(ks.flatMap(1 to _))
        .map({ case (n, d) => n / d }).product
}

// Expected number of cereal boxes you have to buy if you want to collect at least `m` of each of `n` surprise mystery toys
def e(n: Int, m: Int, M: Int = 20, v: Vector[Int] = Vector.empty): Double = {

jliszka

def basketball(unseenShots: Int) = {
  def prob(outcomes: List[Boolean]) = 1.0 * outcomes.count(m => m) / outcomes.size
  val outcomes = always(List(true, false)).markov(unseenShots+1)(outcomes => tf(prob(outcomes)).map(b => b::outcomes)).given(_.head)
  val lastShot = for {
    outcome <- outcomes
    shot <- tf(prob(outcome))
  } yield shot
  lastShot.pr(a => a)
}

jliszka

from itertools import permutations
import pprint

class Strategy:
    def cards(self, cs):
        return False

    def filter(self, p):
        return True

jliszka

class JavaEmbeddedRecord<UserId extends Long> {
    public UserId getId() {
       return (UserId)(new Long(5));
    }
}

jliszka

import scala.collection.mutable.WrappedArray

abstract class Impl(val name: String) {
  val N = 20000
  val R = 100

  def setup(n: Int): Unit = ()
  def run(n: Int): Unit

jliszka

/*
Setup:
  $ git clone https://github.com/jliszka/probability-monad.git
  $ cd probability-monad
  $ ./sbt console
  scala> :load Examples.scala
*/

import probability_monad._
import probability_monad.Distribution._

jliszka

import Data.List
import Test.QuickCheck
import qualified Data.Map as Map

nats = [1..]
divides a b = b `mod` a == 0
sieve (n:t) m = case Map.lookup n m of
  Nothing -> n : sieve t (Map.insert (n*n) [n] m)
  Just ps -> sieve t (foldl reinsert (Map.delete n m) ps)
  where

jliszka

import Data.List
import Test.QuickCheck
import qualified Data.Map as Map

nats = [1..]
divides a b = b `mod` a == 0
sieve (n:t) m = case Map.lookup n m of
  Nothing -> n : sieve t (Map.insert (n*n) [n] m)
  Just ps -> sieve t (foldl reinsert (Map.delete n m) ps)
  where