sortega’s gists

sortega / warrior.hs

Created February 23, 2015 22:58

Improvement over naive.hs

	import Control.Monad.Random
	import Data.List
	import System.Environment
	import System.Exit
	import System.Random
	import System.IO

	data Feedback = Smaller \| Bigger \| Done deriving (Show, Eq)
	type Guess = Int
	type Range = (Int, Int)

sortega / naive.hs

Created February 2, 2015 15:26

Naïe pick/guess implementation

	import System.Environment
	import System.Exit
	import System.Random
	import System.IO

	data Feedback = Smaller \| Bigger \| Done deriving (Show, Eq)
	type Guess = Int
	type Range = (Int, Int)

	range = (1, 100)

sortega / AllocatorTest.scala

Created September 23, 2014 15:34

	import org.scalacheck.Gen
	import org.scalatest.{ShouldMatchers, FlatSpec}
	import org.scalatest.prop.PropertyChecks

	class AllocatorTest extends FlatSpec with ShouldMatchers with PropertyChecks {

	val positives = Gen.posNum[Int]
	val vectorOfPositives = Gen.nonEmptyContainerOf[Vector, Int](positives)

	"A proportional distribution" should "have the same amounts as weights" in {

sortega / BerlinClock.scala

Created January 19, 2014 08:49

Berlin clock kata (http://content.codersdojo.org/code-kata-catalogue/berlin-clock/) implemented in Scala when pairing with Alberto. By just letting the tests guide the design and merciless refactoring after every step we got to this terse code.

	package berlin

	object BerlinClock {

	sealed trait Light
	case object Off extends Light
	case object Yellow extends Light
	case object Red extends Light

	type Clock = List[List[Light]]

sortega / IndentationCheck.scala

Created January 5, 2014 22:32

Functional solution to the Python indentation problem check

	import scala.io.Source

	object IndentationCheck {

	def isValid(filename: String): Boolean = isValid(Source.fromFile(filename).getLines.toSeq)

	def isValid(lines: Seq[String]): Boolean = {
	val initialAccum: Option[Set[Int]] = Some(Set(0))
	lines.map(indentationOf).foldLeft(initialAccum) { (accum, i) =>
	accum match {

sortega / ImperativeIndentationCheck.scala

Created January 5, 2014 22:30

Imperative solution to the Python indentation problem

	import scala.io.Source
	import scala.collection.mutable

	object ImperativeIndentationCheck {

	def isValid(filename: String): Boolean = isValid(Source.fromFile(filename).getLines.toSeq)

	def isValid(lines: Seq[String]): Boolean = {
	val scopes = mutable.Stack(0)
	for(line <- lines) {

sortega / nullitis.pl

Created July 13, 2013 15:39

Quick and dirty script to measure how null-checking prevalence in Java programs.

	#!/usr/bin/env perl
	use strict;
	use warnings;

	sub locs {
	my $repo = shift;
	`sloccount $repo \| grep ^java` =~ /^java:\s+(\d+)/;
	return $1;
	}

sortega / Tree.scala

Created July 6, 2013 23:54

Xmas tree kata

	package xmas

	object Tree {
	def apply(n: Int) = {
	val width = n * 2 - 1
	def center(line: String) = {
	val padding = " " * ((width - line.length) / 2)
	padding ++ line ++ padding
	}.mkString
	def line(row: Int) = row * 2 + 1

sortega / ExtendedGame.scala

Created June 25, 2013 22:43

Rock, paper, scissors in Scala (and extended to Spock and frieds FTW)

	package pogame

	object ExtendedGame extends POGame {
	sealed trait ExtendedHand extends POrdered[ExtendedHand] {
	val weaknesses: Seq[ExtendedHand]
	def defeatedBy(other: POrdered[ExtendedHand]): Boolean = weaknesses.contains(other)
	}
	case object Rock extends ExtendedHand { val weaknesses = Seq[ExtendedHand](Paper, Spock) }
	case object Paper extends ExtendedHand { val weaknesses = Seq[ExtendedHand](Scissors, Lizard) }
	case object Scissors extends ExtendedHand { val weaknesses = Seq[ExtendedHand](Rock, Spock) }

sortega / NameInverter.scala

Created June 22, 2013 16:36

NameInverter in Scala by me

	package cleancode

	object NameInverter {

	def apply(name: String): String =
	swapFirstAndLast(splitName(name).dropWhile(isHonorific)).mkString(" ")

	def swapFirstAndLast(parts: List[String]) = parts match {
	case first :: last :: postNominals => last + "," :: first :: postNominals
	case _ => parts

Sebastián Ortega sortega