pkukielka

import java.math.BigInteger;

class Trampoline<T> 
{
    public T get() { return null; }
    public Trampoline<T>  run() { return null; }

    T execute() {
        Trampoline<T>  trampoline = this;

pkukielka

sealed trait Bounce[A]
case class Done[A](result: A) extends Bounce[A]
case class Call[A](thunk: () => Bounce[A]) extends Bounce[A]

def trampoline[A](bounce: Bounce[A]): A = bounce match {
  case Call(thunk) => trampoline(thunk())
  case Done(x) => x
}

def factorial(n: Int, sum: BigInt): Bounce[BigInt] {

pkukielka

#include <stdio.h>

typedef struct _trampoline_data {
  void(*callback)(struct _trampoline_data*);
  void* parameters;
} trampoline_data;

void trampoline(trampoline_data* data) {
  while(data->callback != NULL)
    data->callback(data);

pkukielka

package com.pkukielka

import scala.actors.Futures._

object ScalaSum {
  def sum(r: Range): Long = { var i = r.start; var sum = 0L; while (i <= r.end) { i += r.step; sum += i }; return sum }
  val cores = Runtime.getRuntime().availableProcessors()
  val jobs = (1 to cores).map(_ to 1234567890 by cores).map(range => future(sum(range)))
  
  def main(args: Array[String]) {

pkukielka

import scala.actors.Futures._

object ScalaMul {
  val cores = Runtime.getRuntime().availableProcessors()
  val sets = (1 to cores).map(_ to 200000 by cores)
  val jobs = sets.map(set => future(set.foldLeft(BigInt(1))(_ * _)))
  val mult = awaitAll(3600000, jobs:_*).foldLeft(BigInt(1))(_ * _.get.asInstanceOf[BigInt])
  def main(args: Array[String]) = println(mult)
}

pkukielka

import scala.collection.mutable.BitSet
import scala.util.hashing.{MurmurHash3 => MH3}
import scala.math.{abs, log}

class BloomFilter(n: Int, p: Double) {
  val m = (-n * log(p) / 0.48).toInt + 1
  val k = (0.7 * m / n).toInt
  val buckets = new BitSet(m)

  def add(elem: String) = hash(elem).forall(buckets += _)

pkukielka

class AnagramsCounter {
 private val map = scala.collection.mutable.HashMap.empty[String, Int]

  private def charBuffer() = Array.fill[Int](256)(0)

  private def getValue(key: String) = map.getOrElse(key, 0)
  private def insert(key: String) = map += (key -> (getValue(key) + 1))

  def parse(input: String) {
    var letters = charBuffer()

pkukielka

extern mod extra;
use std::num;
use extra::bitv::Bitv;

struct BloomFilter {m: uint, k: uint, buckets: Bitv}

impl BloomFilter {
  fn new(n: uint, p: float) -> BloomFilter {
    let m = ((-(n as float) * num::ln(p) / 0.48)) as uint + 1;
    let k = (0.7 * (m as float) / (n as float)) as uint;

pkukielka

class SpellChecker {
  val alphabet = ('a' to 'z') ++ " "
  def trim(word: String) = word.toLowerCase.filter(alphabet.contains(_))

  val file = io.Source.fromFile("big.txt").mkString
  val wordsCount = file.split(' ').map(trim).groupBy(identity).mapValues(_.length).par

  def distortions(w: String) = {
    def disort(t: Int, d: Int, insert: String) = w.take(t) + insert + w.drop(d)
    val transposes = for { i <- (0 to w.length - 2) } yield disort(i, i + 2, "" + w(i + 1) + w(i))

pkukielka