numeron 1.2.0 → 1.3.0

data/README.md

@@ -3,14 +3,10 @@
 ヌメロンの解の探索プログラム (Ruby版, 3桁Only)
 
 1. 解として可能性のある数値を自動計算
-2. Shuffle可能
+2. ダブル(されたあとの開放されたカード番号指定), ターゲット, チェンジ, ハイアンドロー, スラッシュ, シャッフルに対応
 3. 次に出すべき1手を計算してくれるAnalyzer
 4. シミュレーター付き(要実装)
 
-Androidアプリ ... https://play.google.com/store/apps/details?id=com.jpn.gemstone.numer0n.android
-
-iPhoneアプリ  ... https://itunes.apple.com/jp/app/numer0n-numeron/id512484171?mt=8
-
 ## インストール
 
 ruby 1.9以上が必要です
@@ -25,15 +21,92 @@ irbで実行します
 > require 'numeron'
 true
 > Numeron::Solver.new.run
+action (item|question|think|finish|help): 
+```
+
+### actionの説明
+
+```
+item ... アイテムを使う、使われた場合はこれを入力。0 または i をいれてもアイテム利用コンソールが起動する
+question ... 相手に対して、3桁の数値をコールする。
+think ... 答えを計算します。
+finish ... 終了
+```
+
+### itemの説明
+
+ダブルから順番に使用するアイテムを聞かれますので、使用する箇所でyes or yを入力します。
+
+```
+Using double ? [yes]: 
+Using shuffle ? [yes]: 
+Using change ? [yes]: 
+Using target ? [yes]: 
+Using high_and_low ? [yes]: 
+Using slash ? [yes]:
+```
+
+#### double
+
+```
+Input open number: # <= 相手が開けた数値を入力します。(0 から 9)
+Input open position [0, 1, 2]: # <= 開けた数値の位置を入力します。(0が一番左側)
+```
+
+#### shuffle
+
+特に入力は求められません
+
+#### change
+
+```
+Input change position: # <= 相手がチェンジした位置を入力します。(0が一番左側)
+Input high or low: # <= チェンジした数値がhigh なのか low なのかを入力します
+```
+
+#### target
+
+```
+Input open number: # <= ターゲットで指定した番号を入力します。(0から9)
+Input open position.
+If the enemy does not open card position, don't put anything
+Input [0, 1, 2, or empty]: # <= その番号が存在した場合はその位置を入力します(0が一番左側), 存在しなかった場合は何も入力しません。
+```
+
+#### high_and_low
+
+```
+position 0 is high? [yes|no]: # <= 左側がhighの場合は yes or y, lowの場合はno or nを入力
+position 1 is high? [yes|no]: # <= 真ん中がhighの場合は yes or y, lowの場合はno or nを入力
+position 2 is high? [yes|no]: # <= 右側がhighの場合は yes or y, lowの場合はno or nを入力
+```
+
+#### slash
+
+```
+Input slash number: # <= slashナンバーを入力
+```
+
+### questionの説明
+
+コールした数値とその解答を入力するメイン部分です。
+
+```
 Attack number: 123 # <= callした数値を入力
 Eat number: 0 # <= callした結果 eatの数を入力
 Bite number: 0 # <= callした結果 biteの数を入力
-... thinking
-possibilities: 210 # <= 計算した結果、答えとして可能性がある数値の個数
-Analyzer Answer: 372 # <= Analyzerがおすすめの答えとして選んだ数
-Possibilitiy list random: 798 # <= 答えの可能性の一覧からランダムで選んだ数
+```
+
+### thinkの説明
+
+PCが計算した答えを表示してくれます。
+結構適当です。
 
-finish? [yes|no] # <= yes or yで終了, noで続行
+```
+... thinking
+possibilities: 48 # <= 答えの可能性として考えられる個数
+Analyzer Answer: 789 # <= アナライザーが出した答え
+Possibilitiy list random: 345 # <= 答えの候補からランダムで取り出した数値
 ```
 
 ## Simulatorの使い方

data/lib/numeron/calculator.rb

@@ -18,6 +18,7 @@ module Numeron
       @possibilities = nil
       @mays = [(0..9).to_a, (0..9).to_a, (0..9).to_a]
       @answer_size = answer_size
+      @slash_number = nil
     end
 
     # コールした数値とその結果を設定
@@ -60,11 +61,15 @@ module Numeron
       return true
     end
 
-    # 0 Eat 0 Bite の時の可能性計算
-    def zero_eat_zero_bite(attack)
-      @mays[0] = @mays[0] - attack
-      @mays[1] = @mays[1] - attack
-      @mays[2] = @mays[2] - attack
+
+    # シャッフル
+    def shuffle
+      # 使用確定数字を計算(候補数が1つの場合)
+      fixed = @mays.select{|f| f.size == 1}.flatten
+
+      @mays[0] = @mays[0] | @mays[1] | @mays[2]
+      @mays[1] = @mays[0] | @mays[1] | @mays[2]
+      @mays[2] = @mays[0] | @mays[1] | @mays[2]
 
       list = []
       @mays[0].each do |i|
@@ -72,11 +77,129 @@ module Numeron
           next if i == j
           @mays[2].each do |k|
             next if i == k || j == k
-            list << validation(i, j, k)
+            if fixed.size == 0
+              list << validation(i, j, k)
+            else
+              fixed.each do |f| # ちょっと計算量がおおいか。。。
+                list << validation(f, j, k)
+                list << validation(i, f, k)
+                list << validation(i, j, f)
+              end
+            end
           end
         end
       end
-      update_possibilities(list)
+
+      @possibilities = list.compact.uniq
+      @histories.each do |history|
+        eat_and_bite = history[:eat] + history[:bite]
+        if eat_and_bite == 1
+          one_eat_or_one_bite(history[:attack])
+        elsif eat_and_bite == 2
+          two_eat_or_two_bite(history[:attack])
+        end
+      end
+      calc_slash
+    end
+
+    # スラッシュ
+    # @param [Integer] number スラッシュナンバー
+    def slash(number)
+      @slash_number = number
+      calc_slash
+    end
+
+    # チェンジ
+    # チェンジする桁数の指定とその数値がhigh or lowどちらなのかを宣言する
+    # @param [Integer] position チェンジを実行した位置。 0 - 2の範囲
+    # @param [Boolean] is_high チェンジしたカードがhighかどうか
+    def change(position, is_high)
+      raise ArgumentError, 'Invalid argument. position is 0 to 3' if position < 0 && position > 2
+
+      _possibilities = is_high ? [5, 6, 7, 8, 9] : [0, 1, 2, 3, 4]
+      @mays.each_with_index do |may, i|
+        _possibilities -= may if may.size == 1
+        if i != position
+          tmp = may.select {|f| is_high ? f > 4 : f <= 4 }
+          next if tmp.size != 1
+          @mays[i] -= tmp
+        end
+      end
+      # 3種類に絞りこまれていたら、残りの種類であることが確定
+      x = (@mays[0] + @mays[1] + @mays[2]).uniq
+      _possibilities -= x if x.size == 3
+      @mays[position] = _possibilities
+
+      # 可能性の再計算
+      @possibilities = recalculate
+    end
+
+    # ダブル
+    # 相手がダブルを使用し、カードの数値を公開した場合
+    def double(number, position)
+      target(number, position)
+    end
+
+    # ハイ&ロー
+    # @param [Array] result [true, false, true] で high, low, high を示す 
+    def high_and_low(result = [])
+      raise ArgumentError, 'Invalid argument.' if result.size != 3
+
+      result.each_with_index do |f, i|
+        @mays[i] = @mays[i] & (f ? [5, 6, 7, 8, 9] : [0, 1, 2, 3, 4])
+      end
+      update_possibilities(recalculate)
+    end
+
+    # ターゲット
+    # @param [Integer] number 0 から 9までの数値
+    # @param [Integer] position 指定した番号がヒットだった場合の、桁。ヒットでなければnilを指定
+    def target(number, position = nil)
+      raise ArgumentError, 'Invalid argumet. number is 0 to 9' if number < 0 && number > 9
+      raise ArgumentError, 'Invalid argument. position is nil or 0 to 3' if !position.nil? && position < 0 && position > 2
+      if position.nil?
+        3.times {|i| @mays[i] = @mays[i] - [number]}
+      else
+        @mays[position] = [number]
+      end
+      update_possibilities(recalculate)
+    end
+
+  protected
+
+    # 各桁の可能性を元に再度可能性リストを作り直す
+    def recalculate
+      reject
+      [].tap do |list|
+        @mays[0].each do |i|
+          @mays[1].each do |j|
+            next if i == j
+            @mays[2].each do |k|
+              next if i == k || j == k
+              list << validation(i, j, k)
+            end
+          end
+        end
+      end.compact.uniq
+    end
+
+    # 確定数値が存在する場合その数値を除外する
+    def reject
+      @mays.each_with_index do |may, i|
+        next if may.size != 1
+        @mays.each_with_index do |f, j|
+          next if i == j
+          @mays[j] = @mays[j] - may
+        end
+      end
+    end
+
+    # 0 Eat 0 Bite の時の可能性計算
+    def zero_eat_zero_bite(attack)
+      @mays[0] = @mays[0] - attack
+      @mays[1] = @mays[1] - attack
+      @mays[2] = @mays[2] - attack
+      update_possibilities(recalculate)
     end
 
     # 0 Eat 1 Bite の時の可能性計算
@@ -90,24 +213,24 @@ module Numeron
       (@mays[0] - attack).each do |i|
         (@mays[1] - attack).each do |j|
           next if i == j
-          list << validation(i, j, attack[0]) if attack[0] != i || attack[0] != j
-          list << validation(i, j, attack[1]) if attack[1] != i || attack[1] != j
+          list << validation(i, j, attack[0])
+          list << validation(i, j, attack[1])
         end
       end
 
       (@mays[0] - attack).each do |i|
         (@mays[2] - attack).each do |k|
           next if i == k
-          list << validation(i, attack[0], k) if attack[0] != i || attack[0] != j
-          list << validation(i, attack[2], k) if attack[1] != i || attack[1] != j
+          list << validation(i, attack[0], k)
+          list << validation(i, attack[2], k)
         end
       end
 
       (@mays[1] - attack).each do |j|
         (@mays[2] - attack).each do |k|
           next if j == k
-          list << validation(attack[1], j, k) if attack[1] != j || attack[1] != k
-          list << validation(attack[2], j, k) if attack[2] != j || attack[2] != k
+          list << validation(attack[1], j, k)
+          list << validation(attack[2], j, k)
         end
       end
       update_possibilities(list)
@@ -255,32 +378,6 @@ module Numeron
       end
     end
 
-    # シャッフル
-    def shuffle
-      @mays[0] = @mays[0] | @mays[1] | @mays[2]
-      @mays[1] = @mays[0] | @mays[1] | @mays[2]
-      @mays[2] = @mays[0] | @mays[1] | @mays[2]
-      list = []
-      @mays[0].each do |i|
-        @mays[1].each do |j|
-          next if i == j
-          @mays[2].each do |k|
-            next if i == k || j == k
-            list << validation(i, j, k)
-          end
-        end
-      end
-      @possibilities = list.compact
-      @histories.each do |history|
-        eat_and_bite = history[:eat] + history[:bite]
-        if eat_and_bite == 1
-          one_eat_or_one_bite(history[:attack])
-        elsif eat_and_bite == 2
-          two_eat_or_two_bite(history[:attack])
-        end
-      end
-    end
-
     # シャッフル時の再計算
     # 1 Eat 0 Bite または 0 Eat 1 Biteの場合
     def one_eat_or_one_bite(attack)
@@ -349,13 +446,10 @@ module Numeron
       update_possibilities(list)
     end
 
-    def slash(slash_number)
-      @slash_number = slash_number
-
-      # 9
-      # [0, 9]
+    def calc_slash
+      return if @slash_number.nil?
       list = []
-      slash_number.upto(9){|i|
+      @slash_number.upto(9){|i|
         min = i - slash_number
         from = min + 1
         to = i - 1
@@ -373,10 +467,10 @@ module Numeron
 
     # 可能性リストの更新
     # 現在設定されている可能性リストと引数で渡された可能性リストの論理積をとる
-    # @param [Array] possibilities 可能性としてありえる数値リスト
-    def update_possibilities(possibilities)
-      possibilities.compact!
-      @possibilities = @possibilities.nil? ? possibilities : possibilities & @possibilities
+    # @param [Array] list 可能性としてありえる数値リスト
+    def update_possibilities(list)
+      list.compact!
+      @possibilities = @possibilities.nil? ? list : list & @possibilities
     end
   end
 end

data/lib/numeron/solver.rb

@@ -6,28 +6,150 @@ module Numeron
     def initialize
       @calc = Numeron::Calculator.new
       @card_size = 3
-      @used_items = {slash: false, shuffle: false}
+      @used_items = {double: false, shuffle: false, change: false, target: false, high_and_low: false, slash: false}
     end
 
     def run
       while 1
-        item
-        next unless question
-        think
-        finish
+        print "action (item|question|think|finish|help): "
+        input = STDIN.gets.chomp.downcase
+        if %w(0 i item).include?(input)
+          item
+        elsif %w(1 q question).include?(input)
+          question
+        elsif %w(2 t think).include?(input)
+          think
+        elsif %w(3 f finish).include?(input)
+          break
+        else
+          help
+        end
       end
     end
 
+    def help
+      puts "----- help messege -----"
+      puts "item ... using item, shortcut 0 or i"
+      puts "question ... call 3 digits numbers, shortcut 1 or q"
+      puts "think ... thinking answer, shortcut 2 or t"
+      puts "finish ... exit this console, shortcut 3 or f"
+    end
+
     # アイテムの使用
     def item
-      shuffle unless @used_items[:shuffle]
-      slash unless @used_items[:slash]
+      @used_items.each do |f|
+        next if f[1] == true
+        print "Using " + f[0].to_s + " ? [yes]: "
+        input = STDIN.gets.chomp.downcase
+        next if input != 'yes' && input != 'y'
+        send(f[0])
+        @used_items[f[0]] = true
+        break
+      end
+    end
+
+    def double
+      position = nil
+      number = nil
+
+      while 1
+        print "Input open number: "
+        f = STDIN.gets.chomp.to_i
+        if f >= 0 && f <= 9
+          number = f
+          break
+        else
+          puts "Input error. Please input 0 to 9 number."
+        end
+      end
+
+      while 1
+        print "Input open position [0, 1, 2]: "
+        f = STDIN.gets.chomp.to_i
+        if f >= 0 && f <= 2
+          position = f
+          break
+        else
+          puts "Input error. Please input 0 or 1 or 2."
+        end
+      end
+
+      @calc.double(number, position)
+    end
+
+    def target
+      position = nil
+      number = nil
+
+      while 1
+        print "Input open number: "
+        f = STDIN.gets.chomp.to_i
+        if f >= 0 && f <= 9
+          number = f
+          break
+        else
+          puts "Input error. Please input 0 to 9 number."
+        end
+      end
+
+      while 1
+        puts "Input open position."
+        puts "If the enemy does not open card position, don't put anything"
+        print "Input [0, 1, 2, or empty]: "
+        f = STDIN.gets.chomp.to_i
+        position = f if f >= 0 && f <= 2
+        break
+      end
+
+      @calc.target(number, position)
+    end
+
+    def change
+      position = nil
+      is_high = nil
+      while 1
+        print "Input change position: "
+        f = STDIN.gets.chomp.to_i
+        if f >= 0 && f <= 2
+          position = f
+          break
+        else
+          puts "Input error. Please input 0 to 2 number."
+        end
+      end
+
+      while 1
+        print "Input high or low: "
+        f = STDIN.gets.chomp.downcase
+        if f == 'high' || f == 'low'
+          is_high = f == 'high'
+          break
+        else
+          puts "Input error. Please input high or low."
+        end
+      end
+
+      @calc.change(position, is_high)
+    end
+
+    def high_and_low
+      result = []
+      3.times do |i|
+        while 1
+          print "position " + i.to_s + " is high? [yes|no]: "
+          input = STDIN.gets.chomp.downcase
+          if ['yes', 'y', 'no', 'n'].include?(input)
+            result[i] = (input == 'yes' || input == 'y')
+            break
+          else
+            puts "Input error. Please input yes or no."
+          end
+        end
+      end
+      @calc.high_and_low(result)
     end
 
     def slash
-      print "\nUsing slash? [yes]"
-      f = STDIN.gets.chomp
-      return if f != 'yes' && f != 'y'
       while 1
         print "Input slash number: "
         f =STDIN.gets.chomp.to_i
@@ -35,17 +157,10 @@ module Numeron
         puts "Invalid slash number."
       end
       @calc.slash(f)
-      @used_items[:slash] = true
-      think
     end
 
     def shuffle
-      print "\nUsing shuffle? [yes]"
-      f = STDIN.gets.chomp
-      return if f != 'yes' && f != 'y'
       @calc.shuffle
-      @used_items[:shuffle] = true
-      think
     end
 
     def question
@@ -121,17 +236,5 @@ module Numeron
       end
       puts "Possibilitiy list random: " + @calc.possibilities.sample.to_s
     end
-
-    def finish
-      while 1
-        print "\nfinish? [yes] "
-        f = STDIN.gets.chomp
-        if(f == 'yes' || f == 'y')
-          exit
-        else
-          break
-        end
-      end
-    end
   end
 end

data/lib/numeron/version.rb

@@ -1,3 +1,3 @@
 module Numeron
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/numeron.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version       = Numeron::VERSION
   gem.authors       = ["kengos"]
   gem.email         = ["kengo@kengos.jp"]
-  gem.description   = %q{numer0nの解を計算します。(Shuffle, Slash対応, シミュレーター付き, Analyzer未完成)}
-  gem.summary       = %q{numer0n solver}
+  gem.description   = %q{numer0nの解を計算します。すべてのアイテム(ダブル, チェンジ, スラッシュ, シャッフル, ターゲット, ハイアンドロー)に対応。シミュレーター付き, Analyzerは適当)}
+  gem.summary       = %q{numer0n solver.}
   gem.homepage      = "https://github.com/kengos/numeron"
 
   gem.files         = `git ls-files`.split($/)

data/spec/lib/numeron/calculator_spec.rb

@@ -76,6 +76,36 @@ describe Numeron::Calculator do
       calc.shuffle
       calc.possibilities.should have(378).items
     end
+
+    it "mays[0] is 3 and shuffle" do
+      calc.mays[0] = [3]
+      calc.shuffle
+      # 3が利用されているのは確定
+      calc.mays[0].should =~ (0..9).to_a
+      calc.mays[1].should =~ (0..9).to_a
+      calc.mays[2].should =~ (0..9).to_a
+
+      calc.possibilities.should have(216).items
+    end
+
+    context 'using slash' do
+      it 'slash 2' do
+        calc.slash(2)
+        calc.possibilities.should have(48).items
+        calc.shuffle
+        calc.possibilities.should have(48).items
+      end
+
+      it '1e1b, slash 2, shuffle' do
+        calc.input('123', 1, 1)
+        calc.possibilities.should have(42).items
+        calc.slash(2)
+        calc.possibilities.should =~ %w(021 102 243 324)
+        calc.shuffle
+        # 数字の組み合わせは 012 or 234のみなので、 (3 * 2 * 1) * 2 = 12パターン
+        calc.possibilities.should =~ %W(021 012 201 210 102 120 243 234 342 324 432 423)
+      end
+    end
   end
 
   describe '#slash' do
@@ -122,6 +152,126 @@ describe Numeron::Calculator do
     end
   end
 
+  describe '#change' do
+    it '0, true' do
+      calc.change(0, true)
+      calc.mays[0].should == (5..9).to_a
+    end
+
+    it '1, false' do
+      calc.change(1, false)
+      calc.mays[1].should == (0..4).to_a
+    end
+
+    it '234(0e3b), change(0, false)' do
+      calc.input('234', 0, 3) # answer 342
+      calc.change(0, false) # answer 142
+      calc.mays[0].should =~ [0, 1]
+      calc.mays[1].should =~ [2, 4]
+      calc.mays[2].should =~ [2, 3]
+      calc.possibilities.should =~ %w(023 042 043 123 142 143)
+    end
+
+    it '345(0e3b), change(0, false), shuffle' do
+      calc.input('345', 0, 3) # answer 453
+      calc.change(0, false) # 253
+      calc.mays[0].should == [0, 1, 2]
+      calc.mays[1].should == [5]
+      calc.mays[2].should == [3, 4]
+      calc.possibilities.should =~ %w(054 053 153 154 253 254)
+      calc.shuffle
+      calc.mays[0].should =~ [0, 1, 2, 3, 4, 5]
+      calc.mays[1].should =~ [0, 1, 2, 3, 4, 5]
+      calc.mays[2].should =~ [0, 1, 2, 3, 4, 5]
+      # 5確定なので、 3 * 5 * 4 = 60 (5の位置3箇所) * (5を除く可能性数) * (5を除く可能性数 - 1つ前の数値)
+      calc.possibilities.should have(60).items
+    end
+
+    it '456(0e3b), change(0, false)' do
+      calc.input('456', 0, 3) # answer 564
+      calc.change(2, false)
+      calc.mays[0].should == [5]
+      calc.mays[1].should == [6]
+      calc.mays[2].should == [0, 1, 2, 3]
+      calc.possibilities.should =~ %w(560 561 562 563)
+    end
+
+    it '1e2b, 0, false' do
+      calc.input('123', 1, 2) # 132
+      calc.change(0, false) # 432
+      calc.mays[0].should == [0, 4]
+      calc.mays[1].should == [1, 2, 3]
+      calc.mays[2].should == [1, 2, 3]
+      calc.possibilities.should =~ %w(012 013 021 023 031 032 412 413 421 423 431 432)
+    end
+  end
+
+  describe '#high_and_low' do
+    it 'simple' do
+      calc.high_and_low([true, false, true])
+      calc.mays[0].should =~ [5, 6, 7, 8, 9]
+      calc.mays[1].should =~ [0, 1, 2, 3, 4]
+      calc.mays[2].should =~ [5, 6, 7, 8, 9]
+      calc.possibilities.should have(100).items
+    end
+
+    it '345(0e3b), high_and_low' do
+      calc.input('345', 0, 3) # 4 5 3
+      calc.high_and_low([false, true, false])
+      calc.mays[0].should =~ [4]
+      calc.mays[1].should =~ [5]
+      calc.mays[2].should =~ [3]
+      calc.possibilities.should == %w(453)
+    end
+
+    it '345(1e2b), high_and_low' do
+      calc.input('354', 1, 2) # 4 5 3
+      calc.high_and_low([false, true, false])
+      calc.mays[0].should =~ [3, 4]
+      calc.mays[1].should =~ [5]
+      calc.mays[2].should =~ [3, 4]
+      calc.possibilities.should == %w(453)
+    end
+
+    it '345(0e1b), high_and_low' do
+      calc.input('354', 0, 1) # 4 6 2
+      calc.high_and_low([false, true, false])
+      calc.mays[0].should =~ [0, 1, 2, 4]
+      calc.mays[1].should =~ [6, 7, 8, 9]
+      calc.mays[2].should =~ [0, 1, 2, 3]
+
+      # [4] * [6, 7, 8, 9] * [0, 1, 2] + [0, 1, 2] * [6, 7, 8, 9] * [3] = 4 * 3 * 2 = 24
+      calc.possibilities.should have(24).items
+    end
+  end
+
+  describe '#target' do
+    it 'simple' do
+      calc.target(0, 0)
+      calc.mays[0].should =~ [0]
+      calc.mays[1].should =~ (1..9).to_a
+      calc.mays[2].should =~ (1..9).to_a
+      calc.possibilities.should have(72).items
+    end
+
+    it 'target(0, nil)' do
+      calc.target(0)
+      calc.mays[0].should =~ (1..9).to_a
+      calc.mays[1].should =~ (1..9).to_a
+      calc.mays[2].should =~ (1..9).to_a
+      calc.possibilities.should have(504).items
+    end
+
+    it '123(0e3b), target(1, 1)' do
+      calc.input('123', 0, 3)
+      calc.target(1, 1)
+      calc.mays[0].should =~ [3]
+      calc.mays[1].should =~ [1]
+      calc.mays[2].should =~ [2]
+      calc.possibilities.should =~ %w(312)
+    end
+  end
+
   describe "scenario" do
     it "1e0b, 1e2b" do
       calc.input('348', 1, 0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numeron
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-23 00:00:00.000000000 Z
 dependencies: []
-description: numer0nの解を計算します。(Shuffle, Slash対応, シミュレーター付き, Analyzer未完成)
+description: numer0nの解を計算します。すべてのアイテム(ダブル, チェンジ, スラッシュ, シャッフル, ターゲット, ハイアンドロー)に対応。シミュレーター付き,
+  Analyzerは適当)
 email:
 - kengo@kengos.jp
 executables: []
@@ -60,7 +61,7 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: numer0n solver
+summary: numer0n solver.
 test_files:
 - spec/lib/numeron/analyzer_spec.rb
 - spec/lib/numeron/calculator_spec.rb