以前やった迷路探索問題（人生を書き換える者すらいた。: 人材獲得作戦・４　試験問題ほか）の作者の問題らしい。
Gauche 穴掘り法で迷路作成
最短経路探索プログラムの試験問題を解いてみた

麻雀に詳しくないのでクラス名・変数名がおかしいかも。

結果の牌の組み合わせを Machi クラスとして MachiList クラスに保存していく。

Machi クラスには刻子・順子・アタマ・待ちをそれぞれインスタンス変数として別々に保持する。

check メソッドで残り牌の数を調べながら処理を振り分けている。

### 待ち
class Machi
  attr_accessor :kantsu, :juntsu, :atama, :machi
  def initialize(machi = nil)
    if machi.nil?
      @kantsu = []
      @juntsu = []
      @atama = ""
      @machi = ""
    else
      @kantsu = Array.new(machi.kantsu)
      @juntsu = Array.new(machi.juntsu)
      @atama = machi.atama
      @machi = machi.machi
    end
  end

  # 自身と machi との同一性チェック
  def has_same?(machi)
    if (@kantsu.sort <=> machi.kantsu.sort) == 0 and
       (@juntsu.sort <=> machi.juntsu.sort) == 0 and
       @atama == machi.atama and
       @machi == machi.machi
      return true
    else
      return false
    end
  end

  # データを配列にする
  # 待ち牌は [] で囲む
  def to_a
    return @kantsu.sort.concat(@juntsu.sort) << (@atama) << "[#{@machi}]"
  end
end

### 待ちリスト
class MachiList
  attr_accessor :list
  def initialize
    @list = []
  end

  # リストに待ちを追加する
  # 追加時に同一性チェックをする
  def add(machi)
    if is_unique?(machi)
      @list << machi
    end
  end

  # リストを印字する
  def print_list
    @list.each do |m|
      m.to_a.each do |s|
        if s.match(/^\d+$/)
          print "(#{s})"
        else
          print "#{s}"
        end
      end
      print "\n"
    end
  end

  # 待ちを探す
  def check(data, machi)
    c = count_rest(data)
    case c
    when 0
      self.add(machi)
    when 1
      1.upto(9).each do |i|
        if data[i] > 0
          tmp_mdata = Array.new(data)
          tmp_mmachi = Machi.new(machi)
          tmp_mdata[i] -= 1
          tmp_mmachi.machi = "#{i}"
          check(tmp_mdata, tmp_mmachi)
        end
      end
    when 2
      check_machi(data, machi)
    when 4
      check_kantsu(data, machi)
      check_juntsu(data, machi)
      check_atama(data, machi)
    else
      check_kantsu(data, machi)
      check_juntsu(data, machi)
    end
  end

  private

  # 刻子
  def check_kantsu(data, machi)
    1.upto(9).each do |i|
      if has_kantsu?(i, data)
        tmp_kdata = Array.new(data)
        tmp_kdata[i] -= 3
        tmp_kmachi = Machi.new(machi)
        tmp_kmachi.kantsu << "#{i}#{i}#{i}"
        check(tmp_kdata, tmp_kmachi)
      end
    end
  end

  # 順子
  def check_juntsu(data, machi)
    1.upto(9).each do |i|
      if has_juntsu?(i, data)
        tmp_jdata = Array.new(data)
        tmp_jdata[i] -= 1
        tmp_jdata[i+1] -= 1
        tmp_jdata[i+2] -= 1
        tmp_jmachi = Machi.new(machi)
        tmp_jmachi.juntsu << "#{i}#{i+1}#{i+2}"
        check(tmp_jdata, tmp_jmachi)
      end
    end
  end

  # アタマ
  def check_atama(data, machi)
    1.upto(9).each do |i|
      if has_atama?(i, data)
        tmp_adata = Array.new(data)
        tmp_adata[i] -= 2
        tmp_amachi = Machi.new(machi)
        tmp_amachi.atama = "#{i}#{i}"
        check(tmp_adata, tmp_amachi)
      end
    end
  end

  # 待ち
  def check_machi(data, machi)
    1.upto(9).each do |i|
      tmp_mdata = Array.new(data)
      tmp_mmachi = Machi.new(machi)
      if data[i] > 1
        tmp_mdata[i] -= 2
        tmp_mmachi.machi = "#{i}#{i}"
        check(tmp_mdata, tmp_mmachi)
      elsif data[i+1] and data[i] > 0 and data[i+1] > 0
        tmp_mdata[i] -= 1
        tmp_mdata[i+1] -= 1
        tmp_mmachi.machi = "#{i}#{i+1}"
        check(tmp_mdata, tmp_mmachi)
      elsif data[i+2] and data[i] > 0 and data[i+2] > 0
        tmp_mdata[i] -= 1
        tmp_mdata[i+2] -= 1
        tmp_mmachi.machi = "#{i}#{i+2}"
        check(tmp_mdata, tmp_mmachi)
      end
    end
  end

  # 刻子の候補を持っているかどうか
  def has_kantsu?(i, ary)
    ary[i] > 2
  end

  # 順子の候補を持っているかどうか
  def has_juntsu?(i, ary)
    if i < 8
      ary[i] > 0 and ary[i+1] > 0 and ary[i+2] > 0
    else
      false
    end
  end

  # アタマの候補を持っているかどうか
  def has_atama?(i, ary)
    ary[i] > 1
  end

  # 残り牌の数を調べる
  def count_rest(ary)
    count = 0
    1.upto(9).each do |i|
      if ary[i] > 0
        count += ary[i]
      end
    end
    count
  end

  # 重複する待ちがないかどうかをチェック
  def is_unique?(machi)
    @list.each do |m|
      if m.has_same?(machi)
        return false
      end
    end
    return true
  end
end

### ここからテスト

def str2num_array(str)
  ret_array = Array.new(10, 0)
  str.each_char do |c|
    ret_array[c.to_i] += 1
  end
  ret_array
end

def test(str)
  machilist = MachiList.new
  machi = Machi.new
  machilist.check(str2num_array(str), machi)
  machilist.print_list
end

haipai_list = [ "1112224588899",
                "1122335556799",
                "1112223335559",
                "1223344888999",
                "1112345678999" ]

haipai_list.each do |str|
  p str
  test(str)
  puts "------------------------------"
end

実行結果

"1112224588899"
(111)(222)(888)(99)[45]
------------------------------
"1122335556799"
(555)(123)(123)(99)[67]
(123)(123)(567)(55)[99]
(123)(123)(567)(99)[55]
------------------------------
"1112223335559"
(111)(222)(333)(555)[9]
(555)(123)(123)(123)[9]
------------------------------
"1223344888999"
(888)(999)(123)(234)[4]
(888)(999)(123)(44)[23]
(888)(999)(234)(234)[1]
------------------------------
"1112345678999"
(111)(999)(234)(567)[8]
(111)(999)(234)(678)[5]
(111)(999)(345)(678)[2]
(111)(234)(567)(99)[89]
(111)(234)(789)(99)[56]
(111)(456)(789)(99)[23]
(999)(123)(456)(11)[78]
(999)(123)(678)(11)[45]
(999)(345)(678)(11)[12]
(123)(456)(789)(11)[99]
(123)(456)(789)(99)[11]
------------------------------

プログラミング言語 Ruby

posted with amazlet at 10.04.06

まつもと ゆきひろ David Flanagan
オライリージャパン
売り上げランキング: 91254

Amazon.co.jp で詳細を見る

if __name__ == '__main__':
    # do something

同様のコードを Perl, Ruby, PHP で書く方法を調べてみた。

Perl の場合

if ($0 eq __FILE__) {
    # do something
}

Ruby の場合

if $0 == __FILE__
  # do something
end

PHP の場合

if (basename(__FILE__) == basename($_SERVER['PHP_SELF'])) {
    // do something
}

人生を書き換える者すらいた。: 人材獲得作戦・４　試験問題ほか

試験問題は迷路の最短経路探索プログラム。
最初、アルゴリズムとかがわからないので力技で解いてみたが、迷路内の空白が大きくなると処理が終らないのでアルゴリズムを調べてから再度実装してみた。
使ったアルゴリズムはダイクストラ法、こちらのサイト "ダイクストラ法（最短経路問題）" を参考にした。

あと、Gauche で解こうとしてみたが、行き詰まってしまったので Ruby で解いた。

追記：Gauche 版も解けた。

### ノードクラス
class Node
  def initialize(val, edges_to)
    @val = val        # マップ上での文字
    @edges_to = edges_to    # 各エッジの接続先のノード番号
    @edges_cost = []  # 各エッジのコスト
    @done = false     # 確定ノードか否か
    @cost = -1        # このノードへの現時点で判明している最小コスト
  end
  attr_accessor :val, :edges_to, :edges_cost, :done, :cost
end

### マップ文字列を2次元配列に変換する
def map2array(s_map)
  rt = []
  s_map.each{|line|
    rt.push(line.chomp.split(//))
  }
  return rt
end

### 接続先を探す
def find_movable(x, y, a_map)
  rt = []
  [[x,y-1], [x,y+1], [x-1,y], [x+1,y]].each{|v|
    if a_map[v[1]][v[0]].match(/(?:\s|S|G)/) then
      rt.push(v)
    end
  }
  return rt
end

### マップ配列(2次元)からノードリスト(配列)を作る
def array2nodelist(a_map)
  rt = []
  a_map.each_with_index{|y, i|
    _y = []
    y.each_with_index{|x, j|
      if x == ' ' || x == 'S' || x == 'G' then
        node = Node.new(x, find_movable(j,i,a_map))
        if x == 'S' then # スタートノードのコストを 0 にする
          node.cost = 0
        end
        _y.push(node)
      else
        _y.push(nil)
      end
    }
    rt.push(_y)
  }
  return rt
end

### ノードの座標を得る
def get_pos(nodes, str)
  nodes.each_with_index{|y,i|
    y.each_with_index{|x,j|
      if x && x.val == str then
        return [j,i]
      end
    }
  }
  return nil
end

### アルゴリズム実行
def search(nodes)

  # 確定ノードを探す
  while true
    done_node = nil
    nodes.each_with_index{|y,i|
      y.each_with_index{|x,j|
        if x then
          if x.done || x.cost < 0 then
            next
          end
          if done_node == nil || x.cost < done_node.cost then
            done_node = x
            break
          end
        end
      }
      if done_node then
        break
      end
    }
    # 確定ノードがなくなれば終了
    if done_node == nil
      break
    end

    # 確定フラグを立てる
    done_node.done = true
    # 接続先のノードの情報を更新する
    done_node.edges_to.each_with_index{|v, i|
      cost = done_node.cost + 1 # 各エッジのコストは 1
      nodes_to = nodes[v[1]][v[0]]
      if nodes_to.cost < 0 || cost < nodes_to.cost then
        nodes[v[1]][v[0]].cost = cost
      end
    }
  end

  return nodes
end

### 再帰的に最小コストの接続元ノードをたどり、valに'$'を代入していく
def get_from_node(node, nodes)
  if node then
    node.edges_to.each{|e|
      n = nodes[e[1]][e[0]]
      if n.cost == node.cost - 1 && n.val != 'S' then
        n.val = '$'
        return get_from_node(n, nodes)
      end
    }
  end
  return nil
end

### マップ文字列を受け取り、最短経路を探索して、結果のマップを印字する
def maiz(map_str)
  a_map = map2array(map_str)
  nodes = array2nodelist(a_map)
  result_nodes = search(nodes)
  goal_pos = get_pos(result_nodes, 'G')
  goal = result_nodes[goal_pos[1]][goal_pos[0]]
  get_from_node(goal, result_nodes)
  # 結果のマップを印字する
  result_nodes.each_with_index{|y,i|
    y.each_with_index{|x,j|
      if x then
        print x.val
      else
        print '*'
      end
    }
    print "\n"
  }
end

### 実行結果

# マップ文字列
$MAP1 =<<EOD
**********
*S*      *
* * ** * *
*   ** * *
***  *  G*
**********
EOD
$MAP2 =<<EOD
**************************
*S* *                    *
* * *  *  *************  *
* *   *    ************  *
*    *                   *
************** ***********
*                        *
** ***********************
*      *              G  *
*  *      *********** *  *
*    *        ******* *  *
*       *                *
**************************
EOD
$MAP3 =<<EOD
**************************
*S                       *
*                        *
*                        *
*                        *
*                        *
*                        *
*                        *
*                     G  *
*                        *
*                        *
*                        *
**************************
EOD

maiz($MAP1)
puts ""
maiz($MAP2)
puts ""
maiz($MAP3)

実行結果

$ ./maze.rb
**********
*S*$$$$$$*
*$*$** *$*
*$$$** *$*
***  *  G*
**********

**************************
*S* * $$$$               *
*$* *$$* $*************  *
*$* $$*  $$************  *
*$$$$*    $$$$$          *
**************$***********
* $$$$$$$$$$$$$          *
**$***********************
* $$$$$* $$$$$$$$$$$$$G  *
*  *  $$$$*********** *  *
*    *        ******* *  *
*       *                *
**************************

**************************
*S$$$$$$$$$$$$$$$$$$$$$  *
*                     $  *
*                     $  *
*                     $  *
*                     $  *
*                     $  *
*                     $  *
*                     G  *
*                        *
*                        *
*                        *
**************************

プログラミング言語 Ruby

posted with amazlet at 10.01.14

まつもと ゆきひろ David Flanagan
オライリージャパン
売り上げランキング: 24906

Amazon.co.jp で詳細を見る

文字列の配列を大文字・小文字を無視してソートする場合を考える。

# 文字列の配列
ary = ["foo", "Bar", "baz", "HOGE", "FUGA"]

# そのままソートすると
p ary.sort #=> ["Bar", "FUGA", "HOGE", "baz", "foo"]

# 大文字・小文字を無視してソートする（ブロックが繰り返される度に upcase が実行される）
p ary.sort {|x,y| x.upcase <=> y.upcase } #=> ["Bar", "baz", "foo", "FUGA", "HOGE"]

# 大文字・小文字を無視してソートする（upcase した要素と元の要素を含む配列を作り sort した後、元の要素のみを取り出す )
p ary.collect {|x| [x.upcase, x] }.sort.collect {|y| y[-1] } #=> ["Bar", "baz", "foo", "FUGA", "HOGE"]

# ruby に備わっている sort_by メソッドでシュワルツ変換を利用する。
p ary.sort_by {|x| x.upcase } #=> ["Bar", "baz", "foo", "FUGA", "HOGE"]

collect を使って一時配列を作ってソートする場合の一時配列を見てみる。

p ary.collect {|x| [x.upcase, x] }
#=> [["FOO", "foo"], ["BAR", "Bar"], ["BAZ", "baz"], ["HOGE", "HOGE"], ["FUGA", "FUGA"]]
p ary.collect {|x| [x.upcase, x] }.sort
#=> [["BAR", "Bar"], ["BAZ", "baz"], ["FOO", "foo"], ["FUGA", "FUGA"], ["HOGE", "HOGE"]]
p ary.collect {|x| [x.upcase, x] }.sort.collect {|y| y[-1] }
#=> ["Bar", "baz", "foo", "FUGA", "HOGE"]

まつもとゆきひろ コードの世界‾スーパー・プログラマになる14の思考法

posted with amazlet at 09.08.09

まつもとゆきひろ
日経BP出版センター
売り上げランキング: 6604

Amazon.co.jp で詳細を見る

#!/usr/bin/env ruby -w
# -*- coding: utf-8 -*-

$KCODE = "u"
require "jcode" # String クラスの tr メソッドで日本語を使用可能にする。

### ひらがな・カタカナ変換
def translator(from, to)
    lambda {|str| str.tr(from, to) }
end

upto = translator("a-z", "A-Z")
downto = translator("A-Z", "a-z")
hira2kata = translator("ぁ-ん", "ァ-ン")
kata2hira = translator("ァ-ン", "ぁ-ん")

puts upto.call("hello WORLD")   # => HELLO WORLD
puts downto.call("hello WROLD") # => hello wrold
puts hira2kata.call("こんにちはワールド") # => コンニチハワールド
puts kata2hira.call("こんにちはワールド") # => こんにちはわーるど

プログラミング言語 Ruby

posted with amazlet at 09.06.19

まつもと ゆきひろ David Flanagan
オライリージャパン
売り上げランキング: 66949

Amazon.co.jp で詳細を見る

$KCODE = "UTF8"
require "csv"

areas = Hash.new
total = 0
colnum = 4

CSV.open(ARGV[0], "r") {|row|
    address = row[colnum]
    city_name = address.slice(/[^市区]*(市|区)/)
    unless city_name then
        next
    end

    if areas.key?(city_name) then
        new_count = areas[city_name].to_i + 1
        areas.store(city_name, new_count)
    else
        areas.store(city_name, 1)
    end
    total = total + 1
}

areas.each {|key,val|
    puts "#{key}, #{val}"
}
puts "合計 #{total}"

csvデータの中身は以下のようになっている。
市（または区）別に集計をしていく。

"連番","法人名","法人電話番号","法人郵便番号","法人住所"
"1","安威小学校","072-xxx-xxxx","567-xxxx","大阪府茨木市安威x-xx-xx"
"5","茨木市立小学校東小学校","072-xxx-xxxx","567-xxxx","大阪府茨木市鮎川x-x-xx"
"9","茨木市立小学校清溪小学校","072-xxx-xxxx","568-xxxx","大阪府茨木市泉原xxx"
"16","茨木市立小学校茨木小学校","072-xxx-xxxx","567-xxxx","大阪府茨木市片桐町x-xx"
...
...
...
"116","金蘭千里中学校","06-xxxx-xxxx","565-xxxx","大阪府吹田市藤白台x-xx-x"
"117","弘済中学校","06-xxxx-xxxx","565-xxxx","大阪府吹田市古江台x-x-x"
"118","吹田市立中学校豊津西中学校","06-xxxx-xxxx","564-xxxx","大阪府吹田市豊津町x-x"

必要に応じてcsvファイルの文字コード・改行コードを変更する。
実行結果。

$ cat school_data_osaka.csv | nkf -dw >hoge
$ ./count.rb hoge
大阪府吹田市, 57
大阪府茨木市, 47
大阪府大阪市, 456
合計 560

Rubyレシピブック 第2版 268の技

posted with amazlet at 08.11.25

青木 峰郎 後藤 裕蔵 高橋 征義
ソフトバンク クリエイティブ
売り上げランキング: 63136

Amazon.co.jp で詳細を見る