Hatena::Grouprubyist

trotrの日記

2008-01-20

こんな風に生活してみたい* 14:12

=begin
  n -- 自分のこなせる仕事量
  a -- これからのスケジュール
=end

def divide n
  x = n / 2
  (2*x == n)? [x,x] : [x, x+1]
end

def divide_task(task, n)
  task.map{ |e| (e <= n)? e : divide_task(divide(e), n)}
end

def run(a, n)
  puts a.join(" => ")
  xs = divide_task(a, n)
  puts xs.map{ |e| layout(e)}.join(" => ")
end

def layout(e)
  e.respond_to?(:flatten)? e.flatten.join(",") : e
end

a = (1..10).to_a
run(a, 3) 
# >> 1 => 2 => 3 => 4 => 5 => 6 => 7 => 8 => 9 => 10
# >> 1 => 2 => 3 => 2,2 => 2,3 => 3,3 => 3,2,2 => 2,2,2,2 => 2,2,2,3 => 2,3,2,3

2008-01-19

ここの使い方* 14:12

ちょっとした記録はこちらに書いてみよう。

いつもはhttp://d.hatena*/trotr

重複の除去した配列を返す(Array#uniqもどき)* 14:12

require 'set'
xs = [2,1,2,3,7,2,1,7,2,23,4,4,7,5,6,3,2]

def d(seed)
  Set.new(seed).sort {|l, r| seed.index(l) <=> seed.index(r) }
end

def e(seed)
  Set.new(seed).sort_by{ |e| seed.index(e)} 
end

def f(seed)
  result = []
  xs = seed.dup
  until xs.empty?
    x = xs.shift
    result << x
    xs.delete(x)
  end
  result
end
f(xs) # => [2, 1, 3, 7, 23, 4, 5, 6]
xs #=>  # !> useless use of a variable in void context
def g(seed)
  seed.inject([]){ |re,e|re << e unless re.index(e); re}
end
g(xs) # => [2, 1, 3, 7, 23, 4, 5, 6]

require 'benchmark'
Benchmark.bmbm do |x|
  n = 1000
  %w{e f g}.each{ |e| x.report("#{e}:"){ n.times{ send(e,xs)} }}
end

# Rehearsal --------------------------------------
# e:   0.890000   0.150000   1.040000 (  1.041349)
# f:   0.250000   0.010000   0.260000 (  0.252573)
# g:   0.500000   0.090000   0.590000 (  0.598211)
# ----------------------------- total: 1.890000sec

#          user     system      total        real
# e:   0.840000   0.150000   0.990000 (  0.985385)
# f:   0.240000   0.010000   0.250000 (  0.248240)
# g:   0.520000   0.070000   0.590000 (  0.593549)

重複が多ければ多いほどfが有利になる。

2007-07-28階乗の計算

特に意味はないけど 00:16

def fanc1 n
  (n==1)? 1 : n * fanc1(n-1)
end
def fanc2 n
  (1..n).inject(1){ |result,ele| result*ele}
end
# puts "true" if (fanc1 3)==(fanc2 3)
require 'benchmark'
Benchmark.bmbm do |x|
  x.report("fanc1") {(1..1000).each{ |i| fanc1 i} }
  x.report("fanc2") {(1..1000).each{ |i| fanc2 i} }
end

結果

Rehearsal -----------------------------------------
fanc1   4.050000   0.200000   4.250000 (  4.399268)
fanc2   3.140000   0.330000   3.470000 (  3.939125)
-------------------------------- total: 7.720000sec

            user     system      total        real
fanc1   4.080000   0.280000   4.360000 (  4.890393)
fanc2   3.130000   0.310000   3.440000 (  3.810650)

困ったこと[後で考える]

emacsでコピーした文字列がfirefoxで貼り付けられない。何で?

追記
  • (setq x-select-enable-clipboard t)

これで解決。

http://freebsd.g.hatena.ne.jp/Cress/20070707 の中の人どうもありがと

2007-07-18

do-endと{ }の違い 05:17

rubyブロックを使うときに

  • do-endを使う方法
  • { } を使う方法

はほとんど同じような動作をしますが、解釈のされかたが少し違います。

通常

引数の0のかっこを省略しなければ、どちらも意図したとおりの動作を返します。

(1..3).inject(0) do sum, n| 
	sum + n 
end
  #もしくは  (1..3).inject(0) {|sum, n| sum + n} 
=>6

括弧がないとき

do-endの場合は
(1..3).inject 0 do |sum, n| sum + n end
=> 6
	
  # [1,2,3].( inject 0 { sum+n })  こんな感じに解釈されている
   ##==ここでの表記のしかた==
   ## (<レシーバ>.<メソッド> <引数>)
       ## (<レシーバ>.<メソッド> <引数> { <ブロックの中身> } ) ※ブロックがある場合
一方「{ }」を使った場合
(1..3).inject 0 {|sum, n| sum + n} 
=> SyntaxError: compile error

 # [1,2,3] .(inject ( 0 { sum+n } ) ) do-endとはちょっと解釈のされ方が違っている。
						 (0にブロックが渡されてしまっている。)

id:bongoleさんの事例*1

p [1,2,3].collect do |i| i  end.compact
=>nil
NameError: undefined method `compact' for nil:NilClass (NoMethodError)
  # (p ([1,2,3].collect ({ i }.compact) ) ) こんな感じかな?

p [1,2,3].collect { |i| i  }.compact 
=> [1, 2, 3]
  # (p (compact ([1,2,3].collect { i })) ) 

というわけで、compactメソッドが適応される対象が

となるので、上記のような違いが起きるんだと思います。

間違ってたらすみません><

*1:一行に収めるために、少し形を変えてあります。

trotrtrotr2008/04/19 18:39まちがっているかも><