テンパズルに見せ算を導入する

テンパズルとは

テンパズルというパズルをご存じでしょうか？0～9の数字4つと四則演算を組み合わせて、10を作る遊びです。
例えば1, 2, 3, 4の場合、1 * 2 * 3 + 4 = 10という数式を作ることができます。
バスに乗っていて暇な時に、窓の外を通り過ぎていく車のナンバープレートでテンパズルして遊んでましたよね、あれです。

見せ算とは

M-1グランプリ2023の決勝戦でさや香というコンビが披露したネタです。
四則演算に第五の演算を追加しようという独特な試みで、優勝は逃しましたが一部界隈では盛り上がりを見せました。
まずは基本的なルールについて説明します。なお漫才では独自の用語が用いられていましたが、分かりやすくするためなるべく数学用語を使おうと思います。

• 同じ数字に対しては、答えは0となる（例：1 見せ 1 = 0）
• 異なる数字に対しては、大きい方の数字が答えとなる（例：2 見せ 3 = 3）

そして一部の数字を組み合わせた時には特殊ルールが発動し、基本ルールとは結果が異なります。

• 6 見せ 9 = 11
• 2 見せ 5 = 1.1
• 1 見せ 100 = 83（状況によっては84）

ここで疑問が生まれた

• テンパズルで10を作る組合せって何パターンあるんだろう？
• 見せ算を追加したらそのパターンはどれぐらい増えるんだろう？

解明しましょう、その疑問

見せ算を導入する前に、まずはテンパズルを解くプログラムをC++で作成します。作成するに当たって、以下の記事を参考にしました。

• 一般化テンパズルを解くコードをC++で書いてみた
• 重複組み合わせを列挙（C++）→追記にPythonコード

プログラムの構成は以下の通りです。

クラス名	役割
Combination	0~9の中から重複ありで4つの数字の組合せパターンを作成する
INumber	数字生成抽象クラス
IOperator	演算子抽象クラス
Numbers	具体的な数字生成クラスを定義、今回の場合は0~9の数字のリストを生成する
Operators	具体的な演算子クラスを定義、今回の場合は+, -, ×, ÷を定義する
Formula	数字の組合せパターンに対して、結果が10になる数式を見つける
Main	プログラムを実行し、計算結果をログに出力する

ソースコード

折り畳んでいます

Combination.h

#pragma once

#include "INumber.h"
#include <functional>

using namespace std;

class Combination {
private:
	INumber& mNumber;
	size_t mSize;

public:
    Combination(INumber& number, size_t size)
		: mNumber(number)
		, mSize(size) {
	}

	vector<vector<int>> generate() {
        return combWithReplace(mNumber.get(), mSize);
	}

private:
    template<typename T>
    vector<vector<T>> combWithReplace(vector<T> choices, int n) {
        vector<vector<T>> answer;
        for (vector<T> comb : product(choices, n)) {
            vector<T> toSorted = comb;
            sort(toSorted.begin(), toSorted.end());
            if (comb == toSorted) {
                answer.push_back(comb);
            }
        }
        return answer;
    }

    template<typename T>
    vector<vector<T>> product(vector<T> choices, int repeat) {
        vector<vector<T>> emptyResult(1, vector<T>());
        return productRecurse(choices, repeat, emptyResult);
    }

    template<typename T>
    vector<vector<T>> productRecurse(vector<T> choices, int repeat, vector<vector<T>> result) {
        if (repeat == 0) {
            return result;
        }
        vector<vector<T>> provisionalResult;
        for (vector<T> re : result) {
            for (T c : choices) {
                vector<T> temp = re;
                temp.push_back(c);
                provisionalResult.push_back(temp);
            }
        }
        return productRecurse(choices, repeat - 1, provisionalResult);
    }
};

INumber.h

#pragma once

#include <vector>

class INumber {
public:
	virtual std::vector<int> get() = 0;
};

IOperator.h

#pragma once

#include <string>

using namespace std;

class IOperator {
public:
	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) = 0;
	virtual string symbol() = 0;
};

Numbers.h

#pragma once

#include "INumber.h"

// 10進数
class Decimal : public INumber {
	virtual std::vector<int> get() {
		return { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	}
};

Operators.h

#pragma once

#include "IOperator.h"

using namespace std;

// 足し算
class Addition : public IOperator {
	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) {
		return make_pair(a.first * b.second + b.first * a.second, a.second * b.second);
	}

	virtual std::string symbol() {
		return "+";
	}
};

// 引き算
class Subtraction : public IOperator {
	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) {
		return make_pair(a.first * b.second - b.first * a.second, a.second * b.second);
	}

	virtual std::string symbol() {
		return "-";
	}
};

// 掛け算
class Multiplication : public IOperator {
	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) {
		return make_pair(a.first * b.first, a.second * b.second);
	}

	virtual std::string symbol() {
		return "×";
	}
};

// 割り算
class Division : public IOperator {
	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) {
		return make_pair(a.first * b.second, a.second * b.first);
	}

	virtual std::string symbol() {
		return "÷";
	}
};

Formula.h

#pragma once

#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <sstream>

#include "IOperator.h"

using namespace std;

class Formula {
public:
    map<string, string> calculate(std::vector<std::vector<int>> v, std::vector<IOperator*> operators, int answer) {
        map<string, string> results;
		for (size_t i = 0; i < v.size(); ++i) {
            string result = solve(v[i], operators, answer);
            if (result != "") {
                string input = "[" + to_string(v[i][0]);
                for (size_t j = 1; j < v[i].size(); ++j) {
                    input += ", " + to_string(v[i][j]);
                }
                input += "]";
                results[input] = result;
            }
		}
        return results;
	}

private:
    string solve(vector<int> v, const std::vector<IOperator*>& operators, int answer) {
        do {
            map<string, pair<int, int>> T = generate(v, operators);
            for (auto a : T) {
                if (a.second.second != 0 && a.second.first == answer * a.second.second) {
                    return a.first.substr(1, a.first.length() - 2);
                }
            }
        } while (next_permutation(v.begin(), v.end()));
        return "";
    }

    map<string, pair<int, int>> generate(vector<int> v, const std::vector<IOperator*>& operators) {
        map<string, pair<int, int>> T;
        if (v.size() == 1) {
            string key = (v[0] < 0) ? "(" + to_string(v[0]) + ")" : to_string(v[0]);
            T[key] = make_pair(v[0], 1);
            return T;
        } else {
            for (int i = 0; i < v.size() - 1; ++i) {
                vector<int> a, b;
                for (int j = 0; j <= i; ++j) {
                    a.push_back(v[j]);
                }
                for (int j = i + 1; j <= v.size() - 1; ++j) {
                    b.push_back(v[j]);
                }
                map<string, pair<int, int>> s = generate(a, operators);
                map<string, pair<int, int>> t = generate(b, operators);
                for (auto m : s) for (auto n : t) {
                    for (auto o : operators) {
                        pair<int, int> value = o->operate(m.second, n.second);
                        if (value.second != 0) {
                            T["(" + m.first + o->symbol() + n.first + ")"] = value;
                        }
                    }
                }
            }
            return T;
        }
    }
};

Main.cpp

#include <iostream>

#include "Numbers.h"
#include "Combination.h"
#include "Operators.h"
#include "Formula.h"

using namespace std;

int main() {
    // 0～9の中から4つ抽出するパターンを生成
    Decimal decimal;
    Combination combination(decimal, 4);
    vector<vector<int>> pattern = combination.generate();

    // 使用する演算子を準備
    std::vector<IOperator*> operators;
    Addition addtion;
	Subtraction subtraction;
	Multiplication multiplication;
	Division division;
    operators.push_back(&addtion);
    operators.push_back(&subtraction);
    operators.push_back(&multiplication);
    operators.push_back(&division);

    Formula formula;
    map<string, string> result = formula.calculate(pattern, operators, 10);
    for (auto r : result) {
        std::cout << r.first + " : " + r.second << std::endl;
    }
}

結果

[1, 2, 3, 4] : ((1+2)+3)+4というフォーマットで出力しています。結果は552個でした！

折り畳んでいます

[0, 0, 1, 9] : ((0+0)+1)+9
[0, 0, 2, 5] : ((0+0)+2)×5
[0, 0, 2, 8] : ((0+0)+2)+8
[0, 0, 3, 7] : ((0+0)+3)+7
[0, 0, 4, 6] : ((0+0)+4)+6
[0, 0, 5, 5] : ((0+0)+5)+5
[0, 1, 1, 5] : ((0+1)+1)×5
[0, 1, 1, 8] : ((0+1)+1)+8
[0, 1, 1, 9] : ((0+1)×1)+9
[0, 1, 2, 4] : ((0+1)+4)×2
[0, 1, 2, 5] : ((0+1)×2)×5
[0, 1, 2, 6] : ((0-1)+6)×2
[0, 1, 2, 7] : ((0+1)+2)+7
[0, 1, 2, 8] : ((0+1)×2)+8
[0, 1, 2, 9] : ((0-1)+2)+9
[0, 1, 3, 3] : (0+1)+(3×3)
[0, 1, 3, 5] : ((0-1)+3)×5
[0, 1, 3, 6] : ((0+1)+3)+6
[0, 1, 3, 7] : ((0+1)×3)+7
[0, 1, 3, 8] : ((0-1)+3)+8
[0, 1, 3, 9] : ((0×3)+1)+9
[0, 1, 4, 5] : ((0+1)+4)+5
[0, 1, 4, 6] : ((0+1)×4)+6
[0, 1, 4, 7] : ((0-1)+4)+7
[0, 1, 4, 9] : ((0×4)+1)+9
[0, 1, 5, 5] : ((0+1)×5)+5
[0, 1, 5, 6] : ((0-1)+5)+6
[0, 1, 5, 9] : ((0×5)+1)+9
[0, 1, 6, 9] : ((0×6)+1)+9
[0, 1, 7, 9] : ((0×7)+1)+9
[0, 1, 8, 9] : ((0×8)+1)+9
[0, 1, 9, 9] : ((0×9)+1)+9
[0, 2, 2, 3] : (0+2)×(2+3)
[0, 2, 2, 4] : (0+2)+(2×4)
[0, 2, 2, 5] : ((0×2)+2)×5
[0, 2, 2, 6] : ((0+2)+2)+6
[0, 2, 2, 7] : (0-2)×(2-7)
[0, 2, 2, 8] : ((0×2)+2)+8
[0, 2, 2, 9] : ((0+2)÷2)+9
[0, 2, 3, 4] : ((0+2)×3)+4
[0, 2, 3, 5] : ((0+2)+3)+5
[0, 2, 3, 7] : ((0×2)+3)+7
[0, 2, 3, 8] : (0-2)×(3-8)
[0, 2, 3, 9] : ((0-2)+3)+9
[0, 2, 4, 4] : ((0+2)+4)+4
[0, 2, 4, 5] : ((0-2)+4)×5
[0, 2, 4, 6] : ((0×2)+4)+6
[0, 2, 4, 7] : ((0+2)×7)-4
[0, 2, 4, 8] : ((0-2)+4)+8
[0, 2, 4, 9] : (0-2)×(4-9)
[0, 2, 5, 5] : ((0×2)+5)+5
[0, 2, 5, 6] : ((0×6)+2)×5
[0, 2, 5, 7] : ((0-2)+5)+7
[0, 2, 5, 8] : ((0×5)+2)+8
[0, 2, 5, 9] : ((0×9)+2)×5
[0, 2, 6, 6] : ((0-2)+6)+6
[0, 2, 6, 7] : ((0+6)÷2)+7
[0, 2, 6, 8] : ((0+2)×8)-6
[0, 2, 7, 8] : ((0×7)+2)+8
[0, 2, 8, 8] : ((0×8)+2)+8
[0, 2, 8, 9] : ((0+2)×9)-8
[0, 3, 3, 4] : ((0+3)+3)+4
[0, 3, 3, 7] : ((0×3)+3)+7
[0, 3, 3, 9] : ((0+3)÷3)+9
[0, 3, 4, 6] : ((0×3)+4)+6
[0, 3, 4, 7] : ((0×4)+3)+7
[0, 3, 4, 9] : ((0-3)+4)+9
[0, 3, 5, 5] : ((0+3)×5)-5
[0, 3, 5, 6] : ((0+5)÷3)×6
[0, 3, 5, 7] : ((0×5)+3)+7
[0, 3, 5, 8] : ((0-3)+5)+8
[0, 3, 6, 7] : ((0-3)+6)+7
[0, 3, 6, 8] : ((0+3)×6)-8
[0, 3, 7, 7] : ((0×7)+3)+7
[0, 3, 7, 8] : ((0×8)+3)+7
[0, 3, 7, 9] : (0+7)+(9÷3)
[0, 4, 4, 6] : ((0+4)×4)-6
[0, 4, 4, 9] : ((0+4)÷4)+9
[0, 4, 5, 5] : ((0×4)+5)+5
[0, 4, 5, 6] : ((0-4)+6)×5
[0, 4, 5, 8] : ((0+5)÷4)×8
[0, 4, 5, 9] : ((0-4)+5)+9
[0, 4, 6, 6] : ((0×6)+4)+6
[0, 4, 6, 7] : ((0×7)+4)+6
[0, 4, 6, 8] : ((0-4)+6)+8
[0, 4, 6, 9] : ((0×9)+4)+6
[0, 4, 7, 7] : ((0-4)+7)+7
[0, 4, 8, 8] : ((0+8)÷4)+8
[0, 5, 5, 5] : ((0×5)+5)+5
[0, 5, 5, 6] : ((0×6)+5)+5
[0, 5, 5, 7] : (0-5)×(5-7)
[0, 5, 5, 8] : ((0×8)+5)+5
[0, 5, 5, 9] : ((0+5)÷5)+9
[0, 5, 6, 8] : (0-5)×(6-8)
[0, 5, 6, 9] : ((0-5)+6)+9
[0, 5, 7, 8] : ((0-5)+7)+8
[0, 5, 7, 9] : (0-5)×(7-9)
[0, 6, 6, 9] : ((0+6)÷6)+9
[0, 6, 7, 9] : ((0-6)+7)+9
[0, 6, 8, 8] : ((0-6)+8)+8
[0, 7, 7, 9] : ((0+7)÷7)+9
[0, 7, 8, 9] : ((0-7)+8)+9
[0, 8, 8, 9] : ((0+8)÷8)+9
[0, 8, 9, 9] : ((0-8)+9)+9
[0, 9, 9, 9] : ((0+9)÷9)+9
[1, 1, 1, 4] : (1+1)×(1+4)
[1, 1, 1, 5] : ((1+1)×1)×5
[1, 1, 1, 6] : (1+1)×(6-1)
[1, 1, 1, 7] : ((1+1)+1)+7
[1, 1, 1, 8] : ((1+1)×1)+8
[1, 1, 1, 9] : ((1+1)-1)+9
[1, 1, 2, 3] : (1+1)×(2+3)
[1, 1, 2, 4] : (1+1)+(2×4)
[1, 1, 2, 5] : ((1-1)+2)×5
[1, 1, 2, 6] : ((1+1)+2)+6
[1, 1, 2, 7] : ((1×1)+2)+7
[1, 1, 2, 8] : ((1-1)+2)+8
[1, 1, 2, 9] : ((1+1)÷2)+9
[1, 1, 3, 3] : (1×1)+(3×3)
[1, 1, 3, 4] : ((1+1)×3)+4
[1, 1, 3, 5] : ((1+1)+3)+5
[1, 1, 3, 6] : ((1×1)+3)+6
[1, 1, 3, 7] : ((1-1)+3)+7
[1, 1, 3, 8] : (1+1)×(8-3)
[1, 1, 3, 9] : ((3-1)-1)+9
[1, 1, 4, 4] : ((1+1)+4)+4
[1, 1, 4, 5] : ((1×1)+4)+5
[1, 1, 4, 6] : ((1-1)+4)+6
[1, 1, 4, 7] : ((1+1)×7)-4
[1, 1, 4, 8] : (1+(1÷4))×8
[1, 1, 4, 9] : (1+1)×(9-4)
[1, 1, 5, 5] : ((1-1)+5)+5
[1, 1, 5, 6] : ((1×5)-1)+6
[1, 1, 5, 7] : ((5-1)-1)+7
[1, 1, 5, 8] : 8÷(1-(1÷5))
[1, 1, 6, 6] : ((6-1)-1)+6
[1, 1, 6, 7] : (6÷(1+1))+7
[1, 1, 6, 8] : ((1+1)×8)-6
[1, 1, 8, 9] : ((1+1)×9)-8
[1, 1, 9, 9] : (1+(1÷9))×9
[1, 2, 2, 2] : ((1+2)+2)×2
[1, 2, 2, 3] : (1×2)×(2+3)
[1, 2, 2, 4] : ((1+2)×2)+4
[1, 2, 2, 5] : ((1+2)+2)+5
[1, 2, 2, 6] : ((1×2)+2)+6
[1, 2, 2, 7] : (1×2)×(7-2)
[1, 2, 2, 8] : (1+(2÷2))+8
[1, 2, 2, 9] : ((1+2)-2)+9
[1, 2, 3, 3] : (1+(2×3))+3
[1, 2, 3, 4] : ((1+2)+3)+4
[1, 2, 3, 5] : ((1-2)+3)×5
[1, 2, 3, 6] : (1+(2÷3))×6
[1, 2, 3, 7] : (1-3)×(2-7)
[1, 2, 3, 8] : ((1-2)+3)+8
[1, 2, 3, 9] : ((1+2)÷3)+9
[1, 2, 4, 4] : ((1×2)+4)+4
[1, 2, 4, 5] : ((1÷2)×4)×5
[1, 2, 4, 6] : ((1+6)×2)-4
[1, 2, 4, 7] : ((1-2)+4)+7
[1, 2, 4, 8] : ((1÷2)×4)+8
[1, 2, 4, 9] : (1×2)×(9-4)
[1, 2, 5, 5] : ((1+2)×5)-5
[1, 2, 5, 6] : ((1-2)+5)+6
[1, 2, 5, 7] : (1+(2×7))-5
[1, 2, 5, 8] : (1+5)+(8÷2)
[1, 2, 5, 9] : ((1-5)+9)×2
[1, 2, 6, 6] : ((1×6)-2)+6
[1, 2, 6, 7] : ((1÷2)×6)+7
[1, 2, 6, 8] : ((1+2)×6)-8
[1, 2, 6, 9] : (2×(9-1))-6
[1, 2, 7, 7] : ((7-1)÷2)+7
[1, 2, 7, 8] : (1+(2×8))-7
[1, 2, 7, 9] : ((2×9)-1)-7
[1, 2, 8, 8] : (1+(2÷8))×8
[1, 2, 8, 9] : ((1×2)×9)-8
[1, 2, 9, 9] : (1+(2×9))-9
[1, 3, 3, 3] : ((1+3)+3)+3
[1, 3, 3, 4] : ((1×3)+3)+4
[1, 3, 3, 5] : (1+(3÷3))×5
[1, 3, 3, 6] : 1-(3×(3-6))
[1, 3, 3, 7] : (1+(7÷3))×3
[1, 3, 3, 8] : (1+(3÷3))+8
[1, 3, 3, 9] : ((1+3)-3)+9
[1, 3, 4, 4] : ((3-1)+4)+4
[1, 3, 4, 5] : ((1-3)+4)×5
[1, 3, 4, 6] : ((1+3)×4)-6
[1, 3, 4, 7] : 1-(3×(4-7))
[1, 3, 4, 8] : ((1-3)+4)+8
[1, 3, 4, 9] : ((1+3)÷4)+9
[1, 3, 5, 5] : ((1×3)×5)-5
[1, 3, 5, 6] : ((1÷3)×5)×6
[1, 3, 5, 7] : ((1-3)+5)+7
[1, 3, 5, 8] : 1-(3×(5-8))
[1, 3, 5, 9] : ((5-1)-3)+9
[1, 3, 6, 6] : ((1-3)+6)+6
[1, 3, 6, 7] : ((1×6)-3)+7
[1, 3, 6, 8] : ((1×3)×6)-8
[1, 3, 6, 9] : (1+(3×6))-9
[1, 3, 7, 7] : (1+(3÷7))×7
[1, 3, 7, 8] : ((1+8)÷3)+7
[1, 3, 7, 9] : ((1÷3)×9)+7
[1, 3, 8, 8] : (8÷(1+3))+8
[1, 3, 8, 9] : ((3-1)×9)-8
[1, 4, 4, 5] : (1+(4÷4))×5
[1, 4, 4, 6] : ((1×4)×4)-6
[1, 4, 4, 7] : (1+(4×4))-7
[1, 4, 4, 8] : ((1+4)÷4)×8
[1, 4, 4, 9] : ((1+4)-4)+9
[1, 4, 5, 5] : ((1-4)+5)×5
[1, 4, 5, 6] : (1×5)×(6-4)
[1, 4, 5, 7] : (1+4)×(7-5)
[1, 4, 5, 8] : ((1-4)+5)+8
[1, 4, 5, 9] : ((1+4)÷5)+9
[1, 4, 6, 6] : (1+(4÷6))×6
[1, 4, 6, 7] : ((1-4)+6)+7
[1, 4, 6, 8] : (1+4)×(8-6)
[1, 4, 6, 9] : (1+(9÷6))×4
[1, 4, 7, 7] : ((1×7)-4)+7
[1, 4, 7, 8] : ((1+7)÷4)+8
[1, 4, 7, 9] : (1+4)×(9-7)
[1, 4, 8, 8] : ((1÷4)×8)+8
[1, 4, 8, 9] : 8-((1-9)÷4)
[1, 5, 5, 5] : (1+(5÷5))×5
[1, 5, 5, 6] : ((1-5)+6)×5
[1, 5, 5, 7] : (1×5)×(7-5)
[1, 5, 5, 8] : (1+(5÷5))+8
[1, 5, 5, 9] : ((1+5)-5)+9
[1, 5, 6, 6] : (1+(6÷6))×5
[1, 5, 6, 7] : (1-6)×(5-7)
[1, 5, 6, 8] : ((1-5)+6)+8
[1, 5, 6, 9] : ((1+5)÷6)+9
[1, 5, 7, 7] : ((1-5)+7)+7
[1, 5, 7, 8] : ((1×7)-5)+8
[1, 5, 7, 9] : (1×5)×(9-7)
[1, 5, 8, 8] : (1+(8÷8))×5
[1, 5, 8, 9] : ((1-8)+9)×5
[1, 5, 9, 9] : (1+(9÷9))×5
[1, 6, 6, 8] : (1+(6÷6))+8
[1, 6, 6, 9] : ((1+6)-6)+9
[1, 6, 7, 8] : ((1-6)+7)+8
[1, 6, 7, 9] : ((1+6)÷7)+9
[1, 6, 8, 8] : ((1×8)-6)+8
[1, 6, 8, 9] : ((8-1)-6)+9
[1, 7, 7, 8] : (1+(7÷7))+8
[1, 7, 7, 9] : ((1+7)-7)+9
[1, 7, 8, 8] : ((1-7)+8)+8
[1, 7, 8, 9] : ((1+7)÷8)+9
[1, 7, 9, 9] : ((9-1)-7)+9
[1, 8, 8, 8] : (1+(8÷8))+8
[1, 8, 8, 9] : ((1+8)-8)+9
[1, 8, 9, 9] : ((1+8)÷9)+9
[1, 9, 9, 9] : ((1+9)+9)-9
[2, 2, 2, 2] : ((2+2)×2)+2
[2, 2, 2, 3] : (2+2)+(2×3)
[2, 2, 2, 4] : ((2+2)+2)+4
[2, 2, 2, 5] : ((2+2)-2)×5
[2, 2, 2, 6] : 2-(2×(2-6))
[2, 2, 2, 7] : ((2÷2)+2)+7
[2, 2, 2, 8] : ((2+2)-2)+8
[2, 2, 2, 9] : (2-(2÷2))+9
[2, 2, 3, 3] : ((2+2)+3)+3
[2, 2, 3, 4] : 2×((2×4)-3)
[2, 2, 3, 5] : (2×(3-2))×5
[2, 2, 3, 6] : ((2÷2)+3)+6
[2, 2, 3, 7] : ((2-2)+3)+7
[2, 2, 3, 8] : 2-((2-3)×8)
[2, 2, 3, 9] : ((2+2)-3)+9
[2, 2, 4, 4] : (2+(2÷4))×4
[2, 2, 4, 5] : ((2÷2)+4)+5
[2, 2, 4, 6] : ((2+2)×4)-6
[2, 2, 4, 7] : 2×((2-4)+7)
[2, 2, 4, 8] : 2-(2×(4-8))
[2, 2, 4, 9] : ((2+2)÷4)+9
[2, 2, 5, 5] : ((2-2)+5)+5
[2, 2, 5, 6] : (2+5)+(6÷2)
[2, 2, 5, 8] : 2×((2-5)+8)
[2, 2, 5, 9] : 2-(2×(5-9))
[2, 2, 6, 6] : (2-(2÷6))×6
[2, 2, 6, 7] : 2×((2×6)-7)
[2, 2, 6, 8] : ((2×6)+8)÷2
[2, 2, 6, 9] : 2×((2-6)+9)
[2, 2, 7, 7] : ((7-2)-2)+7
[2, 2, 7, 8] : (2×(2+7))-8
[2, 2, 7, 9] : 2×((2×7)-9)
[2, 2, 8, 8] : (2+(2×8))-8
[2, 2, 8, 9] : 2×(9-(8÷2))
[2, 2, 9, 9] : ((2+9)+9)÷2
[2, 3, 3, 3] : (3-2)+(3×3)
[2, 3, 3, 4] : 2×((3×3)-4)
[2, 3, 3, 5] : ((2+3)-3)×5
[2, 3, 3, 6] : ((2+3)÷3)×6
[2, 3, 3, 7] : ((2×3)-3)+7
[2, 3, 3, 8] : ((2+3)-3)+8
[2, 3, 3, 9] : (2-(3÷3))+9
[2, 3, 4, 4] : (2+(3×4))-4
[2, 3, 4, 5] : ((2×3)-4)×5
[2, 3, 4, 6] : 2×((3-4)+6)
[2, 3, 4, 7] : ((2-3)+4)+7
[2, 3, 4, 8] : ((2+3)÷4)×8
[2, 3, 4, 9] : ((2+3)-4)+9
[2, 3, 5, 5] : ((3-2)×5)+5
[2, 3, 5, 6] : ((2-3)+5)+6
[2, 3, 5, 7] : (2+(3×5))-7
[2, 3, 5, 8] : (5÷3)×(8-2)
[2, 3, 5, 9] : ((2+3)÷5)+9
[2, 3, 6, 6] : ((2÷3)×6)+6
[2, 3, 6, 7] : 2×(7-(6÷3))
[2, 3, 6, 8] : (2×(3+6))-8
[2, 3, 6, 9] : ((2×3)÷6)+9
[2, 3, 7, 7] : ((2+7)÷3)+7
[2, 3, 7, 8] : (2÷3)×(7+8)
[2, 3, 7, 9] : 2×((3-7)+9)
[2, 3, 8, 8] : (3×(8-2))-8
[2, 3, 8, 9] : ((2×8)+3)-9
[2, 3, 9, 9] : (9-2)+(9÷3)
[2, 4, 4, 4] : 2×((4÷4)+4)
[2, 4, 4, 5] : ((2+4)-4)×5
[2, 4, 4, 6] : ((2×4)-4)+6
[2, 4, 4, 7] : (2+(4÷4))+7
[2, 4, 4, 8] : ((2+4)-4)+8
[2, 4, 4, 9] : (2-(4÷4))+9
[2, 4, 5, 5] : 2×(4+(5÷5))
[2, 4, 5, 6] : 2×((4-5)+6)
[2, 4, 5, 7] : ((2-4)+5)+7
[2, 4, 5, 8] : (2×(4+5))-8
[2, 4, 5, 9] : ((2+4)-5)+9
[2, 4, 6, 6] : ((2-4)+6)+6
[2, 4, 6, 7] : ((2÷4)×6)+7
[2, 4, 6, 8] : ((2×4)-6)+8
[2, 4, 6, 9] : ((2+4)÷6)+9
[2, 4, 7, 7] : (2-(4÷7))×7
[2, 4, 7, 8] : 2×((4-7)+8)
[2, 4, 7, 9] : ((2×4)-7)+9
[2, 4, 8, 8] : 2×(4+(8÷8))
[2, 4, 8, 9] : ((2×4)÷8)+9
[2, 4, 9, 9] : 2×(4+(9÷9))
[2, 5, 5, 5] : ((2+5)-5)×5
[2, 5, 5, 6] : (2×5)×(6-5)
[2, 5, 5, 7] : (2+(5÷5))+7
[2, 5, 5, 8] : ((2+5)-5)+8
[2, 5, 5, 9] : (2-(5÷5))+9
[2, 5, 6, 6] : ((2×5)+6)-6
[2, 5, 6, 7] : ((2-5)+6)+7
[2, 5, 6, 8] : 2-((5-6)×8)
[2, 5, 6, 9] : ((2+5)-6)+9
[2, 5, 7, 7] : ((2×5)+7)-7
[2, 5, 7, 8] : (2×5)×(8-7)
[2, 5, 7, 9] : ((2+5)÷7)+9
[2, 5, 8, 8] : ((2×5)+8)-8
[2, 5, 8, 9] : (2×5)×(9-8)
[2, 5, 9, 9] : ((2×5)+9)-9
[2, 6, 6, 6] : 2×(6-(6÷6))
[2, 6, 6, 7] : (2+(6÷6))+7
[2, 6, 6, 8] : ((2+6)-6)+8
[2, 6, 6, 9] : (2-(6÷6))+9
[2, 6, 7, 7] : ((2-6)+7)+7
[2, 6, 7, 8] : 2-((6-7)×8)
[2, 6, 7, 9] : ((2+6)-7)+9
[2, 6, 8, 8] : (2-(6÷8))×8
[2, 6, 8, 9] : ((2+6)÷8)+9
[2, 6, 9, 9] : 2×(6-(9÷9))
[2, 7, 7, 7] : (2+(7÷7))+7
[2, 7, 7, 8] : ((2+7)-7)+8
[2, 7, 7, 9] : (2-(7÷7))+9
[2, 7, 8, 8] : (2+7)+(8÷8)
[2, 7, 8, 9] : ((2+7)-8)+9
[2, 7, 9, 9] : ((2+7)÷9)+9
[2, 8, 8, 8] : ((2+8)+8)-8
[2, 8, 8, 9] : (2-(8÷8))+9
[2, 8, 9, 9] : ((2+8)+9)-9
[2, 9, 9, 9] : (2+9)-(9÷9)
[3, 3, 3, 3] : (3×3)+(3÷3)
[3, 3, 3, 4] : ((3×3)-3)+4
[3, 3, 3, 5] : ((3+3)÷3)×5
[3, 3, 3, 6] : ((3÷3)+3)+6
[3, 3, 3, 7] : ((3+3)-3)+7
[3, 3, 3, 8] : ((3+3)×3)-8
[3, 3, 3, 9] : 3×(3+(3÷9))
[3, 3, 4, 4] : (3×3)+(4÷4)
[3, 3, 4, 5] : ((3+3)-4)×5
[3, 3, 4, 6] : ((3-3)+4)+6
[3, 3, 4, 7] : 3-((3-4)×7)
[3, 3, 4, 8] : ((3+3)-4)+8
[3, 3, 4, 9] : (3+4)+(9÷3)
[3, 3, 5, 5] : ((3-3)+5)+5
[3, 3, 5, 6] : ((3×3)-5)+6
[3, 3, 5, 7] : ((3×3)-7)×5
[3, 3, 5, 8] : (3+(3×5))-8
[3, 3, 5, 9] : ((3+3)-5)+9
[3, 3, 6, 6] : (3×3)+(6÷6)
[3, 3, 6, 7] : ((3×3)-6)+7
[3, 3, 6, 8] : 3×(6-(8÷3))
[3, 3, 6, 9] : ((3+3)÷6)+9
[3, 3, 7, 7] : (3×3)+(7÷7)
[3, 3, 7, 8] : ((3×3)-7)+8
[3, 3, 7, 9] : ((3×7)+9)÷3
[3, 3, 8, 8] : (3×3)+(8÷8)
[3, 3, 8, 9] : ((3×3)-8)+9
[3, 3, 9, 9] : ((3×3)÷9)+9
[3, 4, 4, 5] : (3-(4÷4))×5
[3, 4, 4, 6] : ((3×4)+4)-6
[3, 4, 4, 7] : ((3+4)-4)+7
[3, 4, 4, 8] : (3-(4÷4))+8
[3, 4, 4, 9] : (3+(4×4))-9
[3, 4, 5, 5] : ((3+4)-5)×5
[3, 4, 5, 6] : ((3-4)+5)+6
[3, 4, 5, 7] : ((3×4)+5)-7
[3, 4, 5, 8] : ((3+4)-5)+8
[3, 4, 5, 9] : ((3×5)+4)-9
[3, 4, 6, 6] : ((4×6)+6)÷3
[3, 4, 6, 7] : (4-(7÷3))×6
[3, 4, 6, 8] : ((3×4)+6)-8
[3, 4, 6, 9] : ((3+4)-6)+9
[3, 4, 7, 7] : ((3×7)-4)-7
[3, 4, 7, 8] : (3-(7÷4))×8
[3, 4, 7, 9] : ((3+4)÷7)+9
[3, 4, 8, 8] : ((8-3)÷4)×8
[3, 4, 8, 9] : (3-(8÷4))+9
[3, 4, 9, 9] : (4-(9÷3))+9
[3, 5, 5, 5] : (3-(5÷5))×5
[3, 5, 5, 6] : (3+(5÷5))+6
[3, 5, 5, 7] : ((3+5)-5)+7
[3, 5, 5, 8] : (3-(5÷5))+8
[3, 5, 5, 9] : ((5÷3)×9)-5
[3, 5, 6, 6] : ((3-5)+6)+6
[3, 5, 6, 7] : 3-((5-6)×7)
[3, 5, 6, 8] : ((3+5)-6)+8
[3, 5, 6, 9] : ((3×5)×6)÷9
[3, 5, 7, 7] : (3-(7÷7))×5
[3, 5, 7, 8] : ((3+7)÷5)+8
[3, 5, 7, 9] : ((3+5)-7)+9
[3, 5, 8, 8] : (3-(8÷8))×5
[3, 5, 8, 9] : ((3+5)÷8)+9
[3, 5, 9, 9] : (3-(9÷9))×5
[3, 6, 6, 6] : (3+(6÷6))+6
[3, 6, 6, 7] : ((3+6)-6)+7
[3, 6, 6, 8] : (3-(6÷6))+8
[3, 6, 7, 7] : (3+6)+(7÷7)
[3, 6, 7, 8] : ((3+6)-7)+8
[3, 6, 7, 9] : (6+7)-(9÷3)
[3, 6, 8, 8] : (3+6)+(8÷8)
[3, 6, 8, 9] : ((3+6)-8)+9
[3, 6, 9, 9] : ((3+6)÷9)+9
[3, 7, 7, 7] : ((3+7)+7)-7
[3, 7, 7, 8] : (3-(7÷7))+8
[3, 7, 8, 8] : ((3+7)+8)-8
[3, 7, 8, 9] : 3-(7×(8-9))
[3, 7, 9, 9] : ((3+7)+9)-9
[3, 8, 8, 8] : (3+8)-(8÷8)
[3, 8, 8, 9] : ((3+8)+8)-9
[3, 8, 9, 9] : (3+8)-(9÷9)
[4, 4, 4, 5] : ((4+4)÷4)×5
[4, 4, 4, 6] : ((4+4)-4)+6
[4, 4, 4, 7] : (4-(4÷4))+7
[4, 4, 4, 8] : ((4+4)÷4)+8
[4, 4, 4, 9] : (4+(4×9))÷4
[4, 4, 5, 5] : ((4-4)+5)+5
[4, 4, 5, 6] : 4-((4-5)×6)
[4, 4, 5, 7] : ((4+4)-5)+7
[4, 4, 5, 8] : ((4×4)×5)÷8
[4, 4, 6, 6] : (4+(6×6))÷4
[4, 4, 6, 7] : ((6-4)×7)-4
[4, 4, 6, 8] : ((4+4)-6)+8
[4, 4, 6, 9] : 4+((4÷6)×9)
[4, 4, 7, 8] : ((4+8)÷4)+7
[4, 4, 7, 9] : ((4+4)-7)+9
[4, 4, 8, 8] : ((4×4)÷8)+8
[4, 4, 8, 9] : ((4+4)÷8)+9
[4, 4, 9, 9] : ((9-4)-4)+9
[4, 5, 5, 5] : ((4×5)-5)-5
[4, 5, 5, 6] : ((4+5)-5)+6
[4, 5, 5, 7] : (4-(5÷5))+7
[4, 5, 5, 9] : ((5×9)-5)÷4
[4, 5, 6, 6] : (4+5)+(6÷6)
[4, 5, 6, 7] : ((4+5)-6)+7
[4, 5, 6, 8] : (4×5)÷(8-6)
[4, 5, 6, 9] : ((4×6)-5)-9
[4, 5, 7, 7] : (4+5)+(7÷7)
[4, 5, 7, 8] : ((4+5)-7)+8
[4, 5, 7, 9] : (4×5)÷(9-7)
[4, 5, 8, 8] : (4+5)+(8÷8)
[4, 5, 8, 9] : ((4+5)-8)+9
[4, 5, 9, 9] : ((4+5)÷9)+9
[4, 6, 6, 6] : ((4+6)+6)-6
[4, 6, 6, 7] : (4-(6÷6))+7
[4, 6, 6, 8] : ((4×6)-6)-8
[4, 6, 6, 9] : (4÷6)×(6+9)
[4, 6, 7, 7] : ((4+6)+7)-7
[4, 6, 7, 8] : (4÷6)×(7+8)
[4, 6, 7, 9] : 6+((7+9)÷4)
[4, 6, 8, 8] : ((4+6)+8)-8
[4, 6, 8, 9] : 4-(6×(8-9))
[4, 6, 9, 9] : ((4+6)+9)-9
[4, 7, 7, 7] : (4+7)-(7÷7)
[4, 7, 7, 8] : ((4+7)+7)-8
[4, 7, 7, 9] : ((7×7)-9)÷4
[4, 7, 8, 8] : (4+7)-(8÷8)
[4, 7, 8, 9] : ((4+7)+8)-9
[4, 7, 9, 9] : ((4×7)-9)-9
[4, 8, 8, 8] : (8÷(8-4))+8
[4, 8, 8, 9] : ((8÷4)×9)-8
[5, 5, 5, 5] : ((5+5)+5)-5
[5, 5, 5, 6] : (5-(5÷5))+6
[5, 5, 5, 7] : (5×7)-(5×5)
[5, 5, 5, 8] : ((5+5)÷5)+8
[5, 5, 5, 9] : (5+(5×9))÷5
[5, 5, 6, 6] : ((5+5)+6)-6
[5, 5, 6, 7] : 5-(5×(6-7))
[5, 5, 6, 8] : (5×6)÷(8-5)
[5, 5, 6, 9] : ((5×5)-6)-9
[5, 5, 7, 7] : ((5+5)+7)-7
[5, 5, 7, 8] : ((5×5)-7)-8
[5, 5, 7, 9] : (5×(5+9))÷7
[5, 5, 8, 8] : ((5+5)+8)-8
[5, 5, 8, 9] : 5-(5×(8-9))
[5, 5, 9, 9] : ((5+5)+9)-9
[5, 6, 6, 6] : (5+6)-(6÷6)
[5, 6, 6, 7] : ((5+6)+6)-7
[5, 6, 6, 9] : (5×6)÷(9-6)
[5, 6, 7, 7] : (5+6)-(7÷7)
[5, 6, 7, 8] : ((5+6)+7)-8
[5, 6, 7, 9] : ((6+9)÷5)+7
[5, 6, 8, 8] : (5+6)-(8÷8)
[5, 6, 8, 9] : ((5+6)+8)-9
[5, 6, 9, 9] : (5+6)-(9÷9)
[5, 7, 7, 7] : (5×(7+7))÷7
[5, 7, 7, 8] : 7+((7+8)÷5)
[5, 7, 7, 9] : ((5+7)+7)-9
[5, 7, 8, 9] : (5×(7+9))÷8
[5, 8, 8, 8] : (5×(8+8))÷8
[5, 8, 8, 9] : 8-(8÷(5-9))
[5, 9, 9, 9] : (5×(9+9))÷9
[6, 6, 6, 8] : ((6+6)+6)-8
[6, 6, 6, 9] : 6+((6×6)÷9)
[6, 6, 7, 8] : (6÷(8-6))+7
[6, 6, 7, 9] : ((6+6)+7)-9
[6, 6, 8, 8] : 6-(8÷(6-8))
[6, 6, 8, 9] : (6×(9-6))-8
[6, 6, 9, 9] : (6×(6+9))÷9
[6, 7, 7, 9] : (6÷(9-7))+7
[6, 7, 8, 8] : ((6+8)÷7)+8
[6, 7, 8, 9] : (6×(7+8))÷9
[6, 7, 9, 9] : 7-(9÷(6-9))
[6, 8, 8, 9] : ((8-6)×9)-8
[7, 7, 7, 8] : ((7+7)÷7)+8
[7, 7, 7, 9] : (7+(7×9))÷7
[7, 8, 8, 9] : ((7+9)÷8)+8
[7, 8, 9, 9] : ((9-7)×9)-8
[8, 8, 8, 8] : ((8+8)÷8)+8
[8, 8, 8, 9] : (8+(8×9))÷8
[8, 9, 9, 9] : 8+((9+9)÷9)
[9, 9, 9, 9] : ((9×9)+9)÷9

見せ算を導入する

さて、ここから本題です。上記のプログラムに見せ算を導入しましょう。と言っても演算子の定義を追加するだけでいいので簡単です。
ただしここでは整数値のみを扱っていますので、冒頭のルールを少し変えて実装します。

• 小数は扱わない（計算誤差を考慮するのが面倒くさい）ので、2 見せ 5 = 11とします。落とした携帯は盗られます。
• 1 見せ 100 = 83とします。美女なんていません。

Operators.h

// 見せ算
class Mise : public IOperator {
	Subtraction subtraction;

	virtual pair<int, int> operate(pair<int, int> a, pair<int, int> b) {
		if ((a.first == 6 * a.second && b.first == 9 * b.second)
			|| (a.first == 9 * a.second && b.first == 6 * b.second)) {
			return make_pair(11, 1);
		} else if ((a.first == 2 * a.second && b.first == 5 * b.second)
			|| (a.first == 5 * a.second && b.first == 2 * b.second)) {
			return make_pair(11, 1);
		} else if ((a.first == a.second && b.first == 100 * b.second)
			|| (a.first == 100 * a.second && b.first == b.second)) {
			return make_pair(83, 1);
		} else if (a.first * b.second - a.second * b.first == 0) {
			return make_pair(0, 1);
		} else if (isPositive(static_cast<IOperator&>(subtraction).operate(a, b))) {
			return a;
		} else {
			return b;
		}
	}

	virtual std::string symbol() {
		return "見せ";
	}

	// 正の数かどうか判定
	bool isPositive(pair<int, int> a) {
		if (a.first == 0) {
			return false;
		} else if (0 < a.second) {
			return (0 < a.first);
		} else {
			return (a.first < 0);
		}
	}
};

Main.cpp

    // 使用する演算子を準備
    std::vector<IOperator*> operators;
    Addition addtion;
	Subtraction subtraction;
	Multiplication multiplication;
	Division division;
    Mise mise; // ここを追加
    operators.push_back(&addtion);
    operators.push_back(&subtraction);
    operators.push_back(&multiplication);
    operators.push_back(&division);
    operators.push_back(&mise); // ここを追加

見せ算を導入した結果

10になる結果は合計580個でした！あれ？思ったより少ない。。。
見せ算導入前には存在しなかったパターンだけ記載します。

折り畳んでいます

[1, 1, 5, 9] : ((1+1)×5)見せ9
[1, 1, 7, 9] : (1×1)+(7見せ9)
[1, 1, 8, 8] : ((1+1)+8)見せ8
[1, 1, 8, 9] : ((1+1)+8)見せ9
[1, 1, 9, 9] : ((1×1)+9)見せ9
[1, 4, 4, 6] : ((1-4)見せ4)+6
[1, 5, 5, 8] : ((1×5)+5)見せ8
[1, 6, 9, 9] : (1見せ(6-9))+9
[2, 2, 7, 7] : (2×(7-2))見せ7
[3, 6, 6, 9] : ((3見せ6)÷6)+9
[3, 7, 7, 9] : ((3+7)見せ7)見せ9
[3, 9, 9, 9] : ((3見せ9)÷9)+9
[4, 4, 5, 9] : (4÷4)+(5見せ9)
[4, 4, 7, 7] : ((4見せ7)-4)+7
[4, 5, 5, 9] : ((4見せ5)+5)見せ9
[4, 8, 9, 9] : ((4見せ9)-8)+9
[4, 9, 9, 9] : ((4見せ9)÷9)+9
[5, 6, 6, 9] : ((5見せ6)÷6)+9
[5, 7, 8, 8] : ((7-5)+8)見せ8
[5, 7, 9, 9] : (5×(9-7))見せ9
[5, 8, 9, 9] : ((5見せ9)-8)+9
[6, 8, 8, 8] : ((8-6)+8)見せ8
[6, 8, 9, 9] : ((6見せ9)+8)-9
[6, 9, 9, 9] : (6見せ9)-(9÷9)
[7, 7, 8, 9] : (7÷7)+(8見せ9)
[7, 7, 9, 9] : ((7÷7)+9)見せ9
[7, 9, 9, 9] : ((7見せ9)÷9)+9
[8, 8, 9, 9] : ((8÷8)+9)見せ9

まとめ

というわけで、テンパズルに見せ算を導入してみました。できるだけ汎用的に作ったつもりなので、他にも色んなことが試せそうです。例えば、

• 計算結果を10以外の数字にしてみる
• 組み合わせる数字を4つ以外にしてみる
• 見せ算以外の他の演算子を定義してみる
• Decimalクラスの代わりに16進数クラスや素数クラスを使ってみる
• 整数値計算ではなく、ベクトルや汎関数を計算してみる

等々です。興味のある方、PCのスペックに自信のある方は是非実践してみてください。