九九出題プログラムで「7×8=?」「?×?=56」という別種類の問題を共通化or個別化して処理すべきか。

Question

九九のプログラムを作成しています。
0. 問題を作成しユーザーに出題。
0. ユーザーが答えを入力すると正解か間違いかを判定し返す。
0. 間違いの場合、正答を表示する。

という流れです。

問題には3タイプあり
0. 通常：3×4=?
0. 穴埋め：3×?=12
0. 穴埋め2：?×?=12

のいずれかがランダムで出題されます。

以下のような実装を考えてみました。

public interface IQuestion {
  bool IsCorrect(int answer);
  int GetCorrectAnswer();
}

public class QuestionNormal : IQuestion {
  int factor1; // 因数1
  int factor2; // 因数2

  bool IsCorrect(int answer) {
    return factor1 * factor2 == answer;
  }

  int GetCorrectAnswer() {
    return factor1 * factor2;
  }

}

public class QuestionAnaumeSingle: IQuestion {
  int factor; // 因数
  int product; // 積

  bool IsCorrect(int answer) {
    return factor * answer == product;
  }

  int GetCorrectAnswer() {
    return product / factor;
  }

}

public class KukuGenerator() {
  IQuestion GenerateQuestion() {
    // 問題3タイプのうちどれかを生成し返す
  }
}

// 九九の問題を作成（3タイプのうちどれか）
var question = kukuGenerator.GenerateQuestion();
// ユーザーからの入力を受け付け
var 入力 = inputProvider.GetAnswer();
// 入力された回答が合っているかのチェック
bool isCorrect = question.IsCorrect(入力);

if (isCorrect) {
  Console.Write("正解");
} else {
  Console.Write("不正解");
  // 不正解なら正解を取得
  var correctAnswer = question.GetCorrectAnswer();
  // 正解を表示
　// 問題タイプ「通常」なら「12」と表示
  // 問題タイプ「穴埋め2」なら「(2,6) (3,4) (4,3) (6,2)」と表示
  // 可能であれば文字列でなく、数値で受け取り、それを別のViewに投げて表示したい
}

##困ったこと
ここで困ったことが穴埋め2の実装です。
問題タイプによってユーザーからの回答受付数と正解の個数が以下の様に異なるため
穴埋め2のみ、回答数と正解個数が違うためうまく共通化できません。

通常：3×4=? 回答数1, 正解個数1,正解は12。
穴埋め：3×?=12 回答数1, 正解個数1,正解は4。
穴埋め2：?×?=12 回答数2, 正解個数4,正解は(2,6) (3,4) (4,3) (6,2)。

##考えたこと
インターフェースを複数の回答、正解に対応するよう変更し、問題タイプ1,2もそれに合わせて実装する。

public interface IQuestion {
  bool IsCorrect(List<int> answers);
  List<List<int>> GetCorrectAnswers();
}

しかしこれだと問題タイプ3を共通化したいがために無理やり作った感がでるためしっくりきていません。
個別にゴリゴリに書けば動作するものは作れるのですが、こういった場合に上手い実装の仕方はないでしょうか。

Comments

[Zuishin]

正解を出題者があらかじめ入力しておかなくてもその都度計算すればいいのでは？

[Zuishin]

こんな感じに簡単に書いても良さそうです。

public abstract class Question
{
public abstract bool IsCorrect(params int[] answers);
}

public class Question1 : Question
{
public Question1()
{
var random = new Random();
Factors = Enumerable.Range(0, 2).Select(_ => random.Next(9) + 1).ToList();
Answer = Factors[0] * Factors[1];
}

public IReadOnlyList<int> Factors { get; private set; }

public int Answer { get; private set; }

public override string ToString() => $"{Factors[0]}×{Factors[1]}=□";

public override bool IsCorrect(params int[] answers) =>
answers.Length == 1 && answers[0] == Answer;
}

[hinatahinata]

コメントありがとうございます。
「その都度計算する」という場合、どのクラスの役割として実装すべきでしょうか。
なるべくmain側にロジックが染み出さず、mainの変更が少なくなるようするのがスマートかなと思うのですが、上手く思い浮かびません。
そもそもの設計の仕方が良くないのでしょうか。
実装例を記述していただけると大変助かります。

[Zuishin]

IsCorrect がおかしかったので直しました。実際にコンパイルして確かめたわけではないので他にもおかしいところがあるかもしれません。一例として見てください。

[hinatahinata]

コメントかぶってしまい申し訳ありません。
実装例ありがとうございます。

この例では基底クラスを予め回答の受付数を可変にしておくことで全ての問題タイプに対応するということですね。

問題クラスの役割として
・回答が合ってるかを判定
・正解を返す
という役割を考えましたが、
Zuishinさんの前のコメントでの「正解を出題者があらかじめ入力しておかなくてもその都度計算すればいいのでは？」というお考えでは、「問題の正解を教えてくれる」役割はどこが担うべきでしょうか。

[Zuishin]

正解は IsCorrect で出ます。この考えではオーバーライドすべきは問題を成形する ToString と判定する IsCorrect のみです。

編集前のコメントではタイプ 3 の IsCorrect を書いてしまっていました。

public override bool IsCorrect(params int[] answers) => answers.Length == Factors.Count && answers.Aggregate((a, b) => a * b) == Answer;

要するに answers には空白部分をユーザーが埋めたものが順に入るので、それを計算して出題の通りになれば正解ということです。タイプ 3 の場合は answers の要素数が 2 で、それらをすべてかけたものがあらかじめ計算しておいた Answer と一致すれば正解です。正解した時、IsCorrect は true を返します。

クラスを三通り作れば三タイプの問題に対応できます。

[hinatahinata]

コメントありがとうございます。
申し訳ありません、私の質問が不十分でした。

最終的に不正解の場合に正解パターンを全て表示したいと考えています。
つまり
3x4=? の場合 12
3x?=12 の場合 4
?x?=12 の場合 (2,6) (3,4) (4,3) (6,2)
と表示したいのです。

・・・とここまでコメント頂いた中で思ったのですが
string GetCorrectAnswer()
にして内部で正解パターンの文字列を生成し返せばよいのでは？と思いました。
(正解パターンごとに分ける場合は List<string>で)

もしくは数字で欲しければ、やはり返り値をList<List<int>>とかにするのがよいのでしょうか。

[Zuishin]

string でいいと思います。ユーザーに表示する他に使い道のない値なので。もちろん List<List<int>> でもいいと思います。

[takabosoft]

横から割り込んじゃいますが、正解パターンが必須であるのならば、
List<List<int>> GetCorrectAnswers();として派生クラスでそれぞれ実装しておけば、
IsCorrectの方は派生クラスで処理しなくても、GetCorrectAnswers()の結果と一致してればOK的な処理を基本クラスかどこかに一回書いておけば済みそうかなとは思いました。

[Zuishin]

確かにその通りですね。

[hinatahinata]

Zuishinさん、takabosoftさん、コメントありがとうございます。
非常に参考になりました。

>Zuishinさん
私の拙い質問に細かく回答頂き非常に勉強になりました。
もしよろしければベストアンサーにさせていただきたいので、お時間があれば回答として投稿いただけますでしょうか？

[Zuishin]

ありがとうございます。ですが私は一例を適当に書いただけなので、もっと相応しい回答があるのではないかと思いますから辞退します。

[hinatahinata]

承知いたしました。
度々の回答、誠にありがとうございました。
質問と回答をしていく中で自分の考えがまとまっていくのを実感しました。
感謝します。

Answer 1

自分だったらどうするかなーと、いろいろいじった結果だけ載せておきます。

namespace ConsoleApp1
{
    /// <summary>
    /// 九九の問題定義クラス
    /// </summary>
    internal class KukuQuestion
    {
        /// <summary>
        /// 被乗数
        /// nullなら?とします。
        /// </summary>
        internal int? Multiplicand { get; set; }

        /// <summary>
        /// 乗数
        /// nullなら?とします。
        /// </summary>
        internal int? Multiplier { get; set; }

        /// <summary>
        /// 積
        /// nullなら?とします。
        /// </summary>
        internal int? Product { get; set; }

        /// <summary>
        /// 正解パターン
        /// </summary>
        internal int[][] CorrectAnswers { get; set; }

        /// <summary>
        /// 問題を文字列化します。
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            Func<int?, string> Conv = v => v?.ToString() ?? "?";
            return $"{Conv(Multiplicand)}×{Conv(Multiplier)}={Conv(Product)}";
        }

        /// <summary>
        /// ユーザーが入力しないといけない数字の数を取得します。
        /// 文字列処理でも良かったかもね。
        /// </summary>
        internal int NumberOfQuestion => (Multiplicand == null ? 1 : 0) + (Multiplier == null ? 1 : 0) + (Product == null ? 1 : 0);

        /// <summary>
        /// 正解判定を行います。
        /// </summary>
        /// <param name="answer"></param>
        /// <returns></returns>
        internal bool IsCorrect(int[] answer)
        {
            return CorrectAnswers.Any(a => a.SequenceEqual(answer));
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            var q = new KukuQuestion()
            {
                Multiplicand = 3,
                Multiplier = 5,
                CorrectAnswers = new int[][] { new int[] { 15 } },
            };

            Console.WriteLine($"問題:{q}");
            Console.WriteLine($"？の数:{q.NumberOfQuestion}");
            Console.WriteLine($"正解判定:{q.IsCorrect(new[] { 15 })}");

        }
    }
}

実行結果：

問題:3×5=?
？の数:1
正解判定:True

３パターンとも、あらかじめ問題と正解が固定値（不変値（あとから変わらない））なので、問題クラスとしてはただの入れ物として定義しました。
問題を生成する方は上には書いてないので頑張って実装する必要がありますが、
そこにポリモーフィズムを積極的に使う理由は今の所あんまり無いかなぁと思います。

※そもそも派生やインターフェースを使うための課題とかだったらごめんなさい

Comments

[hinatahinata]

回答ありがとうございます。
詳しい実装例も載せていただいて非常に参考になりました。
「EDGE」の作者様だったのですね！使わせていただいてます！

Answer 2

IsCorrect()の引数は無しにして，
代わりに，
必要な回答の個数分だけの回答値入力手段をIQuestionから得る…みたいな．

public interface IQuestion
{
    /// <summary>
    /// 回答の入力手段を得る
    /// </summary>
    /// <returns>
    /// 必要な個数分の，回答値を入力する手段
    /// </returns>
    Action<int>[] GetAnswerInputWays();

    /// <summary>
    /// （現在入力されている）回答が正解かどうかをチェック
    /// </summary>
    /// <returns>正解ならtrue</returns>
    bool IsCorrect();
}

---

IQuestionの具体実装と，それを使う側の雰囲気は，こんな感じでしょうか．

/// <summary>
/// □ * □ = あらかじめ定められた数
/// という，２つの答えを入力するタイプの穴埋め問題．
/// </summary>
public class QuestionImpl : IQuestion
{
    /// <summary>
    /// ctor
    /// </summary>
    /// <param name="TgtValue">
    /// □ * □ = あらかじめ定められた数
    /// という問題の右辺の値を指定．
    /// </param>
    public QuestionImpl( int TgtValue ){    m_TgtValue = TgtValue;  }

    public Action<int>[] GetAnswerInputWays()
    {
        return new Action<int>[]
            {
                (int _)=>{  m_Ans1=_;   },
                (int _)=>{  m_Ans2=_;   }
            };
    }

    public bool IsCorrect(){    return (m_Ans1 * m_Ans2 == m_TgtValue); }

    //入力された値
    //※まともにやるなら，入力前に IsCorrdct() がtrueにならないように「入力を行ったか？」がわかるような方法にする必要かもしれない．
    private int m_Ans1 = 0;
    private int m_Ans2 = 0;

    //ctorで指定された値
    private readonly int m_TgtValue;
}


class Program
{
    static void Main(string[] args)
    {
        IQuestion Q = new QuestionImpl( 15 );

        var InputActs = Q.GetAnswerInputWays();
        //※InputActsの個数をチェックして，その分だけ入力処理を行うことになるが，
        //  ここでは面倒なので，その結果として3と4が入力されたのだとする．
        InputActs[0]( 3 );
        InputActs[1]( 4 );
        Console.WriteLine( Q.IsCorrect().ToString() );  //false

        //２番目の答えを入力し直す
        InputActs[1]( 5 );
        Console.WriteLine( Q.IsCorrect().ToString() );  //true
    }
}

Comments

[hinatahinata]

コメントありがとうございます。
Action<int>[] は引数がintの配列、戻り値が無いdelegateですよね。
勉強不足で申し訳ありません、実装と処理の流れがよくわからないのですが、
これをmain側でどのように使用し、IQuestionの実装クラス側ではどのように実装するのか例をご提示いただけないでしょうか。

[fana]

Action<int> は，引数がintで戻り値無しのdelegateで，
Action<int>[]　は Action<int> の配列ですね．

とりあえず雰囲気を追記してみました．

[hinatahinata]

回答ありがとうございます。
なるほど！こういった実装方法もあるのですね、勉強になりました！

Answer 3

インターフェイスをジェネリクスにして IQuestion<T> にする
回答が全てintではなかったですね。すみません。

public class CalcQuestion : IQuestion<int, int>
{
    private readonly int First;
    private readonly int Second;
    public CalcQuestion(int x, int y)
    {
        First = x;
        Second = y;
    }

    public string Inquire() => $"{First} x {Second} = ?";

    public bool IsCorrect(int answer) => answer == First * Second;

    public int GetCorrectAnswer() => First * Second;
}
public class CombinationQuestion : IQuestion<(int, int), IEnumerable<(int, int)>>
{
    private readonly int Prod;
    private readonly IEnumerable<(int, int)> Pairs;
    public CombinationQuestion(int x)
    {
        Prod = x;
        Pairs = Enumerable.Range(1, x).Select(i => x % i == 0 ? (i, x / i) : (0, 0)).Where(t => t.Item1 != 0);
    }

    public string Inquire() => $"? x ? = {Prod}";
    public bool IsCorrect((int, int) answer) => Pairs.Contains(answer);

    public IEnumerable<(int, int)> GetCorrectAnswer() => Pairs;
}

public interface IQuestion<in T, out U>
{
    string Inquire();
    bool IsCorrect(T answer);
    U GetCorrectAnswer();
}

Comments

[hinatahinata]

回答ありがとうございます。
ジェネリクスにすることでこの問題が解決できる例が上手く思い浮かばないのですが
もしよければ実装例を記述していただけないでしょうか。

IQuestion<T>にした場合
IsCorrect(T answer)
T GetCorrectAnswer()

のように実装するのかなと考えましたが、回答数と正解個数は共通化できないと思うので実装例が浮かびませんでした。

[papinianus]

修正しました。

[hinatahinata]

回答ありがとうございます。
なるほど！こういう方法もあるのですね。勉強になります。

Answer 4

本質問に回答するまでC#を書いたことがなかったため、間違っている可能性もありますが、質問者様のアイデアの種となれば幸いです。

public class Answer {
    readonly int? single;
    readonly Dictionary<int, int>? multiple;

    public Answer(int? single, Dictionary<int, int>? multiple) {
        this.single = single;
        this.multiple = multiple;
    }

    public int? GetSingle() {
        return single;
    }

    public Dictionary<int, int>? GetMultiple() {
        return multiple;
    }
}

public interface IQuestion {
    bool IsCorrect(int firstAnswer, int? secondAnswer = null);
    Answer GetCorrectAnswer();
}


public class QuestionNormal : IQuestion {
  int factor1; // 因数1
  int factor2; // 因数2

  bool IsCorrect(int firstAnswer, int? secondAnswer = null) {
    if (secondAnswer != null) throw new Exception();
    return factor1 * factor2 == firstAnswer;
  }

  Answer GetCorrectAnswer() {
    return new Answer(factor1 * factor2, null);
  }
}

public class QuestionAnaumeSingle: IQuestion {
  int factor; // 因数
  int product; // 積

  bool IsCorrect(int firstAnswer, int? secondAnswer = null) {
    if (secondAnswer != null) throw new Exception();
    return factor * firstAnswer == product;
  }

  Answer GetCorrectAnswer() {
    return new Answer(product / factor, null);
  }
}

public class QuestionAnaumeDouble: IQuestion {
  int product; // 積

  bool IsCorrect(int firstAnswer, int? secondAnswer = null) {
    if (secondAnswer == null) throw new Exception();
    return firstAnswer * secondAnswer == product;
  }

  Answer GetCorrectAnswer() {
    Dictionary<int, int>? multiple = new Dictionary<int, int>();
    // 省略：解答の組み合わせを辞書に重複しないように追加
    return new Answer(null, multiple);
  }
}

Comments

[hinatahinata]

回答ありがとうございます。
「正答」のクラスを別に定義するパターンですね。
勉強になります。