Marc-Andre

[Ruby] On Stable sort in ruby

2009-12-15T03:08:25-08:00

Calling #sort if no block is given won't really work if the class of the sorted elements has redefined <=> (for example to be case insensitive).

Moreover you might as well define stable_sort on Enumerable in general. Finally, your #with_indices already exist (in enumerator form): each_with_index

Note: if running 1.8.6: require 'backports'

module Enumerable
  def stable_sort(&block)
    block &&= Proc.new do |(x, i), (y, j)|
      yield(x, y).nonzero? || i <=> j
    end
    each_with_index.sort(&block).map(&:first)
  end
end

9.downto(1).sort{|x,y| x % 2 <=> y % 2}         # => [8, 2, 4, 6, 5, 7, 3, 9, 1]
9.downto(1).stable_sort{|x,y| x % 2 <=> y % 2}  # => [8, 6, 4, 2, 9, 7, 5, 3, 1]

[Ruby] On rindex

2009-09-04T20:16:09-07:00

I like Pierre's version. If you're in 1.8.7 (or including backports ;-) you could use #rpartition instead of #split, which should be faster.

# in ruby 1.8.7 or require 'backports'

title.rpartition(' > ').last

[Ruby] On Running Ruby 1.9 or 1.8 code

2009-09-01T18:43:44-07:00

Shameless plug for my backports gem (http://github.com/marcandre/backports ). Note that String#lines was added in 1.8.7 (not in 1.9)

require 'backports'

exceptions = exceptions.to_s.lines.to_a

[Ruby] On Count words in a string

2009-05-05T02:06:43-07:00

Daniel: The added advantage of Hash.new(0) is that simply checking a word won't create a useless entry. Say you get a frequency hash of a small text and you then run the words of the bible on that hash... you might not like the memory usage!

TJ: your Enumerable version is much more versatile and can be used to get the frequencies of other stuff than strings. While I'm nitpicking, isn't this a good opportunity to use the new 'returning'?

module Enumerable
  def frequency
    returning Hash.new(0) do |hash|
      each{ |elem| hash[elem] +=1 }
    end
  end
end

[Ruby] On Return from function within a function

2009-04-23T15:21:13-07:00

Can't agree more with Tj. Read a good book on Ruby (say the new edition of Pragmatic Programmers') and learn Ruby.

I don't understand what's up with the self.frequency test, so apart from that, here's a refactor of your code. I didn't change the date_conflict test because I don't want to understand what it's doing, but there's a better way. Check the api to get days, months, etc... directly, not going through strings.

Bob is right, the way to break out of many functions is to raise an exception. Clearly you don't need it here, you just need more Ruby-fu :-)

FREQUENCY = { 'weekly' => 7, 'bi_monthly' => 14}.freeze
def check_appt_conflicts
  appointments.any? do |appointment|
    date_conflict(date, appointment.date, FREQUENCY[appointment.frequency])
  end
end

def date_conflict(this_date, later_date, mod_value)
  this_date.strftime("%j").to_i % mod_value == later_date.strftime("%j").to_i % mod_value      
end

[Ruby] On ATP Tournament iCalendar

2009-04-20T17:49:04-07:00

Here's a prettified prettify_output

def prettify_output(rows)
  rows.map do |date, location, surface, price, tickets, winners|
    location, tourney = location.split("\n")
    {
      :date     => Date.parse(date),
      :location => location,
      :tourney  => tourney.sub(/(\w)ATP/,"\\1\nATP"),
      :surface  => surface,
      :price    => price,
      :tickets  => tickets,
      :winners  => winners || "no info available"
    }
  end
end

# and modify initialize to set @tourneys:
@tourneys = prettify_output(parse_resource(@hp))

[Ruby] On Swedish Personnummer in Rails (Ruby)

2009-04-07T18:26:00-07:00

My Swedish is a bit rusty, but isn't that simply Luhn's check?
You can add all the numbers and check the sum (mod 10) is 0.
You might want to add a check that only numbers have been passed.
I didn't check the following code:

def passes_luhn_check?(str)
  sum = 0
  numbers = str.split(//).map(&:to_i)
  numbers.each_with_index do |n, i|
    n *= 2 if i.even?
    n -= 9 if n >= 10
    sum += n
  end
  sum % 10 == 0
end

def validate_ssn
  # Kontrollera antal siffror i personnummret.
  if ssn.size != 10
    errors.add_to_base "Personnummret innehÃ¥ller fel antal siffror. (Ã…Ã…MMDDXXXX)"
  end
  
  # RÃ¤kna ut kontrollsiffran
  errors.add_to_base 'Personnummret mÃ¥ste vara riktigt.' unless passes_luhn_check?(ssn)
end

[Ruby] On Splitting array into defined sizes

2009-03-25T17:44:52-07:00

And if you don't need those extra methods, it's really a two line job, and you can change the beginning of the week easily:

def date_range_by_week(selected_date)
  first_in_calendar = selected_date.beginning_of_month.next_week(:monday) - 7
  (first_in_calendar...(first_in_calendar+7*6)).to_a.in_groups_of(7)
end

[Ruby] On Splitting array into defined sizes

2009-03-25T17:26:53-07:00

I'm presuming you're coding in rails, or at least using 'activesupport', so there is no need for your 'first_day_of_month' method. Use DateTime.beginning_of_month. Also, you were looking for Array.in_groups_of (activesupport) or Enumerable.group_by (ruby 1.9). Here's the result:

def offset(selected_date)
  wday = selected_date.beginning_of_month.wday
  wday == 0 ? 6 : (wday - 1)
end

def start_date(selected_date)
 selected_date.beginning_of_month - offset(selected_date)
end

def end_date(selected_date)
 (selected_date.beginning_of_month - offset(selected_date)) + 41
end

def date_range_by_week(selected_date)
  (start_date(selected_date)..end_date(selected_date)).to_a.in_groups_of(7)
end

[Ruby] On Converting all umlaut characters to their base

2009-03-17T19:52:36-07:00

@Tj: Bit-shifting? For all 14 accents, with variations of letter + lower/uppercase? Mmmm, I'll bet, say, $20 it's not possible! :-)

@pragmatig: Thanks! You probably won't be able to do the normalization without activesupport. Even ruby 1.9 doesn't give you a way to normalize strings (yet!)

[Ruby] On Advanced search form & Named scopes

2009-03-17T15:45:57-07:00

I'd use a naming convention, so that a parameter 'xyz' corresponds to a named_scope 'xyz_form_filter', for instance.
I didn't include any error checking, you'll get a NoMethodError thrown if the right form filter doesn't exist.
This gives:

class Asset < ActiveRecord::Base
  belongs_to :account
  belongs_to :asset_type
  belongs_to :deal_type
  belongs_to :neighborhood
  belongs_to :settlement
  belongs_to :user
  named_scope :showeb, :conditions => {:showeb => 2}
  named_scope :ordered,  :order => 'created_at DESC'
  named_scope :demo, :conditions => {:demo => 1}
  named_scope :image144, :conditions => ["image_list != ?", "null"]
  named_scope :slideshow, :conditions => ["slideshow != ?", "null"]
  named_scope :status, :conditions => {:status => 2}
  named_scope :pr_from_form_filter, lambda {|*args| {:conditions => ["price_shekel >=?", (args.first || 0)]} }
  named_scope :pr_to_form_filter, lambda {|*args| {:conditions => ["price_shekel <=?", (args.first || 9999999999)]} }
  named_scope :rm_from_form_filter, lambda {|*args| {:conditions => ["rooms >=?", (args.first || 0)]} }
  named_scope :rm_to_form_filter, lambda {|*args| {:conditions => ["rooms <=?", (args.first || 9999)]} }
  named_scope :settlement_id_form_filter, lambda { |settlement_ids| {:conditions => {:settlement_id => settlement_ids.to_i} } }  
  named_scope :neighborhood_id_form_filter, lambda { |neighborhood_ids| {:conditions => ["neighborhood_id = ?", neighborhood_ids]} }  
  named_scope :assettype_id_form_filter, lambda { |assettype_ids| {:conditions => ["assettype_id = ?", assettype_ids]} }
  named_scope :dealtype_id_form_filter, lambda { |dealtype_ids| {:conditions => ["dealtype_id = ?", dealtype_ids]} } 
  
  def self.search(asset_params, page, records)
    main = showeb.ordered.demo.image144.slideshow.status
    asset_params.each do |key, value|
      main = main.send(:"#{key.to_s}_form_filter", value)
    end if asset_params
    main.paginate(:all, :page => page, :per_page => records)
  end
end

[Ruby] On Converting all umlaut characters to their base

2009-03-17T14:48:42-07:00

There are way more accents than these, like Ã§, Ã±, Ãª, Ã¨ and variations you have not included, like Ã«.
Here's a nifty way to strip them which will take care of all cases except for your ÃŸ. You decompose the code points (so Ã© becomes e+Â´) and go from there. You could remove all complex code points (like +Â´ see strip_to_ascii), but then you strip also any complex letters like ÃŸ or Ã¸. Instead I build ALL_ACCENTS from an example of all the accents I could find. That list is then used to strip all accents after they've been split from their underlying letters.

I don't speak german, but I believe the ÃŸ should be substituted with 'ss', not just a single 's' (see http://en.wikipedia.org/wiki/ÃŸ )

Note that there are ligatures to take care of (e.g. Å“ -> oe , ï¬ -> fi, see http://en.wikipedia.org/wiki/Typographical_ligature ), I don't know if there's a quick way to deal with all them without listing them all.

Here's the resulting code with both options. Your convert_umlaut_to_base should probably renamed to convert_to_ascii or something.

class String
  # returns an array of unicode codepoints, in canonical order
  def split_codepoints
    ActiveSupport::Multibyte::Handlers::UTF8Handler.normalize(self,:d).split(//u)
  end
  
  ALL_ACCENTS = "Ã¹ÃºÃ»Ã¼Å«Å¯Å±ÅÅ©Å³Ä£Ä—Ä›".split_codepoints.reject { |e| e.length == 1 }

  def strip_accents
    (split_codepoints - ALL_ACCENTS).join
  end
  
  def strip_to_ascii
    split_codepoints.reject { |e| e.length > 1 }.join
  end
end

# "MÃ¥Å—Ã§-Î›Ã±âˆ‚Å™Ã©".strip_to_ascii  => "Marc-nre"
# "MÃ¥Å—Ã§-Î›Ã±âˆ‚Å™Ã©".strip_accents  => "Marc-Î›nâˆ‚re"

def convert_umlaut_to_base(input)
  input.to_s.gsub(/ÃŸ/, 'ss').strip_accents
end

[Ruby] On While loop to get unique value

2009-01-13T01:49:28-08:00

...and if you favor using a while over recursion:

def create_vouchercode
  begin
    self.vouchercode = generate_vouchercode(8)
  end while find_by_vouchercode(vouchercode)
end

[Ruby] On Integer puzzle

2007-10-18T18:04:45-07:00

Well, I'd say I am such a candidate :-)

So, about your code, the last thing one could note is that it still has a pattern: ThousandRange, MixedRange and MillionRange are really similar and could be factorized. I think the very best way to do this is to go all the way and have a very generic "AnyRange" class (I called it GenericNumber). Coding it to be a bit more general (so that the basic units go only up to 100 instead of 1000) is not that much more difficult, and you end up with something looking like my code below. This can scale without any problem to ridiculously huge values. It took my mac less than 0.1 second to calculate the puzzle's answer, and less than 0.2 seconds to calculate the 33 trillionth letter for all numbers up to a quadrillion (it's "t" :-) It's also shorter.

I had lots of fun with this puzzle, thanks for your code, this site and everything...

# We deal with the problem by writing classes of numbers in tree form.
# Leaves can be a specific number (Centile), a generic centile (GenericValue) or a subtree (another GenericNumber).
# Each such GenericNumber can be expanded one level by replacing the leftmost GenericValue by specific values.
# This is done using GenericNumber.each; the other important method is children, which calculates recursively 
# information about all the children: sum, size of strings, number.

# All language dependent constants:
TO_TWENTY =   { 0 => '', 1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four',
                5 => 'five', 6 => 'six', 7 => 'seven', 8 => 'eight', 9 => 'nine',
               10 => 'ten', 11 => 'eleven', 12 => 'twelve', 13 => 'thirteen', 14 => 'fourteen',
               15 => 'fifteen', 16 => 'sixteen', 17 => 'seventeen',  18 => 'eighteen', 19 => 'nineteen' }
DECADES  =     { 2 => 'twenty', 3 => 'thirty', 4 => 'forty', 5 => 'fifty',
                6 => 'sixty', 7 => 'seventy', 8 => 'eighty', 9 => 'ninety' }
MAGNITUDES = { 100 => 'hundred', 1000 => 'thousand', 1_000_000 => 'million' }

require 'delegate'
class Centile < DelegateClass(Fixnum)
  NAMES = Array.new(100) {|n| n < TO_TWENTY.length ? TO_TWENTY[n] : DECADES[n/10] + TO_TWENTY[n%10]}
  
  def to_s
    NAMES[self]
  end
  
  def children
    {:nb =>1, :including_zero => 0==self.to_i, :sizes => to_s.size, :sum => self.to_i}
  end
  
  def <=>(anOther)
    to_s <=> anOther.to_s
  end
end

VARIABLE='*'

class GenericValue < Range
  def initialize(to)
    super(0,to,:exclusive)
  end
  
  def to_s
    VARIABLE
  end

  def children
    @children_cache ||= {:nb => self.end, :including_zero => true, :sizes=> inject(0){|sum, n| sum + n.children[:sizes] }, :sum=>self.end*(self.end-1)/2}
  end

  def each
    super {|n| yield Centile.new(n)}
  end
end

class GenericNumber
  include Enumerable, Comparable

  def initialize(left, right, multiplier = {:name => MAGNITUDES[right.children[:nb]], :value => right.children[:nb]})
    @left = left
    @right = right
    @multiplier = multiplier
  end
  
  def each
    if @left.children[:nb] > 1
      @left.each do |n|
        if 0==n
          @right.each{|n| yield n}
        else
          yield GenericNumber.new(n, @right, @multiplier)
        end
      end
    else
       @right.each{|n| yield GenericNumber.new(@left, n, @multiplier)}
    end
  end
 
  def children
    # The information on all children is computed with extra care for zeros, because we don't write "(zero)hundred"
    @children_cache ||= {
      :nb             => @left.children[:nb] * @right.children[:nb],
      :including_zero => @left.children[:including_zero] && @right.children[:including_zero],
      :sizes          =>(@left.children[:sizes] + (@left.children[:nb] - (@left.children[:including_zero] ? 1 : 0))  * @multiplier[:name].size) *
                         @right.children[:nb] + @right.children[:sizes]*@left.children[:nb],
      :sum            => @left.children[:sum] * @multiplier[:value] * @right.children[:nb] + @right.children[:sum] * @left.children[:nb]
     }
  end
  
  def to_s
    @str_cache ||= @left.to_s + (@left.to_s[-1] == VARIABLE[-1] ? '' : @multiplier[:name] + @right.to_s)
  end

  def <=>(anOther)
    to_s <=> anOther.to_s
  end

end
to_ten        = GenericValue.new(10)
to_a_hundred  = GenericValue.new(100)
to_a_thousand = GenericNumber.new(to_ten, to_a_hundred)
to_a_million  = GenericNumber.new(to_a_thousand, to_a_thousand)
to_a_billion  = GenericNumber.new(to_a_thousand, to_a_million)

@target = 51_000_000_000
@sum = @size = 0

# Caution: different genericNumbers can be "equal", since they have the same representation,
# for example 1xx == 1xxxxx == 'onehundred*' so we have to deal with groups of similar string values.
def expandAndGroup(genericNumbers)
  group = []
  genericNumbers.collect{ |n| n.to_a }.flatten.sort.each do |curNumber|
    unless curNumber == group[0]
      yield group
      group = []
    end
    group <<= curNumber
  end
  yield group
end

def seek(genericNumbers)
  expandAndGroup(genericNumbers) do |group|
    new_size = group.inject(@size) { |sum, n| sum + n.children[:sizes] }
    # recurse if we'll reach target and we are not dealing with _one_ _fixed_ number:
    return seek(group) if (new_size >= @target) && ((group.size > 1) || (group[0].children[:nb]>1)) 
    @size, @sum = new_size, group.inject(@sum) { |sum, n| sum + n.children[:sum] }
    return group[0] if new_size >= @target
  end
end

puts 'Number is:', seek([to_a_billion]), 'Sum is: ', @sum, 'Size is: ', @size

[Ruby] On Integer puzzle

2007-10-18T00:14:09-07:00

Hi Daniel!
Congrats on solving this...
I have a couple of comments on your code.
1) You cheated! Well, ok, not cheated per say, but really, the big constants (e.g. 44_872_000) should all be calculated by your code, not hardcoded, no? Imagine for instance that you have to translate this program to French. Besides the obvious lists of words, you would have to change 5 constants in your program for it to work!
2) I think there's a (potential) bug. If the number we're looking for was the last of a range, it wouldn't seek(), add the full size and values and the range would be echoed, so you wouldn't get the right last letter...
3) If you actually do rework the seek method, why not alias child_values/sizes with value & size for the ITA::Number class, this way there won't be a need for the ugly test e.class == ITA::Number

I'm basically done having fun with a further "factorization" (more of a rewrite, actually...) I'll post it tomorrow.

Cheers!