numeron 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in numeron.gemspec
+gemspec
+
+group :development, :test do
+  gem 'tapp', :git => 'git://github.com/esminc/tapp.git'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'fuubar'
+  gem 'libnotify', :require => false
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'growl', :require => false
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 kengos
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# Numeron
+
+ヌメロンの解の探索プログラム (Ruby版)
+
+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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'numeron'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install numeron
+
+## Usage
+
+```
+irb
+```
+
+```
+> require 'numeron'
+true
+> Numeron::Solver.new.run
+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 # <= 答えの可能性の一覧からランダムで選んだ数
+
+finish? [yes|no] # <= yes or yで終了, noで続行
+```
+
+## Numeron::Calculator
+
+ヌメロンの解の可能性として考えられるものを計算する部分。
+
+
+基本
+
+```ruby
+calc = Numeron::Calculator.new
+calc.input('123', 0, 1) # callした番号, Eatの数, Biteの数
+p calc.possibilities # 答えの可能性の一覧がでてくる
+
+# 続いて以下のように245をcallして 2Eat, 0Biteだった場合 11個に絞りこまれる
+calc.input('245', 2, 0)
+p calc.possibilities
+# => ["240", "246", "247", "248", "249", "205", "265", "275", "285", "295", "345"]
+```
+
+Shuffle対応(ほとんどテストはしていない)
+
+```ruby
+calc = Numeron::Calculator.new
+calc.input('123', 0, 3)
+calc.shuffle # シャッフルされた
+p calc.possibilities.size
+# => 6
+
+calc = Numeron::Calculator.new
+calc.input('123', 1, 1)
+p calc.possibilities.size
+# => 42
+calc.shuffle
+p calc.possibilities.size
+# => 126
+```
+
+以下の2つの変数を用いている
+
+`@mays`
+
+@mays[0]が左側の数値の可能性リスト(初期値0-9)<br>
+@mays[1]が真ん中の数値の可能性リスト(初期値0-9)<br>
+@mays[2]が右側の数値の可能性リスト(初期値0-9)<br>
+
+`@possibilities`
+
+解の可能性リスト
+
+## Numeron::Analyzer
+
+案がなかったので、以下3つの分析方法を適当に実装。<br>
+計算量はまったく考慮していない
+
+0e1bを最悪ケースとして、このケースが出た場合に、最も可能性リストが少なくなる数値を計算する機能
+
+0e1b, 1e0bを最悪ケースとして、これらのケースが出た場合に、最も可能性リストの平均値が少なくなる数値を計算する機能
+
+可能性リスト中から、最も可能性リストが少なくなる数値を計算する機能
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/numeron.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+require 'numeron/version'
+require 'numeron/calculator'
+require 'numeron/solver'
+require 'numeron/analyzer'
+
+module Numeron
+end

data/lib/numeron/analyzer.rb

@@ -0,0 +1,140 @@
+# coding: utf-8
+
+module Numeron
+  class Analyzer
+    attr_accessor :calculator
+    def initialize(calculator)
+      @calculator = calculator
+    end
+
+    # 次の1手の計算
+    # @param [Symbol] mode :average or :worst
+    # @return [Hash] {recommend: [Array], size: Number}
+    def run(mode = :average, options = {})
+      case mode
+      when :average
+        run_average_mode(options[:cases])
+      when :worst
+        run_worstcase_mode(options[:worst_case])
+      when :possibilities
+        run_possibilities
+      end
+    end
+
+    # 最悪のケースを0e1b, 1e0bと想定し、それぞれの結果が出た際に可能性の平均値が最も少なくなるケースを推定する
+    def run_average_mode(cases = nil)
+      cases ||= [
+        {eat: 0, bite: 1},
+        {eat: 1, bite: 0}
+      ]
+      recommend = []
+      min_size = 10000
+      all_list.each do |f|
+        average = calc_average(f, cases)
+        if min_size == average
+          recommend << f
+        elsif min_size > average
+          recommend = [f]
+          min_size = average
+        end
+      end
+
+      { recommend: recommend, size: min_size }
+    end
+
+    # 最悪のケースを0e1bと推定し、その結果として最も可能性の数が最も少なくなるケースを推定する
+    def run_worstcase_mode(worst_case = {})
+      worst_case = {eat: 0, bite: 1}.merge(worst_case)
+      min_size = 10000
+      recommend = []
+      all_list.each do |f|
+        _calculator = build_calculator
+        _calculator.input(f, worst_case[:eat], worst_case[:bite])
+        if min_size == _calculator.possibilities.size
+          recommend << f
+        elsif min_size > _calculator.possibilities.size
+          recommend = [f]
+          min_size = _calculator.possibilities.size
+        end
+      end
+
+      { recommend: recommend, size: min_size }
+    end
+
+    def run_possibilities
+      possibilities = @calculator.possibilities.clone
+
+      recommend = []
+      min_size = 10000
+      cases = [
+        {eat: 0, bite: 0},
+        {eat: 0, bite: 1},
+        {eat: 0, bite: 2},
+        {eat: 1, bite: 0},
+        {eat: 1, bite: 1},
+        {eat: 2, bite: 0}
+      ]
+      possibilities.each do |f|
+        average = calc_average(f, cases, true)
+        if min_size == average
+          recommend << f
+        elsif min_size > average
+          recommend = [f]
+          min_size = average
+        end
+      end
+
+      { recommend: recommend, size: min_size }
+    end
+
+    # attackの結果、推定される結果に対する可能性の数の平均を計算する
+    # @example
+    #   [10, 20, 10, 0, 5, 0, 5]の場合は ( 10 + 20 + 10 + 5 + 5 ) / 5 = 10
+    def calc_average(attack, cases, can_zero = false)
+      result = []
+      cases.each do |pattern|
+        _calculator = build_calculator
+        _calculator.input(attack, pattern[:eat], pattern[:bite])
+        result << _calculator.possibilities.size
+      end
+
+      n = 0
+      sum = 0
+      result.each do |f|
+        sum = sum + f
+        n = n + 1 if f > 0
+      end
+
+      if n > 0
+        return sum.to_f / n.to_f
+      elsif can_zero
+        return 0
+      else
+        return 10000
+      end
+    end
+
+    def build_calculator
+      _calculator = Numeron::Calculator.new
+      _calculator.possibilities = @calculator.possibilities.clone
+      _calculator.mays = @calculator.mays.clone
+      _calculator.histories = @calculator.histories.clone
+      return _calculator
+    end
+
+    def all_list
+      [].tap do |f|
+        (0..9).to_a.each { |i|
+          (0..9).to_a.each { |j|
+            next if i == j
+            (0..9).to_a.each { |k|
+              next if i == k || j == k
+              f << i.to_s + j.to_s + k.to_s
+            }
+          }
+        }
+      end
+    end
+
+  end
+end

data/lib/numeron/calculator.rb

@@ -0,0 +1,320 @@
+# coding: utf-8
+
+module Numeron
+  class Calculator
+    attr_accessor :histories, :possibilities, :mays
+
+    def initialize(card_size = 3)
+      @histories = []
+      @mays = [(0..9).to_a, (0..9).to_a, (0..9).to_a]
+      @possibilities = nil
+    end
+
+    def input(attack, eat, bite)
+      attack = attack.split(//).map(&:to_i)
+      eat = eat.to_i
+      bite = bite.to_i
+      @histories << {attack: attack, eat: eat, bite: bite}
+
+      if eat == 0 && bite == 0
+        zero_eat_zero_bite(attack)
+      elsif eat == 0 && bite == 3
+        zero_eat_three_bite(attack)
+      elsif eat == 0 && bite == 2
+        zero_eat_two_bite(attack)
+      elsif eat == 0 && bite == 1
+        zero_eat_one_bite(attack)
+      elsif eat == 1 && bite == 2
+        one_eat_two_bite(attack)
+      elsif eat == 1 && bite == 1
+        one_eat_one_bite(attack)
+      elsif eat == 1 && bite == 0
+        one_eat_zero_bite(attack)
+      elsif eat == 2 && bite == 0
+        two_eat_zero_bite(attack)
+      else
+        return false
+      end
+      return true
+    end
+
+    def zero_eat_zero_bite(attack)
+      @mays[0] = @mays[0] - attack
+      @mays[1] = @mays[1] - attack
+      @mays[2] = @mays[2] - attack
+
+      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
+      update_possibilities(list)
+    end
+
+    def zero_eat_one_bite(attack)
+      # 各桁のeatの可能性がなくなる
+      @mays[0] = @mays[0] - [attack[0]]
+      @mays[1] = @mays[1] - [attack[1]]
+      @mays[2] = @mays[2] - [attack[2]]
+
+      list = []
+      (@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
+        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
+        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
+        end
+      end
+      update_possibilities(list)
+    end
+
+    def zero_eat_two_bite(attack)
+      @mays[0] = @mays[0] - [attack[0]]
+      @mays[1] = @mays[1] - [attack[1]]
+      @mays[2] = @mays[2] - [attack[2]]
+      list = []
+
+      # 先頭不明
+      (@mays[0] - attack).each do |f|
+        list << validation(f, attack[0], attack[1])
+        list << validation(f, attack[2], attack[0])
+        list << validation(f, attack[2], attack[1])
+      end
+
+      # 中央不明
+      (@mays[1] - attack).each do |f|
+        list << validation(attack[1], f, attack[0])
+        list << validation(attack[2], f, attack[0])
+        list << validation(attack[2], f, attack[1])
+      end
+
+      # 末尾不明
+      (@mays[2] - attack).each do |f|
+        list << validation(attack[1], attack[0], f)
+        list << validation(attack[1], attack[2], f)
+        list << validation(attack[2], attack[0], f)
+      end
+      update_possibilities(list)
+    end
+
+    def zero_eat_three_bite(attack)
+      # 各桁の可能性が2つに絞られる
+      @mays[0] = @mays[0] & [attack[1], attack[2]]
+      @mays[1] = @mays[1] & [attack[0], attack[2]]
+      @mays[2] = @mays[2] & [attack[0], attack[1]]
+      list = [
+        validation(attack[1], attack[2], attack[0]),
+        validation(attack[2], attack[0], attack[1])
+      ].compact
+      update_possibilities(list)
+    end
+
+    def one_eat_zero_bite(attack)
+      list = []
+      # 先頭eat
+      (@mays[1] - attack).each do |j|
+        (@mays[2] - attack).each do |k|
+          next if j == k
+          list << validation(attack[0], j, k)
+        end
+      end
+
+      # 真ん中eat
+      (@mays[0] - attack).each do |i|
+        (@mays[2] - attack).each do |k|
+          next if i == k
+          list << validation(i, attack[1], k)
+        end
+      end
+
+      # 末尾eat
+      (@mays[0] - attack).each do |i|
+        (@mays[1] - attack).each do |j|
+          next if i == j
+          list << validation(i, j, attack[2])
+        end
+      end
+      update_possibilities(list)
+    end
+
+    def one_eat_one_bite(attack)
+      list = []
+      (@mays[2] - attack).each do |f|
+        list << validation(attack[0], attack[2], f)
+      end
+      (@mays[1] - attack).each do |f|
+        list << validation(attack[0], f, attack[1])
+      end
+      # 2桁目があっている
+      (@mays[2] - attack).each do |f|
+        list << validation(attack[2], attack[1], f)
+      end
+      (@mays[0] - attack).each do |f|
+        list << validation(f, attack[1], attack[0])
+      end
+      # 3桁目があっている
+      (@mays[0] - attack).each do |f|
+        list << validation(f, attack[0], attack[2])
+      end
+      (@mays[1] - attack).each do |f|
+        list << validation(attack[1], f, attack[2])
+      end
+      update_possibilities(list)
+    end
+
+    def one_eat_two_bite(attack)
+      # attack以外の可能性がなくなるので、積
+      @mays[0] = @mays[0] & attack
+      @mays[1] = @mays[1] & attack
+      @mays[2] = @mays[2] & attack
+      list = [
+        validation(attack[0], attack[2], attack[1]),
+        validation(attack[2], attack[1], attack[0]),
+        validation(attack[1], attack[0], attack[2])
+      ].compact
+      update_possibilities(list)
+    end
+
+    def two_eat_zero_bite(attack)
+      # 先頭2つがeat
+      list = []
+      (@mays[2] - attack).each do |k|
+        list << validation(attack[0], attack[1], k)
+      end
+      # 先頭、末尾がeat
+      (@mays[1] - attack).each do |j|
+        list << validation(attack[0], j, attack[2])
+      end
+      # 真ん中、末尾がeat
+      (@mays[0] - attack).each do |i|
+        list << validation(i ,attack[1], attack[2])
+      end
+      update_possibilities(list)
+    end
+
+    def validation(i, j, k)
+      return nil if i == j || i == k || j == k
+      if @mays[0].include?(i) && @mays[1].include?(j) && @mays[2].include?(k)
+        return i.to_s + j.to_s + k.to_s
+      else
+        return nil
+      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
+
+    def one_eat_or_one_bite(attack)
+      list = []
+      # attack[0] - attack[3]が一桁目に含まれている
+      (@mays[1] - attack).each do |j|
+        (@mays[2] - attack).each do |k|
+          next if j == k
+          list << validation(attack[0], j, k)
+          list << validation(attack[1], j, k)
+          list << validation(attack[2], j, k)
+        end
+      end
+      (@mays[0] - attack).each do |i|
+        # attack[0..3]が2桁目に含まれている
+        (@mays[2] - attack).each do |k|
+          next if i == k
+          list << validation(i, attack[0], k)
+          list << validation(i, attack[1], k)
+          list << validation(i, attack[2], k)
+        end
+        # attack[0..3]が3桁目に含まれている
+        (@mays[1] - attack).each do |j|
+          next if i == j
+          list << validation(i, j, attack[0])
+          list << validation(i, j, attack[1])
+          list << validation(i, j, attack[2])
+        end
+      end
+      update_possibilities(list)
+    end
+
+    def two_eat_or_two_bite(attack)
+      list = []
+      # 末尾が不明
+      (@mays[2] - attack).each do |k|
+        list << validation(attack[0], attack[1], k)
+        list << validation(attack[0], attack[2], k)
+        list << validation(attack[1], attack[0], k)
+        list << validation(attack[1], attack[2], k)
+        list << validation(attack[2], attack[0], k)
+        list << validation(attack[2], attack[1], k)
+      end
+
+      # 真ん中が不明
+      (@mays[1] - attack).each do |j|
+        list << validation(attack[0], j, attack[1])
+        list << validation(attack[0], j, attack[2])
+        list << validation(attack[1], j, attack[0])
+        list << validation(attack[1], j, attack[2])
+        list << validation(attack[2], j, attack[0])
+        list << validation(attack[2], j, attack[1])
+      end
+
+      # 先頭が不明
+      (@mays[0] - attack).each do |i|
+        list << validation(i, attack[0], attack[1])
+        list << validation(i, attack[0], attack[2])
+        list << validation(i, attack[1], attack[0])
+        list << validation(i, attack[1], attack[2])
+        list << validation(i, attack[2], attack[0])
+        list << validation(i, attack[2], attack[1])
+      end
+      update_possibilities(list)
+    end
+
+    def update_possibilities(possibilities)
+      possibilities.compact!
+      @possibilities = @possibilities.nil? ? possibilities : possibilities & @possibilities
+    end
+  end
+end

data/lib/numeron/solver.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+module Numeron
+  class Solver
+    attr_accessor :calc, :card_size
+    def initialize
+      @calc = Numeron::Calculator.new
+      @card_size = 3
+    end
+
+    def run
+      while 1
+        next unless question
+        think
+        finish
+      end
+    end
+
+    def question
+      attack_number = nil
+      eat = 0
+      bite = 0
+      while 1
+        print "Attack number: "
+        attack_number = STDIN.gets.chomp
+        if @card_size == attack_number.split(//).size
+          break
+        else
+          puts 'Required ' + @card_size.to_s + ' digits.'
+        end
+      end
+
+      while 1
+        while 1
+          print "Eat number: "
+          eat = STDIN.gets.chomp.to_i
+          if @card_size > eat
+            break
+          else
+            puts 'Required less than ' + @card_size.to_s + ' digits.'
+          end
+        end
+
+        while 1
+          print "Bite number: "
+          bite = STDIN.gets.chomp.to_i
+          if @card_size >= bite
+            break
+          else
+            print 'Required ' + @card_size.to_s + ' digits or less'
+          end
+        end
+        if eat + bite <= @card_size
+          break
+        else
+          puts "Error, Eat + Bite > " + @card_size.to_s
+        end
+      end
+
+      @calc.input(attack_number, eat, bite)
+    end
+
+    def think
+      puts "... thinking"
+      puts "possibilities: " + @calc.possibilities.size.to_s
+      analyzer = Numeron::Analyzer.new(@calc)
+      result = @calc.possibilities.size <= 64 ? analyzer.run(:possibilities) : analyzer.run(:average)
+      if result[:recommend].size > 0
+        puts "Analyzer Answer: " + result[:recommend].sample.to_s
+      else
+        puts "Calculator Error."
+      end
+      puts "Possibilitiy list random: " + @calc.possibilities.sample.to_s
+    end
+
+    def finish
+      while 1
+        print "\nfinish? [yes|no] "
+        f = STDIN.gets.chomp
+        if(f == 'yes' || f == 'y')
+          exit
+        elsif f == 'no' || f == 'n'
+          break
+        end
+      end
+    end
+  end
+end

data/lib/numeron/version.rb

@@ -0,0 +1,3 @@
+module Numeron
+  VERSION = "1.0.0"
+end

data/numeron.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numeron/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "numeron"
+  gem.version       = Numeron::VERSION
+  gem.authors       = ["kengos"]
+  gem.email         = ["kengo@kengos.jp"]
+  gem.description   = %q{numer0nの解を計算します。}
+  gem.summary       = %q{numer0n solver}
+  gem.homepage      = "https://github.com/kengos/numeron"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/lib/numeron/analyzer_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Numeron::Analyzer do
+  let(:analyzer) { Numeron::Analyzer.new(calc) }
+  describe '#run_average_mode' do
+    context '0e1b' do
+      let(:calc) { Numeron::Calculator.new.tap{|f| f.input('123', 0, 1) } }
+      it do
+        result = analyzer.run_average_mode
+        result[:recommend].should have(378).items
+        result[:size].should == 60.0
+      end
+    end
+  end
+
+  describe '#run_worstcase_mode' do
+    let(:calc) { Numeron::Calculator.new.tap{|f| f.input('123', 0, 1) } }
+    it do
+      result = analyzer.run_worstcase_mode
+      result[:recommend].should have(21).items
+      result[:size].should == 72
+    end
+  end
+
+  describe '#run_possibilities' do
+    let(:calc) { Numeron::Calculator.new.tap{|f| f.input('123', 0, 3) } }
+    it do
+      result = analyzer.run_possibilities
+      result[:recommend].should =~ %w(312 231)
+      result[:size].should == 0
+    end
+  end
+end

data/spec/lib/numeron/calculator_spec.rb

@@ -0,0 +1,136 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Numeron::Calculator do
+  let(:calc) { Numeron::Calculator.new }
+  describe '#input' do
+    it "0e0b" do
+      calc.input('123', 0, 0)
+      calc.possibilities.should have(7 * 6 * 5).items
+    end
+
+    it "0e1b" do
+      calc.input('123', 0, 1)
+      calc.possibilities.should have(252).items
+    end
+
+    it "0e2b" do
+      calc.input('123', 0, 2)
+      calc.possibilities.should have(63).items
+      calc.input('231', 0, 2)
+      calc.possibilities.should have(21).items
+    end
+
+    it "0e3b" do
+      calc.input('123', 0, 3)
+      calc.possibilities.should =~ %w(231 312)
+      calc.input('231', 0, 3)
+      calc.possibilities.should =~ %w(312)
+    end
+
+    it "1e0b" do
+      calc.input('123', 1, 0)
+      calc.possibilities.should have(126).items
+    end
+
+    it "1e1b" do
+      calc.input('123', 1, 1)
+      calc.possibilities.should have(42).items
+    end
+
+    it "1e2b" do
+      calc.input('123', 1, 2)
+      calc.possibilities.should =~ %w(132 321 213)
+    end
+
+    it "2e0b" do
+      calc.input('123', 2, 0)
+      calc.possibilities.should have(21).items
+    end
+  end
+
+  describe "#shuffle" do
+    it "0e3b" do
+      calc.input('123', 0, 3)
+      calc.shuffle
+      calc.possibilities.should =~ %w(123 132 213 231 312 321)
+    end
+
+    it "2e0b" do
+      calc.input('123', 2, 0)
+      calc.shuffle
+      # 12?, 13?, 21?, 23?, 31?, 32? が3パターン, ? = [0, 4, 5, 6, 7, 8, 9]
+      # => 6 * 3 * 7=  126
+      calc.possibilities.should have(126).items
+    end
+
+    it "1e1b" do
+      calc.input('123', 1, 1)
+      calc.shuffle
+      calc.possibilities.should have(126).items
+    end
+
+    it "1e0b" do
+      calc.input('123', 1, 0)
+      calc.shuffle
+      calc.possibilities.should have(378).items
+    end
+  end
+
+  describe "scenario" do
+    it "1e0b, 1e2b" do
+      calc.input('348', 1, 0)
+      calc.input('123', 1, 2)
+      calc.possibilities.should == ['321']
+    end
+
+    it "0e1b, 0e1b 0e0b 1e0b 1e2b" do
+      calc.input('123', 0, 1)
+      calc.input('210', 0, 1)
+      calc.input('340', 0, 0)
+      calc.input('562', 1, 0)
+      calc.input('892', 1, 2)
+      calc.possibilities.should == %w(982)
+    end
+
+    it "3eat is 571" do
+      calc.input('123', 0, 1)
+      calc.input('245', 0, 1)
+      calc.input('367', 0, 1)
+      calc.input('890', 0, 0)
+      calc.input('416', 0, 1)
+      calc.possibilities.should =~ ['571', '751']
+    end
+
+    it "0e1b, 0e1b" do
+      calc.input('123', 0, 1)
+      calc.input('245', 0, 1)
+      calc.possibilities.should have(75).items
+    end
+
+    it "0e1b, 0e1b 2" do
+      calc.input('123', 0, 1)
+      calc.input('235', 0, 1)
+      calc.possibilities.should have(78).items
+    end
+
+    it "0e1b, 0e1b 3" do
+      calc.input('123', 0, 1)
+      calc.input('145', 0, 1)
+      calc.possibilities.should have(90).items
+    end
+
+    it "0e1b, 0e1b 4" do
+      calc.input('123', 0, 1)
+      calc.input('456', 0, 1)
+      calc.possibilities.should have(96).items
+    end
+
+    it "0e1b, 2e0b" do
+      calc.input('123', 0, 1)
+      calc.input('245', 2, 0)
+      calc.possibilities.should have(11).items
+    end
+  end
+end

data/spec/lib/numeron_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Numeron do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+begin
+  require 'tapp'
+rescue Exception
+end
+
+require 'rspec'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/numeron')
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: numeron
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- kengos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-18 00:00:00.000000000 Z
+dependencies: []
+description: numer0nの解を計算します。
+email:
+- kengo@kengos.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/numeron.rb
+- lib/numeron/analyzer.rb
+- lib/numeron/calculator.rb
+- lib/numeron/solver.rb
+- lib/numeron/version.rb
+- numeron.gemspec
+- spec/lib/numeron/analyzer_spec.rb
+- spec/lib/numeron/calculator_spec.rb
+- spec/lib/numeron_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kengos/numeron
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: numer0n solver
+test_files:
+- spec/lib/numeron/analyzer_spec.rb
+- spec/lib/numeron/calculator_spec.rb
+- spec/lib/numeron_spec.rb
+- spec/spec_helper.rb
+has_rdoc: