paulhomebus friends

[C] Polymorphic functions using pointers to pointers

2009-04-21T23:24:52-07:00

The *stupid* example below expresses what I wish to accomplish in terms of functionality. When I change OBJ in Animal_inspect's signature to Dog, and then cast both animals as Dogs (removing (*animal)->name) everything is fine, however ideally I would like a pointer of a pointer to be passed, but the compiler complains

#include <stdio.h>
#include <stdlib.h>

#define ALLOC(x) (x) malloc(sizeof(struct _##x))

typedef int *OBJ;

enum {
  tDog,
  tCat
};

typedef struct _Cat {
  int type;  
  char *name;  
} *Cat;

typedef struct _Dog {
  int type;
  char *name;
} *Dog;

Cat
Cat_alloc() {
  return ALLOC(Cat);
}

Dog
Dog_alloc() {
  return ALLOC(Dog);
}

Cat
Cat_new(char *name) {
  Cat cat = Cat_alloc();
  cat->type = tCat;
  cat->name = name;
  return cat;
}

Dog
Dog_new(char *name) {
  Dog dog = Dog_alloc();
  dog->type = tDog;
  dog->name = name;
  return dog;
}

void
Animal_inspect(OBJ self) {
  printf("<Animal name:%s>\n", (*self)->name);
}

int
main(int argc, char **argv) {
  Dog dog = Dog_new("Fatty");
  Cat cat = Cat_new("Fluffy");
  
  Animal_inspect((OBJ) cat);
  Animal_inspect((OBJ) dog);
  
  return 0;
}

[Haskell] Tag

2009-04-13T01:03:01-07:00

Just playing around, super new to Haskell (1 hour or so), and pointers would be great

---
--- Tag
---

data Tag = Tag {
 tagType  :: String,
 tagAttrs :: [Attr]
}

data Attr = Attr String String

---
--- tagToHTML
---

tagToHTML :: Tag -> String
tagToHTML t = "<" ++ tagType t ++ " " ++ attrs ++ "/>a"
          where attrs = join (map attrPair (tagAttrs t))

---
--- attrPair
---

attrPair :: Attr -> String
attrPair (Attr k v) = k ++ "=\"" ++ v ++ "\""

---
--- join
---

join :: [String] -> String 
join (x:xs) = x ++ " " ++ (join xs)
join [] = ""

--- main

input = Tag "input" [Attr "id" "comments", Attr "disabled" "disabled"]
main = print (tagToHTML input)

[JavaScript] Testing Framework

2009-04-11T19:26:44-07:00

Snippit from http://visionmedia.github.com/jspec/, trying to come up with the most readable syntax possible for the testing framework (-{} is alternative for function(){} )

describe 'ShoppingCart'
  var cart

  before_each
    cart = new ShoppingCart
  end
  
  describe 'addProducts'
    it 'should add several products'
      cart.addProduct('cookie')
      cart.addProduct('icecream')
      cart.should.have 2, 'products'
    end
  end

  describe 'checkout'
    it 'throw an error when checking out with no products'
      -{ cart.clear().checkout() }.should.throw_error
    end
  end
end

[Ruby] Hash#switchify

2009-04-08T21:26:25-07:00

Whipped this up really quick, the output shows what I want but pretty messy IMO

class String
  def dasherize
    to_s.gsub '_', '-'
  end
  
  def switchify
    length > 1 ? "--#{dasherize}" : "-#{self}"
  end
end

class Hash
  def switchify
    inject [] do |args, (key, value)|
      next args unless value
      args << key.to_s.switchify
      args << (value === String ? value.inspect : value.to_s) unless value === true
      args
    end
  end
end

h = { :config => 'foo.ini', :verbose => true, :with_foo_bar => false, :with_some_coolness => true, :T => true }

p h.switchify
# => ["--config", "foo.ini", "--verbose", "--with-foo", "-T"]

p h.switchify.join(' ')
# => --config foo.ini --verbose --with-foo -T

[Ruby] Simple wrap method

2009-03-20T18:35:48-07:00

rawr

class String
  def wrap prefix, suffix = nil
    [prefix, self, (suffix || prefix)].join
  end
end

puts 'foo'.wrap('|') 
# => |foo|

puts 'foo'.wrap('(', ')')
# => (foo)

[JavaScript] Range

2009-03-17T21:26:41-07:00

I use this in a JS interpreted grammar for JSpec, if anyone has a better solution let me know :D

/**
 * Create a range string which can be evaluated to a native array.
 *
 * @param  {int} start
 * @param  {int} end
 * @return {string}
 * @api public
 */

function range(start, end) {
  s = parseInt(start), e = parseInt(end), b = '[' + s
  if (e > s) while (++s <= e) b += ',' + s
  else       while (--s >= e) b += ',' + s
  return b + ']'
}

[Ruby] String#strip with char list

2009-02-21T01:08:10-08:00

Better way?

class String
  def strip chars = "\s"
    gsub /^[#{chars}]+|[#{chars}}]+$/, ''
  end
end

p ' test '.strip        # => "test"
p '$test$'.strip('$')   # => "test"
p '<test>'.strip('<>')  # => "test"
p '.test.'.strip('.')   # => "test"

[Ruby] Time lost since

2009-02-02T18:34:25-08:00

Pasted the rest just so people can play around, but #lost_since is the only thing Im concerned about, the lambda needs some loven

require 'rubygems'

class Numeric
  
  def second ; self * 1 end
  alias_method :seconds, :second
  
  def minute; self * 60 end
  alias_method :minutes, :minute
  
  def hour; self * 3600 end
  alias_method :hours, :hour
  
  def day; self * 86400 end
  alias_method :days, :day
  
  def week; self * 604800 end
  alias_method :weeks, :week
  
  def month; self * 2592000 end
  alias_method :months, :month
  
  def year; self * 31471200 end
  alias_method :years, :year
  
  def to_minutes; self / 1.minute end
  def to_hours;   self / 1.hour   end
  def to_days;    self / 1.day    end
  def to_weeks;   self / 1.weeks  end
  def to_months;  self / 1.months end
  def to_years;   self / 1.years  end
  
end

module TimeHelpers
  def lost_since time = Time.now
    return unless self < time
    seconds = (time - self).to_i
    pluralize = lambda { |string| n = seconds.send(:"to_#{string}s"); n == 1 ? "one #{string}" : "#{n} #{string}s" }
    case seconds
    when 0..59                ; "less than one minute"
    when 1.minute..59.minutes ; pluralize[:minute]
    when 1.hour..23.hours     ; pluralize[:hour]
    when 1.day..6.days        ; pluralize[:day]
    when 1.week..3.weeks      ; pluralize[:week]
    when 1.month..11.months   ; pluralize[:month]
    when 1.year..4.years      ; pluralize[:year]
    else "several years"
    end
  end
  alias :lost_since_now :lost_since
end

Time.send :include, TimeHelpers

describe "#lost_since" do
  it "should return nil when greater than now" do
    event = Time.now + 5.days
    event.lost_since_now.should be_nil
  end
  
  it "should return less than one minute" do
    event = Time.now - 30.seconds
    event.lost_since_now.should == 'less than one minute'
  end
  
  %w( minutes hours days weeks months years ).each do |v|
    it "should return several #{v}" do
      event = Time.now - 2.send(v)
      event.lost_since_now.should == "2 #{v}"
    end
  end
  
  %w( minute hour day week month year ).each do |v|
    it "should return a single #{v}" do
      event = Time.now - 1.send(v)
      event.lost_since_now.should == "one #{v}"
    end
  end
  
  it "should return several years when past 4" do
    event = Time.now - 5.years
    event.lost_since_now.should == "several years"
  end
  
  it "should work using alternate time as argument" do
    event = Time.now - 10.days
    event2 = Time.now - 5.days
    event.lost_since(event2).should == '5 days'
  end
  
  it "should work using future time as argument" do
    # Not sure when anyone would do this ... but it works
    event = Time.now - 7.days
    event2 = Time.now + 7.days
    event.lost_since(event2).should == '2 weeks'
  end
  
end

[Ruby] Recursive population of hash key-value pairs

2009-01-23T20:13:31-08:00

I do not even know where to begin on this one to be honest. Basically I want to parse a string, for example a query string, and populate a hash. Parsing the query string is super easy I am just not sure how to dynamically populate the hash in Ruby. In PHP I know this was a limitation (among many haha..) and you had to support X levels of nesting

params[:name][:primary] # etc ...

[Ruby] Closure scoping issue

2009-01-09T20:14:40-08:00

Below is the syntax I would like. However the only problem I am running into is that even when #form uses a proxy object to redirect method calls to my Elements module, the instance evaluation of the block below still call the methods at the global scope, in turn not 'collecting' results of each invocation. I know I could simply pass an object to the block like the second example but I would way rather have it this way

   
  include Form::Elements

  form :login do
    textfield :name, :label => 'Username'
    textfield :pass, :label => 'Password'
    submit :op, :value => 'Login'
  end

  form :login do |f|
    f.textfield :name, :label => 'Username'
    f.textfield :pass, :label => 'Password'
    f.submit :op, :value => 'Login'
  end

[Ruby] includes_all?

2009-01-05T21:14:49-08:00

Having brain cramps today, this implementation could certainly be better. It is somewhat ad-hoc, I needed it for a permission system but figured I would abstract it a little

require 'ostruct'
require 'rubygems'
require 'extlib/blank'

class Object
  def includes_all? objects, options = {}
    meth = options.delete :method
    enum = (meth and respond_to? meth) ? self.send(meth) : self
    objects.each do |v|
      return false unless enum.include? v
    end
    true
  end
end

describe "includes_all?" do
  it "should work with flat arrays" do
    ['hey', 'there', 'world'].includes_all?(['hey', 'there']).should be_true
  end
  
  it "should work with arbitrary objects" do
    obj = { :foo => 'bar' }
    [1, 'two', obj].includes_all?([obj, 1]).should be_true
  end
  
  it "should fail appropriately" do
    ['foo', 'bar'].includes_all?(['foo', 'fail']).should be_false
    ['foo', 'bar'].includes_all?([]).should_not be_false
  end
  
  it "should work with methods" do
    role = OpenStruct.new
    role.permissions = ['access content', 'edit content']
    role.includes_all?(['access content', 'edit content'], :method => :permissions).should be_true
    role.includes_all?(['delete content'], :method => :permissions).should be_false
  end
end

[Ruby] Run once

2008-12-16T21:30:54-08:00

Cleaner way?

def run_once &block
  path = File.expand_path caller.first
  unless ($__run_once ||= []).include? path
    yield
    $__run_once << path
  end
end

[Ruby] Proc param names

2008-12-12T23:20:50-08:00

Below is the exact result I want, just the param names, however I need to do this without explicitly returning the binding, can this be done without a bunch of 'meta-magic'?

# Working example
def test &block
  bind = yield 1, 2, 3
  p eval('local_variables', bind)
end

test do |just, some, params|
  binding
end

# => ['just', 'some', 'params']

[Ruby] Bindings on caller

2008-11-22T06:16:53-08:00

I dont really have a need for this but i was trying to figure it out and was curious this sort of thing could be accomplished with bindings.

def test(a, b)
  capitalize_args
  puts a   # => Hello
  puts b   # => World
end

test "hello", "world"

[Ruby] Initial script execution very slow and skewing results

2008-11-22T02:27:39-08:00

Below is a little snippit of a quick response time monitor I was playing around with, works fine BUT when executed the first time everything performs really slowly and skews the duration by 3 to 4 seconds.. after that every execution works as expected.

def monitor(uri)
  Thread.new(uri) do |uri|
    begin
      start = Time.now
      res = open uri
      duration = (Time.now - start).abs
      puts "   %0.3f | %s | %s" % [duration, res.status.join(' '), uri]
    rescue
      puts "   0.000 | 404 Not Found | %s" % [uri]
    end
  end.queue
end

[Ruby] suppress ERB newlines

2008-11-22T02:16:09-08:00

Just plain-jane ERB. What does rails do differently to allow <% -%> and <%= -%> ? to get below to actually format correctly I have to place the erb tags in a gross manor.. initializing ERB with <> or >

  NAME:
  
    <%= @name %>
  
  DESCRIPTION:
  
    <%= @description %>
  
  SYNOPSIS:
  
    <%= @syntax %>

<% unless @examples.empty? %>
  EXAMPLES:
  <% @examples.each do |example| %>  
    # <%= example[:description] %>
    <%= example[:command] %>
  <% end %>
<% end %> 

<% unless @options.empty? %>
  OPTIONS:
  <% @options.each do |option| %>
    <%= option[:args].join(', ') %>
  <% end %>
<% end %>

[Ruby] Caching Methods

2008-11-19T05:23:59-08:00

Is it possible to cache methods in a manor similar to below? (non-RoR). I have a few ideas of how this may work but any suggestions would be great

class Something
  
  def something_else
    "Expensive operation"
  end
  
  cache_method :something_else, :for => 2.hours
  
end

inst = Something.new

# Empty cache
inst.something_else

# Primed cache
inst.something_else

[Ruby] Yield by 'reference'

2008-10-23T22:25:19-07:00

This has been bugging me, its a simple thing but I do not quite understand how "initial" and "total_length" have the same object_id, and yet the example below will not work.

Ps. this is not an actually implementation I just needed a similar use so this was the test code

class Array
  def new_inject(initial, &block)
    self.each { |v| yield initial, v } 
    initial
  end
end

p %w[ just a test ].new_inject(0) { |total_length, v| total_length += v.length }

[Ruby] Source code analysis

2008-09-26T03:04:52-07:00

Small class to analyze scripts, outputs similar to below:

files js 5
declared classes 146
lines todo 27
lines blank 3171
files 69
lines 28263
files module 3
files inc 36
files install 1
files css 5
files php 19
declared functions 1004
lines comments 6313
comment ratio 0.22

I dont really like the order of which I am outputting but you cannot sort Hashes correct? it looks fine
when piped through sort $ lc -r . | sort -n, but I would hardly call that ideal. Anyways feel free to comment
or refactor any portion, I am eager to learn Ruby and seeing your examples helps alot!

#!/usr/bin/env ruby

# == Synopsis
#   lc is an open source Ruby program for analysing the contents
#   of source code, such as line counts and comment ratios.
#
# == Usage
#   lc [-hVr] [ dir | file ... ]
#  
# == Examples
#   Analyse current directory 
#     lc
#    
#   Analyse current directory recursively
#     lc --recursive
#    
#   Analyse specific files and a directory recursively
#     lc -r ./index.php ./cron.php ./sites/all/modules/gui
#    
# == Options
#   -h, --help      Display this help information.
#   -V, --version   Display version of lc.
#   -r, --recurse   Scan directories recursively.
# 
# == Author
#   TJ Holowaychuk 
#
# == Copyright
#   Copyright (c) 2008 TJ Holowaychuk. Licensed under the MIT License:
#   http://www.opensource.org/licenses/mit-license.php

require 'optparse'
require 'rdoc/usage'
	
$syntax = {
		'rb' => {																																						
				:name => 'Ruby',																																
				:blank => /^\s*$/,																															
				:comment => /^[\s]*#/,																													
				:comment_open => /[\s]*=begin/,																									
				:comment_close => /[\s]*=end/,																									
				:function => /def[\s]+[\w]+/,																										
				:class => /class[\s]+[\w]+/,			
				:todo => /@?todo/,																							
				:associations => ['rb', 'erb']																									
			},																																								
		'php' => {																																					
				:name => 'PHP',																																	
				:blank => /^\s*$/,																															
				:comment => /^[\s]*\/\//,																												
				:comment_open => /^[\s]*\/\*/,																									
				:comment_close => /[\s]*\*\//,																									
				:function => /^[\s]*function[\s]+[\w]+[\s]*\(/,																				
				:class => /class[\s]+[\w]+/,												
				:todo => /@?todo/,														
				:associations => ['php', 'inc', 'module', 'install']														
			},																																								
		'js' => {																																						
				:name => 'JavaScript',																													
				:blank => /^\s*$/,																															
				:comment => /^[\s]*\/\//,																												
				:comment_open => /^[\s]*\/\*/,																									
				:comment_close => /[\s]*\*\//,																									
				:function => /^[\s]*(?:function[\s][\w]+|(var)?[\s]*[\w\.]+[\s]+=[\s]+function)[\s]*\(/,	
				:todo => /@?todo/,
				:associations => ['js']																													
			},																																								
		'css' => {																																					
				:name => 'CSS',																																	
				:blank => /^\s*$/,																															
				:comment => /^[\s]*\/\//,																												
				:comment_open => /^[\s]*\/\*/,																									
				:comment_close => /[\s]*\*\//,						
				:todo => /@?todo/,																																			
				:associations => ['css']																												
			}																																									
	}																																											

class LC 
	
	VERSION = '0.0.1'
	
	attr_reader :files, :reports
	attr_accessor :options, :arguments
	
	# Initialize
	def initialize()
		self.initialize_options
		self.initialize_reports
	end
	
	# Initialize option defaults
	def initialize_options
		@options = {}
		@options[:recursive] = false		
	end
	
	# Initialize reports, create defaults
	def initialize_reports
		@reports = {}
		@reports[:comment_ratio] = 0
		@reports[:totals] = {
		    'files' => 0,
		    'lines' => 0,
				'lines blank' => 0,
				'lines comments' => 0,
				'lines todo' => 0,
				'declared functions' => 0,
				'declared classes' => 0,			 
			}
		$syntax.each do |lang|
			lang[1][:associations].each do |association|
				@reports[:totals]['files ' << association] = 0
			end
		end		 
	end
	
	# Start analysis.
	def run
		# Parse options
		self.parse_options
		
		# Default files to cwd
		@files = @arguments.empty? ? ['.'] : @arguments

		# Parse files and directories
		file_pattern = $syntax.collect{|lang| lang[1][:associations].join(',')}.join(',')
		@files.each do |file|
			if File.directory?(file)
				files = Dir[(@options[:recursive] ? '**/' : '') << file << '/*.{' + file_pattern + '}']
				files.each do |file|
					self.parse_script(file)
				end			 
			elsif File.file?(file)
				self.parse_script(file)
			end
		end

		# Report
		self.prep_report
		self.output_report
		exit
	end
	
	# Parse options
	def parse_options
		opts = OptionParser.new
		opts.on('-h', '--help')				{ RDoc.usage(0) }
		opts.on('-V', '--version')		{ self.output_version; exit 0 }
		opts.on('-r', '--recursive')	{ @options[:recursive] = true }
		begin
		  opts.parse!(@arguments)
	  rescue => e
	    puts e
	    exit 1
    end
	end

	# Get extension of filepath.
	def get_extension(filepath) 
		File.extname(filepath).reverse.chop.reverse
	end

	# Get syntax based on a filenames extension.
	def get_syntax(filepath)
		extension = get_extension(filepath)
		$syntax.each_pair do |lang, info|
			return $syntax[lang] if info[:associations].include?(extension)
		end
	end

	# Parse a script and report on findings.
	def parse_script(filepath)
		lang = get_syntax(filepath)
		comment_open = false
		extension = get_extension(filepath)

		# Ensure syntax was found
		if lang.kind_of? NilClass
			return
		end

		File.open(filepath) do |file| 
			@reports[:totals]['files'] += 1
			@reports[:totals]['files ' << extension] += 1
			file.each_line do |line|
				@reports[:totals]['lines'] += 1
				@reports[:totals]['lines blank'] += 1 if line.match(lang[:blank])
				if !line.match(lang[:blank])
				  @reports[:totals]['lines todo'] += 1 if line.match(lang[:todo])
				  case 
			      when line.match(lang[:comment]); @reports[:totals]['lines comments'] += 1 
			      when line.match(lang[:comment_open]); @reports[:totals]['lines comments'] += 1; comment_open = true
			      when line.match(lang[:comment_close]); @reports[:totals]['lines comments'] += 1; comment_open = false
            else 
						  if comment_open
							  @reports[:totals]['lines comments'] += 1
						  else
						    case
					        when lang[:function] && line.match(lang[:function]); @reports[:totals]['declared functions'] += 1
							    when lang[:class] && line.match(lang[:class]); @reports[:totals]['declared classes'] += 1
							  end
						  end
					end
				end
			end
		end
	end

	# Prepare output of report.
	def prep_report
		if @reports[:totals]['lines comments'] > 0 and @reports[:totals]['lines'] > 0
			@reports[:comment_ratio] = @reports[:totals]['lines comments'].to_f / @reports[:totals]['lines'].to_f 
		end
	end

	# Output report.
	def output_report
		@reports[:totals].each_pair do |k, v| 
			puts k + ' ' + v.to_s unless v == 0
		end
		puts 'comment ratio ' << '%.2f' % @reports[:comment_ratio] unless @reports[:comment_ratio] == 0
	end
	
	# Output version information.
	def output_version
		puts "Version #{LC::VERSION}"
	end
end

counter = LC.new
counter.arguments = ARGV
counter.run

[Ruby] Interactive CLI Session

2008-09-23T16:06:20-07:00

Again I am a Ruby newb (two days now), but the help is very appreciated in getting to understand the magic behind Ruby and more elegant ways to take care of issues.

I am looking to allow classes to extend CLI:Session and implement their own commands in a unified manor, below is an example fused into the single class, however ideally the only command for CLI:Session would be 'help' where as the rest would simply extend this class.

module CLI
  class Session 
    
    # 
    # Initialize
    #
    def initialize
      @commands = [
          {
            :title => 'Help',
            :description => 'Output command help and usage information.',
            :pattern => /help|usage|commands/,
            :syntax => 'help | usage | commands',
            :callback => 'self.usage',
          },
          {
            :title => 'Source code analysis',
            :description => 'Quickly reports on the current source code round within this Shard installation.',
            :pattern => /analyze source/,
            :syntax => 'analyze source',
            :callback => 'self.analyze_source',
          }
        ]
    end
      
    #
    # Start the session.
    #
    def start
      loop do
        print "Shard >> "  
        @@args = gets
        @commands.each do |command|                                     
          eval(command[:callback]) if command[:pattern].match @@args    
        end                                                             
      end      
    end
    
    #
    # Output command usage.
    #
    def usage
      @commands.each{|command| puts self.command_usage(command)}
    end
    
    #
    # Get command usage.
    #
    def command_usage(command)
      <<-USAGE
      
        #{command[:title]}
        #{command[:description]}
        Syntax: '#{command[:syntax]}'
USAGE
    end
    
    #
    # Analyze source.
    #
    def analyze_source
      Dir['**/*.rb'].each{ |file| puts `wc -l #{file}` }
    end
  end
end

[Ruby] Format Filesize

2008-09-22T15:40:24-07:00

Ruby-newb coming through. I only really need to format sizes in bytes, KiB, and MiB, however I suppose a larger scale does not hurt! but im sure this one can be refactored quite alot

  #
  # Format filesize.
  #
  def Format.filesize(bytes, label_style = 0)
    size = bytes
    suffix = 'Bytes'
    labels = {
        0 => ['KB', 'MB'],
        1 => ['Kilobytes', 'Megabytes'],
        2 => ['KiB', 'MiB']
      }
    sizes = [1024, 1048576, 1073741824]
    
    # KiB
    if size >= 1024
      size = (size / 1024).round
      suffix = labels[label_style][0]
    end
  
    # MiB
    if size >= 1024
      size = (size / 1024).round
      suffix = labels[label_style][1]
    end
    
    size.to_s + ' ' + suffix
  end

[Ruby] Camelize

2008-09-22T15:38:30-07:00

I am pretty new to Ruby (one day), however this works fine, but I would like to allow the first character to be lower case optionally, anyone have a smaller solution for this?

  
  #
  # Convert a string to CamelCase.
  #
  def camelize
    self.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
  end

[PHP] Dynamically invoking static classes?

2008-06-09T20:52:53-07:00

Hey guys, I should have really thought ahead with this before I went ahead and wrote a good 15 classes but either way my core class needs a mechanism to invoke 'hooks' within each of the other classes available within the scope. Eval() does work, however it obviously outputs an error when the 'hook' does not exist which is certainly no good.. Is there any good clean way this can be done?

  static public function invoke($hook) {
    $packages = array();
    $results = array();  
    
    $packages['libraries'] = self::$libraries;
    $packages['modules'] = self::$modules;
    
    foreach((array) $packages AS $type => $names){
      foreach((array) $names AS $name){
        switch($type){
          case 'libraries':
            $result = @eval("{$name}::{$hook}();");
            break;
            
          case 'modules':
            $result = @eval("{$name}Module::{$hook}();");
            break;
        }
         
        if (is_array($results)){
          $results = array_merge($results, (array) $result);
        }
      }
    }
    
    return $results;  
  }

[PHP] Command-Line TicTacToe

2008-03-24T00:00:15-07:00

Just wondering if there are any ways to make this smaller.

<?php
$std = fopen("php://stdin", "r");
echo "TICTACTOE\n\n\n\n";
function letsSeeUm($taken){
  foreach(range(1, 9) as $i) ${"s" . $i} = array_key_exists($i, $taken) ? $taken[$i]:" ";
  echo "   +   +   \n $s1 + $s2 + $s3 \n   +   +   \n+++++++++++\n   +   +   \n $s4 + $s5 + $s6 \n   +   +   \n+++++++++++\n   +   +   \n $s7 + $s8 + $s9 \n   +   +   \n\n";
}
function check($squ, $em = "x"){
  if(($squ[1] == $em && $squ[2] == $em && $squ[3] == $em) || ($squ[4] == $em && $squ[5] == $em && $squ[6] == $em) || ($squ[7] == $em && $squ[8] == $em && $squ[9] == $em) || ($squ[1] == $em && $squ[4] == $em && $squ[7] == $em) || ($squ[2] == $em && $squ[5] == $em && $squ[8] == $em) || ($squ[3] == $em && $squ[6] == $em && $squ[9] == $em) || ($squ[1] == $em && $squ[5] == $em && $squ[9] == $em) || ($squ[3] == $em && $squ[5] == $em && $squ[7] == $em)) return true;
  return false;
}
$squares = array();
$player = 1;
while(1){
  echo str_repeat("\n", 100);
  letsSeeUm($squares);
  echo "Player $player> ";
  $input = (int) fgets($std);
  if(!array_key_exists($input, $squares) && in_array($input, range(1, 9))){
    $squares[$input] = ($player == 1) ? "x":"o";
    if(check($squares) || check($squares, "o")){
      echo str_repeat("\n", 100);
      letsSeeUm($squares);
      echo "\nPlayer $player Wins!";
      die;
    }
    if(count($squares) == 9){
      echo str_repeat("\n", 100);
      letsSeeUm($squares);    
      echo "\nDraw!";
      die;
    }
    $player = $player == 1 ? 2:1;
  }
}

[Ruby] On Getting QWERTY misstypes

2007-10-24T02:45:19-07:00

Hi, I don't how to write a Ruby solution but you can have some idea looking at this Perl module.

http://search.cpan.org/~krburton/String-KeyboardDistance-1.01/KeyboardDistance.pm