tallakt

defmodule LazyPermutations do
  def permutations(list) do
    list
    |> Enum.sort
    |> Stream.unfold fn
      [] -> nil
      p -> {p, next_permutation(p)}
    end
  end

tallakt

defmodule XStream do
  @doc """
  Returns a stream of all permutations of the given collection.

  The count parameter will limit the number of elements, all are returned
  by default

  ## Examples

tallakt

defmodule Between do
  @doc """
  ## Examples

      iex> list = for x <- 1000..1031, rem(x, 5) != 0, do: x
      iex> chunks = Between.chunk_between(list, fn a, b -> b - a != 1 end)
      iex> IO.inspect
      [[1001, 1002, 1003, 1004], [1006, 1007, 1008, 1009], [1011, 1012, 1013, 1014],
       [1016, 1017, 1018, 1019], [1021, 1022, 1023, 1024], [1026, 1027, 1028, 1029],
       [1031]]

tallakt

$ elixir tuplify.exs 
Returned from macro:
def(tuplify_from_macro(x)) do
  {unquote(Macro.var(:x, nil))}
end
** (CompileError) tuplify.exs:21: function x/0 undefined
    (stdlib) lists.erl:1336: :lists.foreach/2
    tuplify.exs:14: (file)
    (elixir) lib/code.ex:307: Code.require_file/2
    

tallakt

defmodule Bubble do
  def sort(list) do
    do_sort list, {[], false}
  end

  defp do_sort([a, b | tail], {acc, _}) when b < a do
    do_sort [a | tail], {[b | acc], true}
  end
  
  defp do_sort([a | tail], {acc, swapped?}) do

tallakt

require 'minitest/autorun'

module ConvexHull
  class << self
    def find(points)
      sorted = points.sort.uniq
      reversed = sorted.reverse
      [sorted, reversed].map do |points|
        points.
          reduce([]) {|acc, p| add_to_convex_list p, acc }.

tallakt

defmodule ConvexHull do
  @type coordinate :: {number, number}
  @type point_list :: [coordinate]

  @spec find(point_list) :: point_list
  def find(points) do
    sorted = points |> Enum.sort
    left = sorted |> do_half_calc
    right = sorted |> Enum.reverse |> do_half_calc
    [left, right] |> Enum.concat

tallakt

defmodule LineFollower do
  using Time.PLC
  
  # These may be extracted to a separate module
  # input and output are macros that generate something lacced 'optical' and 'pwm'
  # that somehow link to the signal 'objects'. Think Ruby 'attr' function
  # the physical addresses are linked to the actual hardware being used
  input :optical, "I3.0", desc: "Optical line sensor"
  output :pwm, "PIW100", desc: "Steering motor PWM input"
  

tallakt

# A hand is a list of five with tuples {rank, color}
defmodule Hand do
  @ranks 2..10 |> Enum.concat([:j, :q, :k, :a])
  @consecutive_ranks (@ranks 
                      |> Stream.cycle 
                      |> Stream.chunk(2,1) 
                      |> Enum.take(13))
  
  @rank_weight (@ranks 
                |> Enum.with_index 

tallakt

require 'liquid'

class SetClrCondition < Liquid::Tag
  include Liquid

  def initialize(tag_name, condition, tokens)
    super
    @condition = condition
  end