適切な分岐処理について

Question

###前提・実現したいこと
以下のような簡単な図の分岐処理のスマートな書き方について

A	B	重要度
×	×	低い
×	○	普通
○	×	やや高い
○	○	高い

###該当のソースコード

if(A == "×" && B == "×"){

   Console.WriteLine("低い");

}else if(A == "×" && B == "○"){

   Console.WriteLine("普通");

}else if(A == "○" && B == "×"){

   Console.WriteLine("やや高い");

}else if(A == "○" && B == "○"){

   Console.WriteLine("高い");

}

###試したこと
図に従ってコーディングしますと、すぐに思いついたのが上記のような書き方になります。

ただ、簡単なものであればこのような書き方をしてしまっても良いと思うのですが、
より複雑になった場合は、ただ分岐が増える事になり、あまりスマートな書き方ではないと思ってしまいました。

何か他に良い書き方はありますでしょうか。

よろしくお願いします。

###補足情報(言語/FW/ツール等のバージョンなど)
言語は問いませんが、出来ればPowerShellであると助かります。

Comments

[tmp]

複雑になった場合とは、どのようことを想定していますか？

[think49]

「複雑になった場合」は「2次元構造から3次元構造->4次元構造と増えた場合」を想定しましたが、それで良いのでしょうか。

[tmp]

ありがとうございます。いっぱい回答でて、もう回答するほどのものはもってないです。

Answer 1

Javaで回答します。
まず、以下のような列挙型クラスを作成します。

public enum Judge {
    LOW("×","×","低い"),
    NORMAL("×","○","普通"),
    SLIGHTLY_HIGH("○","×","やや高い"),
    HIGH("○","○","高い"),
    UNKNOWN("-","-","");
    
    private final String a;
    private final String b;
    private final String message;
    
    private Judge(String a,String b ,String message){
        this.a = a;
        this.b = b;
        this.message = message;
    }
    
    public static String getMessage(String a,String b){
        return Stream.of(Judge.values())
                .filter(j -> j.a.equals(a) && j.b.equals(b))
                .findAny()
                .orElse(UNKNOWN)
                .message;
}

これを使用する場合は以下のようになります。

Judge.getMessage("×","○"); // 「普通」が出力

Comments

[kurokoba]

if文(switch文)をオブジェクトのポルモーフィズムで置き換えるというのはオブジェクト指向の基本的な考え方であり、M.ファウラーの「リファクタリング」でも最初の方でとりあげられています。
ssbb0212さんが該当ソースコードに"不吉な匂い"(※技術用語)を感じたなら健全で良い事だと思います。
なお状態定数自身に自身のやることを知ってるようなクラス設計というのはGoFのデザインパターンの一つstateパターンとして知られています。
Javaのenumはstateパターン書きやすいのだけど(他の言語と比べ特殊すぎますが)、他のOOP言語でもstateパターンは有効です。

[swordone]

gerMessageの返り値は、orElseを使えば3項演算子いらずになります。

[mr-hisa-child]

ご指摘ありがとうございます。ソースを修正致しました。

[swordone]

すごい今更ですが、mapメソッドを使えばUNKNOWN要らずでは？
findAny().map(x -> x.message).orElse("");

Answer 2

選択肢に○でも×でもない場合があることを考慮する必要がありますか？
PowerShellの仕様はよくわかりませんが、もし配列がつかえるなら
全ての組み合わせを配列化しておけばよいと思います。

sample

せっかく何でサンプル

var table = [
  {A:'×',B:'×','text':'低い'},
  {A:'○',B:'×','text':'普通'},
  {A:'×',B:'○','text':'やや高い'},
  {A:'○',B:'○','text':'高い'},
  ]
function getText(a,b){
  var t=(t=table.filter(function(i){return i.A==a && i.B==b;})).length>0?t[0]:{"text":"不明"};
  return t;
}
console.log(getText('○','×').text);
console.log(getText('○','□').text);

Comments

[yuba]

質問文の通りのif-else連鎖か、このテーブルを使った方法が多くの場合最良かと思います。
点数化して足し算する方法だと、行数は減らせるのですが今後の仕様変更に弱いです。

[yambejp]

よくよく考えたらユーザー関数名getTextはゼンゼンダメですね
textをとらずにobjectをとっているので
流用するならgetObject的な名称にするか、戻り値をtextにしてあげて下さい

[think49]

「普通」と「やや高い」の設定が逆転していませんか。

Answer 3

まず、〇か×かの判定は、避けたいです。
というのも、文字列なので実際には〇、×、それ以外を考慮する必要があるため
提示されたものでは、なにも表示されないことがあります。（まぁ、それもアリですが）
あとは、よくあるフラグ管理でswitch使います。
Aの重み付けは１、Bは２、Cができたら４というやつね

あ、重みづけまちがってました・・表ベースなので、Aの方が２でBが１です。

A	B	重要度	合計
-	-	低い	0
-	〇	普通	1
〇	-	やや高い	2
〇	〇	高い	3

String A = "x";
String B = "〇";

int pt = 0;
pt += A.equals("〇") ? 2 : 0;
pt += B.equals("〇") ? 1 : 0;
		
String result;
switch (pt) {
	case 0:
		result = "低い";
		break;
	case 1:
		result = "普通";
		break;
	case 2:
		result = "やや高い";
		break;
	case 3:
		result = "高い";
		break;
	default:
		result = "";	// 表示しない or 低い
		break;
	}
		
	System.out.println(result);

配列使う場合は、こんな感じ。
ソースはスッキリしますが、配列の修正がめんどいです。excelマクロとかで生成する感じかなぁ。

int APos = A.equals("〇") ? 1 : 0;
int BPos = B.equals("〇") ? 1 : 0;

String[][] results = {
		{"低い", "普通"},	// ×× , ×〇
		{"やや高い", "普通"}	// 〇× , 〇〇
	};

System.out.println(results[APos][BPos]);

か、最初のやつのswitch使うのやだなぁ。ならこれ。
非表示が実現できず、デフォルトが”低い”になっちゃいますが。

	String[] result = {"低い","普通","やや高い","高い"};		
	System.out.println(result[pt]);

Answer 4

複雑になった場合を考えているようですので、拡張可能な方法で考えていきたいと思います。

より複雑になるのは次のような物だと思います。

• A、Bだけではなく、C、D、E、... と増えていく可能性がある。
• ○、×だけではなく、△、□、◎、... と増えていく可能性がある。
• 低い、普通、やや高い、高いだけではなく、やや低い、極めて高い、... と増えていく可能性がある。

これらを全て想定して条件分岐を考えた場合、すぐに破綻するのは目に見えています。ですので、今回は得点方式を採用します。

今回の問題は、それぞれの状態によって、最終的な評価が決まるという物です。そして、Aが○である場合と、Bが○である場合では、最終的な評価の重みが異なります。その重みを得点にし、それぞれの状態による得点を加算し、合計値からその評価を判定することにします。

状態	○	×
A	2	0
B	1	0

得点	結果
0	低い
1	普通
2	やや高い
3	高い

これをコードにすると、下記のような感じになります。(コードはRuby 2.4です。結構突貫で書いたので所々は怪しいです。大目に見てやってください。)

# frozen_string_literal: true

class Judgement
  def initialize(score, result)
    @score_table = ScoreTable.new(score)
    @result_table = ResultTable.new(result)
  end

  def judge(list)
    score = list.to_h
      .map { |name, value| @score_table.score(name, value) }
      .sum
    @result_table.score_to_result(score)
  end

  class ScoreTable
    def initialize(score)
      @score_map = score
    end

    def score(name, value)
      raise ArgumentError, "#{name} not found" unless @score_map.key?(name)
      name_map = @score_map[name]
      raise ArgumentError, "#{value} not found" unless name_map.key?(value)
      name_map[value]
    end
  end

  class ResultTable
    def initialize(result_map, compare = :more, out_of_range = true)
      @score_list, @result_list = result_map.to_a
        .map { |s, r| [s.to_i, r.to_s] }
        .sort_by { |s, _r| s }
        .transpose
      @compare = compare
      @out_of_range = out_of_range
    end

    def score_to_result(score)
      case @compare
      when :exact
        idx = @score_list.find_index(score)
        return @result_list[idx] if idx
        raise ArgumentError, "#{socre} not included in score list"
      when :more
        ridx = @score_list.reverse_each.with_object(score).find_index(&:<=)
        return @result_list[- 1 - ridx] if ridx
        return @result_list.first if @out_of_range
        raise RangeError, "#{socre} out of score range"
      when :less
        idx = @score_list.with_object(score).find_index(&:>=)
        return @result_list[idx] if idx
        return @result_list.last if @out_of_range
        raise RangeError, "#{socre} out of score range"
      else
        raise Argumenterror, "#{@compare} invalid compare"
      end
    end
  end
end

if $0 == __FILE__
  require 'yaml'

  data_yaml = <<~EndOfLine
    score:
      A:
        ○: 2
        ×: 0
      B:
        ○: 1
        ×: 0
    result:
      0: 低い
      1: 普通
      2: やや高い
      3: 高い
    EndOfLine

  data = YAML.load(data_yaml)
  jm = Judgement.new(data['score'], data['result'])
  puts jm.judge({'A' => '○', 'B' => '×'})

  data2_yaml = <<~EndOfLine
    score:
      A:
        ○: 2
        △: 1
        ×: 0
      B:
        ○: 1
        △: 0
        ×: 0
      C:
        ○: 4
        △: 2
        ×: -1
    result:
      0: 低い
      1: 普通
      2: やや高い
      3: 高い
      4: 極めて高い
    EndOfLine

  data2 = YAML.load(data2_yaml)
  jm2 = Judgement.new(data2['score'], data2['result'])
  puts jm2.judge({'A' => '×', 'B' => '○', 'C' => '△'})
  puts jm2.judge({'A' => '×', 'B' => '×', 'C' => '×'})
  puts jm2.judge({'A' => '○', 'B' => '○', 'C' => '○'})
end

data2_yaml以降を見てください。Cや△を追加したパターンを書いてみました。このように、見るべき状態が増えたり、結果が変わったとしても、柔軟に対応できるのがこの書き方の良いところです。データの持ち方や、クラスの作り方はまだまだ工夫の余地があるのですが、考え方としては、

1. 各状態について、得点を求める。
2. 得点を合計する。
3. 合計得点から、評価を得る。

と言うものになります。

さて、この方法には二つ問題があります。一つは、状態がどんどん増えていくと、どのように得点を配分すべきかが難しくなります。もう一つは「XとYの両方が○のときは高評価だが片方だけ○の場合は価値がない」のような状態の相互作用については考慮していません。あくまで、各状態が独立しているときでないとこの方式は無理です。

そのような、より多くの条件、かつ、それぞれの状態が絡み合って評価が変わるとなると違う分野に手を出す必要があります。そう、AIと言われる分野です。

※ ここから先は私もあまり詳しくは無いので、間違いがあればご指摘下さい。

例えば、囲碁というのは、361(19x19)のマスに「無」「白」「黒」の三状態、白黒双方のアゲハマに入る数値、白か黒の手番、コウになっているマス、という状態で盤面を表せます。上の話をより複雑にしただけに過ぎません。ですが、それぞれの状態で、白勝ち、白良し、互角、黒良し、黒勝ち、といった結果が存在します。これを条件分岐だけで作って行くことは不可能です。とはいえ、先ほどの単純な得点方式も限界があります。囲碁のルールにそって、複雑に絡み合った石の繋がりを見なければならないからです。

古典的なAIと言われたものは、この複合条件も一つ一つ得点化していくことで、総合評価を図ろうとしました。コンピューター将棋のメイン部分は今でもこの方式です。Bonanzaによって広まった3駒関係を得点化するというものです。この方式の問題は二つです。ひとつはある関係についてどれだけの得点を付ければ良いのかです。これについては強化学習の手法が広まり、かなり高い精度を誇れるようになりました。もう一つの問題は、どういった関係を得点にすれば良いかです。現在広く使われている3駒関係ですら、完全では無いと言われています。コンピューター将棋では(すでにトップレベルが人間の名人に勝てるほどの実力がありながら)まだまだ未知の部分であると言われています。

それに対して、コンピューター囲碁の分野では、衝撃的なデビューを果たしたAlphaGoがやってのけてしまいました。そもそも、どのような関係を得点にすべきかと言うことを人間が考えないという手法です。現代的なAIと言われるニューラルネットワークを利用したものがそれです。関係やその得点を人が作るのでは無く、自動的に学習していくという手法です。それは、人間の脳が少しずつ学習していくのを模倣する仕組みになっており、先入観にとらわれない、汎用性が高い手法です。この方法であれば、人では見逃していた関係も考慮に入れることもできますし、状態が増えたりしても(計算量は増えますが)より柔軟に対応可能です。

ということで、より複雑な状態についても評価を得られるような仕組みを作るには、ニューラルネットワークなどの最新のAI技術を使うしか無いでしょう。ぜひ、挑戦してみてください。

Answer 5

JavaScript で回答します。

二次元配列

「〇×」を Boolean 型の変数として作ってみました。
二次元配列を使った簡単なコードなので、他の言語にも応用できると思います。

'use strict';
function getImportance1 (a, b) { // 仮引数 a, b は Boolean 型の値をとるものとする
  return [['低い', '普通'], ['やや高い', '高い']][Number(Boolean(a))][Number(Boolean(b))];
}

console.log(getImportance1(false, false)); // "低い"
console.log(getImportance1(false, true));  // "普通"
console.log(getImportance1(true, false));  // "やや高い"
console.log(getImportance1(true, true));   // "高い"

二次元配列 + オブジェクト初期化子

設定の可読性とパフォーマンスの両立を目指しました。

'use strict';
var getImportance2 = (function () {
  var rules = [
        [{a: false, b: false}, '低い'],
        [{a: false,  b: true}, '普通'],
        [{a: true, b: false},  'やや高い'],
        [{a: true,  b: true},  '高い']
      ],
      array = [[],[]];

  for (var i = 0, len = rules.length, rule; i < len; ++i) {
    rule = rules[i];

    array[Number(rule[0].a)][Number(rule[0].b)] = rule[1];
  }

  return function getImportance2 (a, b) {
    return array[Number(Boolean(a))][Number(Boolean(b))];
  };
}());

console.log(getImportance2(false, false)); // "低い"
console.log(getImportance2(false, true));  // "普通"
console.log(getImportance2(true, false));  // "やや高い"
console.log(getImportance2(true, true));   // "高い"

多次元 Map

配列の代わりに Map を使用してみました。

• multidimensional-map.js : 多次元Mapを生成
• 多次元 Map - JSFiddle

var map = createMultidimensionalMap([
            [[false, false], '低い'],
            [[false, true], '普通'],
            [[true, false], 'やや高い'],
            [[true, true], '高い']
          ]);

console.log(map);
console.log(map.get(false).get(false)); // "低い"
console.log(map.get(false).get(true));  // "普通"
console.log(map.get(true).get(false));  // "やや高い"
console.log(map.get(true).get(true));   // "高い"

以下、オブジェクト初期化子でルールを渡せるようにしたコード。

• 多次元 Map で重要度を定義する - JSFiddle

'use strict';
function createFunction (rules) {
  var keys = [...rules[0][0].keys()],
      hasOwnProperty = Object.prototype.hasOwnProperty;

  for (var i = 0, len = rules.length, rule; i < len; ++i) {
    rule = rules[i];
    rule[0] = [...rule[0].values()];
  }

  rules = createMultidimensionalMap(rules);

  return function getImportance3 (conditions) {
    var map = rules;

    for (var i = 0, len = keys.length, key; i < len; ++i) {
      key = keys[i];

      if (!hasOwnProperty.call(conditions, key)) {
        throw new ReferenceError;
      }

      map = map.get(conditions[key]);
    }

    return map;
  };
}

var rules = [
              [new Map([['A', false], ['B', false]]), '低い'],
              [new Map([['A', false], ['B', true]]), '普通'],
              [new Map([['A', true], ['B', false]]), 'やや高い'],
              [new Map([['A', true], ['B', true]]), '高い']
            ];
var getImportance3 = createFunction(rules);

console.log(getImportance3({A: false, B: false})); // "低い"
console.log(getImportance3({A: false, B: true}));  // "普通"
console.log(getImportance3({A: true, B: false}));  // "やや高い"
console.log(getImportance3({A: true, B: true}));   // "高い"

条件が増えた場合、ルールの数を増やすだけで対応可能です。

var rules = [
              [new Map([['A', false], ['B', false], ['C', false]]), 'XXX'],
              [new Map([['A', false], ['B', true], ['C', true]]), 'XYY'],
              [new Map([['A', true], ['B', false], ['C', false]]), 'YXX'],
              [new Map([['A', true], ['B', true], ['C', true]]), 'YYY']
            ];
var getImportance3 = createFunction(rules);

console.log(getImportance3({A: false, B: false, C: false})); // "XXX"
console.log(getImportance3({A: false, B: true, C: true}));   // "XYY"
console.log(getImportance3({A: true, B: false, C: false}));  // "YXX"
console.log(getImportance3({A: true, B: true, C: true}));    // "YYY"

2進数のビットマップ

もし、2進数に馴染み深いのであれば、基数変換するのも手です。

A	B	C	合計
0	0	0	0
0	0	1	1
0	1	0	2
0	1	1	3
1	0	0	4
1	0	1	5
1	1	0	6

2進数なので2パターンしか対応できませんが、コードは大分シンプルで条件が増えても対応可能です。
ただし、条件が増えると左端に "D -> A -> B - > C" になってしまいます。
「C -> B -> A」のように降順で定義しておけば解決しますが、反面、読みづらくなるので、機械的に処理する工夫が必要かもしれません。

function getValue (a, b, c) {
  return ['000','001','010','011','100','101','110'][parseInt('' + Number(c) + Number(b) + Number(a), 2)];
}

console.log(getValue(false, false, false)); // "000"
console.log(getValue(false, false, true));  // "001"
console.log(getValue(false, true, false));  // "010"
console.log(getValue(false, true, true));   // "011"
console.log(getValue(true, false, false));  // "100"
console.log(getValue(true, false, true));   // "101"
console.log(getValue(true, true, false));   // "110"

更新履歴

• 2017/07/19 17:40 「多次元 Map」を追記
• 2017/07/19 18:14 「2進数のビットマップ」を追記
• 2017/07/19 18:21 多次元 Map で条件が増えた場合のコードを追記

Re: ssbb0212 さん

Comments

[think49]

多次元Map, ビットマップのコードを追記しました。

[think49]

ビットマップのコードは、2進数から3進数、4進数と増やしていけば、値のパターンを増やせます。
ただし、2進数のビットマップから後で思い立って3進数に変更しようとすると一から配列を作り直さなければなりません。
汎用性においては、多次元Mapが一番使いやすい感じです。

Answer 6

['低い', '普通', 'やや高い', '高い'][ (B === '○') + (A === '○') * 2 ];

回答しておいてなんですが、可読性が悪化するので、if文列挙の方がマシだと思います。

回答かぶったので別解

['低い', '普通', 'やや高い', undefined, '高い'][ '××○×○○'.indexOf(A+B) ];

×○以外の値があった場合はundefinedを返します。
可読性は最悪ですね。

Answer 7

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        List<List<string>> ans = new List<List<string>>()
            {
                new List<string>(){ "×", "×" },
                new List<string>(){ "×", "○" },
                new List<string>(){ "○", "×" },
                new List<string>(){ "○", "○" }
            };

        string check(List<string> input)
        {
            string data = string.Join("", input);

            switch (data)
            {
                case "××": return "低い";
                case "×○": return "普通";
                case "○×": return "やや高い";
                case "○○": return "高い";
            }

            return "エラー";
        }

        foreach (List<string> e in ans.OrderBy(i => Guid.NewGuid()))
        {
            Console.WriteLine($"回答[{string.Join(" ", e)}] : {check(e)}");
        }

        Console.ReadKey();
    }
}

# encoding : utf-8

ans = [['×', '×'], ['×',	'○'], ['○', '×'], ['○', '○']]

def check(input)
  case input
  when %w[× ×] then '低い'
  when %w[× ○] then '普通'
  when %w[○ ×] then 'やや高い'
  when %w[○ ○] then '高い'
  else 'エラー'
  end
end

ans.shuffle.each do |e|
  puts "回答[#{e.join(' ')}] : #{check(e)}"
end

回答には〇×が1つずつ書かれているという設定で
Joinを使ってリストを結合、比較、判定するという方法を
考えました。

Answer 8

function moji_kaesu(A,B){
  return ["低い","普通","やや高い","高い"][(A == "○")*2 + (B == "○")];
}

分岐の結果を数字に変えて、点数計算するって感じ。
未定義が多少発生してもある程度動いてくれるチャランポランな言語ならではのやり方かもしれません。

Answer 9

Powershellではなく、JavaScriptでの回答となりますが、テーブルのような形で持ってしまうとかどうでしょうか？

var table = {
  '×': {
    '×': '低い',
    '○': '普通'
  },
  '○': {
    '×': 'やや高い',
    '○': '高い'
  }
};

alert(table['×']['×']);
alert(table['×']['○']);
alert(table['○']['×']);
alert(table['○']['○']);