【確率シミュレータ】情報セキュリティマネジメント試験 ランダムマークの合格率計算

以下の配点として計算します。

• 科目A：No1～48。1問あたり1点とする。
• 科目B：No49～60。1問あたり4点とする。ただし、選択肢が9択と10択の4問は5点とする。
• 各問題の完全ランダム正答率: その問題の「選択肢の数」列の値の逆数（例: 4択なら1/4、8択なら1/8、10択なら1/10）。

出典：情報セキュリティマネジメント試験 サンプル問題セットを分析し、選択肢の数を準拠。🔗取り扱いガイドライン

情報セキュリティマネジメント合格確率シミュレーションのロジック

情報セキュリティマネジメント試験の合格確率をモンテカルロシミュレーションで計算するためのロジックは、以下の手順で行います。このシミュレーションは、IRT（項目応答理論）ではなく、各問題の配点が定義された「素点計算」に基づきます。

1. 問題データとシミュレーション定数の定義

• 全60問の問題データを表現するためのデータ構造（例: クラスのリストや構造体の配列）を用意します。各問題は以下の情報を持つとします。
  • No (問題番号: 1-60)
  • 選択肢の数 (例: 4, 8, 10)
  • 配点 (例: 1, 4, 5)
  具体的な問題データ（配列やリストとして初期化）:// 例: 問題データを格納する構造体のリスト 問題リスト = [ {No: 1, 選択肢の数: 4, 配点: 1}, {No: 2, 選択肢の数: 4, 配点: 1}, // ... 中略 ... {No: 48, 選択肢の数: 4, 配点: 1}, {No: 49, 選択肢の数: 4, 配点: 4}, {No: 50, 選択肢の数: 8, 配点: 4}, {No: 51, 選択肢の数: 10, 配点: 5}, {No: 52, 選択肢の数: 8, 配点: 4}, {No: 53, 選択肢の数: 10, 配点: 5}, {No: 54, 選択肢の数: 6, 配点: 4}, {No: 55, 選択肢の数: 4, 配点: 4}, {No: 56, 選択肢の数: 5, 配点: 4}, {No: 57, 選択肢の数: 4, 配点: 4}, {No: 58, 選択肢の数: 9, 配点: 5}, {No: 59, 選択肢の数: 5, 配点: 4}, {No: 60, 選択肢の数: 10, 配点: 5} ]
• シミュレーション定数:
  • TOTAL_QUESTIONS: 60 (総問題数)
  • REQUIRED_TOTAL_SCORE: 60 (合格に必要な合計点数)
  • DEFAULT_TRIALS: 10000 (デフォルトの試行回数)

2. 1回の試行における問題の解答シミュレーション

各モンテカルロ試行において、以下の手順でTOTAL_QUESTIONS問全ての解答をシミュレートします。

• 「事前に知っている問題」の処理:
  • シミュレーションの入力として設定された「事前に知っている正解数」（例: 全体60問中の10問）を決定します。
  • TOTAL_QUESTIONS問の問題リストの中から、この指定数分だけランダムに異なる問題を選択し、それらの問題を「正解」とします。 これらの問題は、その問題に設定された「配点」をそのまま獲得します。
  • この際、同じ問題が複数回選ばれないように配慮します。
• 「残りの問題」の処理（ランダム解答）:
  • 「事前に知っている問題」としてマークされていない、残りの問題（TOTAL_QUESTIONS − 事前に知っている正解数 問）に対して、ランダムに解答をシミュレートします。
  • このランダム解答の正答率は、「選択肢を絞り込める学力」に応じて設定します。シミュレーションでは以下の3パターンを想定します。
    • 「0%の不正解を消す力（完全ランダム）」の場合: 各問題の正答率は、その問題の「選択肢の数」の逆数とします。（例: 4択なら1/4、8択なら1/8、10択なら1/10） これは、完全に勘で解答する場合に相当します。
    • 「25%の不正解を消す力」の場合: このシナリオでは、元の選択肢の数から25%の不正解選択肢を確実に除外し、残りの選択肢からランダムに解答する状況を想定します。 各問題における有効な選択肢の数は、Math.round(元の選択肢の数 × 0.75) と計算し、この有効な選択肢の数の逆数を正答率とします。 例:
      • 4択（選択肢4つ）の場合: Math.round(4 × 0.75) = 3 なので、3択から選ぶ。正答率は約33.33%（1/3）とします。
      • 8択（選択肢8つ）の場合: Math.round(8 × 0.75) = 6 なので、6択から選ぶ。正答率は約16.67%（1/6）とします。
      • 10択（選択肢10つ）の場合: Math.round(10 × 0.75) = 8 なので、8択から選ぶ。正答率は12.5%（1/8）とします。
      • ※有効な選択肢の数が1未満になる場合は、最小値1とします（全問正解とみなす）。
    • 「50%の不正解を消す力」の場合: このシナリオでは、元の選択肢の数から50%の不正解選択肢を確実に除外し、残りの選択肢からランダムに解答する状況を想定します。 各問題における有効な選択肢の数は、Math.round(元の選択肢の数 × 0.50) と計算し、この有効な選択肢の数の逆数を正答率とします。 例:
      • 4択（選択肢4つ）の場合: Math.round(4 × 0.50) = 2 なので、2択から選ぶ。正答率は50%（1/2）とします。
      • 8択（選択肢8つ）の場合: Math.round(8 × 0.50) = 4 なので、4択から選ぶ。正答率は25%（1/4）とします。
      • 10択（選択肢10つ）の場合: Math.round(10 × 0.50) = 5 なので、5択から選ぶ。正答率は20%（1/5）とします。
      • ※有効な選択肢の数が1未満になる場合は、最小値1とします（全問正解とみなす）。
  • 正解と判定された場合、その問題に設定された「配点」を合計点に加算します。不正解の場合は0点です。

3. 合格条件の判定

1回の試行で60問全ての解答が決定したら、以下の合格条件をチェックします。この条件を満たした場合のみ、その試行を「合格」とカウントします。

• 総合評価チェック:
  • 上記「2. 1回の試行における問題の解答シミュレーション」で計算された全60問の合計得点を算出します。
  • この合計得点が、REQUIRED_TOTAL_SCORE（60点）以上であるかを確認します。
  • もし60点未満であれば、この試行は不合格とします。
• 上記のチェックに合格した場合のみ、この1回の試行を「合格」と数え上げます。

4. 合格率の算出

上記の「1回の試行」を指定された回数（例: DEFAULT_TRIALS）繰り返します。 最終的に、「合格」と判定された試行の総数を、全試行回数で割ることで、合格率（パーセンテージ）を算出します。

（補足）本シミュレーターにおける「事前に知っている問題」の解釈について

情報セキュリティマネジメント試験の科目Bは、事例形式であり、また採点にはIRT（項目応答理論）が用いられるため、その得点を素点計算で厳密にシミュレートすることは困難です。

本シミュレーターでは、科目B（特に配点の高い問題）を含む「事前に知っている問題」とは、受験者の方が「自身の知識と理解に基づいて、確実に正解できると確信している問題」と読み替えることを想定しています。

これにより、IRT採点の「難しい問題を正解すると高得点が得られる傾向」を素点計算上で近似的に表現しつつ、受験者の方が自身の得意分野や学習効果をシミュレーションに反映させ、より現実的な学習戦略を検討するための参考として活用いただけます。

IsmsSimulator.java
--------------------------------------------------------------------------------------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.HashSet;

/**
 * 情報セキュリティマネジメント試験の合格確率をモンテカルロシミュレーションで計算するシミュレーター。
 * 各問題の配点設定に基づいた「素点計算」により合格率を算出します。
 * 本シミュレーターはIRT（項目応答理論）採点を再現するものではありません。
 */
public class IsmsSimulator {

    // 情報セキュリティマネジメント試験の定数（素点計算に基づく）
    private static final int TOTAL_QUESTIONS = 60; // 総問題数
    private static final int DEFAULT_TRIALS = 10000; // 各シナリオでのデフォルト試行回数

    // 合格に必要な合計得点
    // 総合評価点600点以上 / 1000点 -> 100点満点中 (600/1000) * 100 = 60点
    private static final int REQUIRED_TOTAL_SCORE = 60;

    /**
     * 各問題の定義。問題番号、選択肢の数、配点を保持します。
     */
    public static class Question {
        private final int no;
        private final int choices;
        private final int score;

        public Question(int no, int choices, int score) {
            this.no = no;
            this.choices = choices;
            this.score = score;
        }

        public int getNo() { return no; }
        public int getChoices() { return choices; }
        public int getScore() { return score; }
    }

    // 全60問の問題データ（No, 選択肢の数, 配点）
    private static final List<Question> QUESTIONS = new ArrayList<>();

    static {
        // No. 1-48: 4択1点問題
        for (int i = 1; i <= 48; i++) {
            QUESTIONS.add(new Question(i, 4, 1));
        }
        // No. 49: 4択4点問題
        QUESTIONS.add(new Question(49, 4, 4));
        // No. 50: 8択4点問題
        QUESTIONS.add(new Question(50, 8, 4));
        // No. 51: 10択5点問題
        QUESTIONS.add(new Question(51, 10, 5));
        // No. 52: 8択4点問題
        QUESTIONS.add(new Question(52, 8, 4));
        // No. 53: 10択5点問題
        QUESTIONS.add(new Question(53, 10, 5));
        // No. 54: 6択4点問題
        QUESTIONS.add(new Question(54, 6, 4));
        // No. 55: 4択4点問題
        QUESTIONS.add(new Question(55, 4, 4));
        // No. 56: 5択4点問題
        QUESTIONS.add(new Question(56, 5, 4));
        // No. 57: 4択4点問題
        QUESTIONS.add(new Question(57, 4, 4));
        // No. 58: 9択5点問題
        QUESTIONS.add(new Question(58, 9, 5));
        // No. 59: 5択4点問題
        QUESTIONS.add(new Question(59, 5, 4));
        // No. 60: 10択5点問題
        QUESTIONS.add(new Question(60, 10, 5));
    }

    /**
     * ランダム解答方式を定義する列挙型。
     * 各方式で、元の選択肢数から計算される有効な選択肢数を保持し、正答率を決定します。
     */
    public enum AnswerMethod {
        // 完全ランダム（不正解を0%消す力）
        FULL_RANDOM("0%の不正解を消す力（完全ランダム）", 0.0),
        // 不正解を25%消す力
        ELIMINATE_25_PERCENT("25%の不正解を消す力", 0.25),
        // 不正解を50%消す力
        ELIMINATE_50_PERCENT("50%の不正解を消す力", 0.50);

        private final String name;
        private final double eliminationRate; // 除外する不正解の割合

        AnswerMethod(String name, double eliminationRate) {
            this.name = name;
            this.eliminationRate = eliminationRate;
        }

        public String getName() {
            return name;
        }

        /**
         * 指定された問題の有効な選択肢数を計算します。
         * Math.round() を使用し、最小値は1とします。
         * @param originalChoices 元の選択肢の数
         * @return 計算された有効な選択肢の数
         */
        public int calculateEffectiveChoices(int originalChoices) {
            // 除外後の選択肢数を計算
            double remainingChoices = originalChoices * (1.0 - eliminationRate);
            // Math.round で丸め、小数点以下を四捨五入して整数にする
            int effectiveChoices = (int) Math.round(remainingChoices);
            // 少なくとも1つの選択肢は残るようにする
            return Math.max(1, effectiveChoices);
        }

        /**
         * ランダムに正解するかどうかを判定します。
         * @param random Randomインスタンス
         * @param question 問題オブジェクト
         * @return 正解であればtrue、そうでなければfalse
         */
        public boolean isCorrect(Random random, Question question) {
            int effectiveChoices = calculateEffectiveChoices(question.getChoices());
            // 0からeffectiveChoices-1までの乱数を生成し、0であれば正解とみなす
            return random.nextInt(effectiveChoices) == 0;
        }
    }

    /**
     * シミュレーション結果を保持するクラス。
     */
    public static class SimulationResult {
        private final int knownCorrectQuestions;
        private final double successRate;

        public SimulationResult(int knownCorrectQuestions, double successRate) {
            this.knownCorrectQuestions = knownCorrectQuestions;
            this.successRate = successRate;
        }

        public int getKnownCorrectQuestions() { return knownCorrectQuestions; }
        public double getSuccessRate() { return successRate; }
    }

    private final Random random;

    /**
     * IsmsSimulator の新しいインスタンスを生成します。
     */
    public IsmsSimulator() {
        this.random = new Random();
    }

    /**
     * 指定されたシナリオでモンテカルロシミュレーションを実行し、合格確率を計算します。
     *
     * @param answerMethod            シミュレーション対象の解答方式（ランダム解答の精度）
     * @param knownCorrectQuestions   事前に知っている正解数（60問全体に対する数）
     * @param trials                  試行回数
     * @return シミュレーション結果を表す {@code SimulationResult} オブジェクト
     * @throws IllegalArgumentException 不正な引数が指定された場合
     */
    public SimulationResult simulateScenario(AnswerMethod answerMethod, int knownCorrectQuestions, int trials) {
        if (knownCorrectQuestions < 0 || knownCorrectQuestions > TOTAL_QUESTIONS) {
            throw new IllegalArgumentException(
                "事前に知っている正解数 (" + knownCorrectQuestions + ") は、0から総問題数 (" + TOTAL_QUESTIONS + ") の範囲で指定してください。"
            );
        }
        if (trials <= 0) {
            throw new IllegalArgumentException("試行回数は1以上を指定してください。");
        }

        int successfulTrials = 0;

        for (int i = 0; i < trials; i++) {
            // 各問題の得点を格納する配列（インデックスは0から59にマップ）
            int[] currentScores = new int[TOTAL_QUESTIONS];
            // 既に「事前に知っている問題」としてマークされた問題のインデックスを保持
            Set<Integer> knownCorrectIndices = new HashSet<>();

            // 1. 「事前に知っている問題」の処理
            List<Integer> questionIndices = new ArrayList<>();
            for (int k = 0; k < TOTAL_QUESTIONS; k++) {
                questionIndices.add(k);
            }
            Collections.shuffle(questionIndices, random); // 問題インデックスをシャッフル

            // シャッフルされたリストからknownCorrectQuestions分だけ選び、正解とする
            for (int k = 0; k < knownCorrectQuestions; k++) {
                int questionIndex = questionIndices.get(k); // シャッフルされたインデックス
                currentScores[questionIndex] = QUESTIONS.get(questionIndex).getScore(); // その問題の配点を加算
                knownCorrectIndices.add(questionIndex); // 既に処理済みとしてマーク
            }

            // 2. 「残りの問題」の処理（ランダム解答）
            for (int j = 0; j < TOTAL_QUESTIONS; j++) {
                if (!knownCorrectIndices.contains(j)) { // 事前に知っている問題でなければランダムに解答
                    // その問題オブジェクトを取得
                    Question question = QUESTIONS.get(j);
                    if (answerMethod.isCorrect(random, question)) {
                        currentScores[j] = question.getScore(); // 正解なら配点を加算
                    } else {
                        currentScores[j] = 0; // 不正解なら0点
                    }
                }
            }

            // 3. 合格条件の判定（総合評価のみ）
            int totalEarnedScore = 0;
            for (int score : currentScores) {
                totalEarnedScore += score;
            }

            if (totalEarnedScore >= REQUIRED_TOTAL_SCORE) {
                successfulTrials++;
            }
        }

        double successRate = (double) successfulTrials / trials * 100;
        return new SimulationResult(knownCorrectQuestions, successRate);
    }

    /**
     * シミュレーション結果を表示します。
     *
     * @param result 表示するシミュレーション結果
     */
    public void displayResult(SimulationResult result) {
        System.out.printf("・事前に%d問知っている場合: 合格率: %.2f%%\n", 
                         result.getKnownCorrectQuestions(), result.getSuccessRate());
    }

    /**
     * メインメソッド。情報セキュリティマネジメント試験の各種シナリオでシミュレーションを実行します。
     */
    public static void main(String[] args) {
        IsmsSimulator simulator = new IsmsSimulator();

        System.out.println("★情報セキュリティマネジメント試験 突破確率計算：ランダム選択方式（モンテカルロシミュレーション）★");
        System.out.println("---");
        System.out.println("総問題数: " + TOTAL_QUESTIONS + "問");
        System.out.println("合格に必要な合計得点: " + REQUIRED_TOTAL_SCORE + "点 / 100点満点");
        System.out.println("---");
        System.out.println();

        // 各解答方式のシミュレーション
        for (AnswerMethod answerMethod : AnswerMethod.values()) {
            System.out.println("■" + answerMethod.getName() + " 試行結果");
            // knownCorrectQuestions は0問からTOTAL_QUESTIONSまで繰り返す
            for (int i = 0; i <= TOTAL_QUESTIONS; i++) {
                try {
                    SimulationResult result = simulator.simulateScenario(answerMethod, i, DEFAULT_TRIALS);
                    simulator.displayResult(result);
                } catch (IllegalArgumentException e) {
                    System.err.println("エラー: " + e.getMessage());
                }
            }
            System.out.println(); // 各解答方式の後に空行
        }
        System.out.println("---");
        System.out.println("※本シミュレーターは、情報セキュリティマネジメント試験のIRT（項目応答理論）採点を厳密に再現するものではなく、");
        System.out.println("  各問題の配点が上記で設定された値であると仮定した「素点計算」に基づいています。");
        System.out.println("  実際の試験結果と異なる場合があることをご留意ください。");
    }
}

★情報セキュリティマネジメント試験 突破確率計算：ランダム選択方式（モンテカルロシミュレーション）★
---
総問題数: 60問
合格に必要な合計得点: 60点 / 100点満点
---

■0%の不正解を消す力（完全ランダム） 試行結果
・事前に0問知っている場合: 合格率: 0.00%
・事前に1問知っている場合: 合格率: 0.00%
・事前に2問知っている場合: 合格率: 0.00%
・事前に3問知っている場合: 合格率: 0.00%
・事前に4問知っている場合: 合格率: 0.00%
・事前に5問知っている場合: 合格率: 0.01%
・事前に6問知っている場合: 合格率: 0.00%
・事前に7問知っている場合: 合格率: 0.00%
・事前に8問知っている場合: 合格率: 0.00%
・事前に9問知っている場合: 合格率: 0.00%
・事前に10問知っている場合: 合格率: 0.03%
・事前に11問知っている場合: 合格率: 0.02%
・事前に12問知っている場合: 合格率: 0.08%
・事前に13問知っている場合: 合格率: 0.10%
・事前に14問知っている場合: 合格率: 0.18%
・事前に15問知っている場合: 合格率: 0.30%
・事前に16問知っている場合: 合格率: 0.38%
・事前に17問知っている場合: 合格率: 0.80%
・事前に18問知っている場合: 合格率: 1.35%
・事前に19問知っている場合: 合格率: 2.10%
・事前に20問知っている場合: 合格率: 3.61%
・事前に21問知っている場合: 合格率: 5.21%
・事前に22問知っている場合: 合格率: 7.08%
・事前に23問知っている場合: 合格率: 9.73%
・事前に24問知っている場合: 合格率: 14.00%
・事前に25問知っている場合: 合格率: 17.85%
・事前に26問知っている場合: 合格率: 23.70%
・事前に27問知っている場合: 合格率: 30.38%
・事前に28問知っている場合: 合格率: 37.80%
・事前に29問知っている場合: 合格率: 46.58%
・事前に30問知っている場合: 合格率: 53.52%
・事前に31問知っている場合: 合格率: 62.18%
・事前に32問知っている場合: 合格率: 70.09%
・事前に33問知っている場合: 合格率: 76.29%
・事前に34問知っている場合: 合格率: 83.36%
・事前に35問知っている場合: 合格率: 88.50%
・事前に36問知っている場合: 合格率: 91.98%
・事前に37問知っている場合: 合格率: 95.36%
・事前に38問知っている場合: 合格率: 97.21%
・事前に39問知っている場合: 合格率: 98.35%
・事前に40問知っている場合: 合格率: 99.29%
・事前に41問知っている場合: 合格率: 99.55%
・事前に42問知っている場合: 合格率: 99.86%
・事前に43問知っている場合: 合格率: 99.95%
・事前に44問知っている場合: 合格率: 99.97%
・事前に45問知っている場合: 合格率: 100.00%
・事前に46問知っている場合: 合格率: 100.00%
・事前に47問知っている場合: 合格率: 100.00%
・事前に48問知っている場合: 合格率: 100.00%
・事前に49問知っている場合: 合格率: 100.00%
・事前に50問知っている場合: 合格率: 100.00%
・事前に51問知っている場合: 合格率: 100.00%
・事前に52問知っている場合: 合格率: 100.00%
・事前に53問知っている場合: 合格率: 100.00%
・事前に54問知っている場合: 合格率: 100.00%
・事前に55問知っている場合: 合格率: 100.00%
・事前に56問知っている場合: 合格率: 100.00%
・事前に57問知っている場合: 合格率: 100.00%
・事前に58問知っている場合: 合格率: 100.00%
・事前に59問知っている場合: 合格率: 100.00%
・事前に60問知っている場合: 合格率: 100.00%

■25%の不正解を消す力 試行結果
・事前に0問知っている場合: 合格率: 0.00%
・事前に1問知っている場合: 合格率: 0.00%
・事前に2問知っている場合: 合格率: 0.01%
・事前に3問知っている場合: 合格率: 0.01%
・事前に4問知っている場合: 合格率: 0.00%
・事前に5問知っている場合: 合格率: 0.02%
・事前に6問知っている場合: 合格率: 0.03%
・事前に7問知っている場合: 合格率: 0.07%
・事前に8問知っている場合: 合格率: 0.10%
・事前に9問知っている場合: 合格率: 0.12%
・事前に10問知っている場合: 合格率: 0.22%
・事前に11問知っている場合: 合格率: 0.39%
・事前に12問知っている場合: 合格率: 0.51%
・事前に13問知っている場合: 合格率: 0.83%
・事前に14問知っている場合: 合格率: 1.38%
・事前に15問知っている場合: 合格率: 2.06%
・事前に16問知っている場合: 合格率: 3.43%
・事前に17問知っている場合: 合格率: 4.79%
・事前に18問知っている場合: 合格率: 6.51%
・事前に19問知っている場合: 合格率: 8.36%
・事前に20問知っている場合: 合格率: 11.71%
・事前に21問知っている場合: 合格率: 15.17%
・事前に22問知っている場合: 合格率: 20.47%
・事前に23問知っている場合: 合格率: 25.55%
・事前に24問知っている場合: 合格率: 30.47%
・事前に25問知っている場合: 合格率: 36.14%
・事前に26問知っている場合: 合格率: 44.44%
・事前に27問知っている場合: 合格率: 51.21%
・事前に28問知っている場合: 合格率: 57.55%
・事前に29問知っている場合: 合格率: 66.09%
・事前に30問知っている場合: 合格率: 71.83%
・事前に31問知っている場合: 合格率: 78.54%
・事前に32問知っている場合: 合格率: 83.13%
・事前に33問知っている場合: 合格率: 88.37%
・事前に34問知っている場合: 合格率: 91.38%
・事前に35問知っている場合: 合格率: 94.52%
・事前に36問知っている場合: 合格率: 96.30%
・事前に37問知っている場合: 合格率: 97.56%
・事前に38問知っている場合: 合格率: 98.75%
・事前に39問知っている場合: 合格率: 99.19%
・事前に40問知っている場合: 合格率: 99.69%
・事前に41問知っている場合: 合格率: 99.82%
・事前に42問知っている場合: 合格率: 99.96%
・事前に43問知っている場合: 合格率: 99.97%
・事前に44問知っている場合: 合格率: 99.99%
・事前に45問知っている場合: 合格率: 100.00%
・事前に46問知っている場合: 合格率: 100.00%
・事前に47問知っている場合: 合格率: 100.00%
・事前に48問知っている場合: 合格率: 100.00%
・事前に49問知っている場合: 合格率: 100.00%
・事前に50問知っている場合: 合格率: 100.00%
・事前に51問知っている場合: 合格率: 100.00%
・事前に52問知っている場合: 合格率: 100.00%
・事前に53問知っている場合: 合格率: 100.00%
・事前に54問知っている場合: 合格率: 100.00%
・事前に55問知っている場合: 合格率: 100.00%
・事前に56問知っている場合: 合格率: 100.00%
・事前に57問知っている場合: 合格率: 100.00%
・事前に58問知っている場合: 合格率: 100.00%
・事前に59問知っている場合: 合格率: 100.00%
・事前に60問知っている場合: 合格率: 100.00%

■50%の不正解を消す力 試行結果
・事前に0問知っている場合: 合格率: 0.75%
・事前に1問知っている場合: 合格率: 1.04%
・事前に2問知っている場合: 合格率: 1.15%
・事前に3問知っている場合: 合格率: 1.73%
・事前に4問知っている場合: 合格率: 2.13%
・事前に5問知っている場合: 合格率: 2.94%
・事前に6問知っている場合: 合格率: 4.65%
・事前に7問知っている場合: 合格率: 5.56%
・事前に8問知っている場合: 合格率: 6.83%
・事前に9問知っている場合: 合格率: 8.94%
・事前に10問知っている場合: 合格率: 10.01%
・事前に11問知っている場合: 合格率: 13.01%
・事前に12問知っている場合: 合格率: 16.66%
・事前に13問知っている場合: 合格率: 20.17%
・事前に14問知っている場合: 合格率: 22.94%
・事前に15問知っている場合: 合格率: 26.96%
・事前に16問知っている場合: 合格率: 31.22%
・事前に17問知っている場合: 合格率: 37.36%
・事前に18問知っている場合: 合格率: 41.56%
・事前に19問知っている場合: 合格率: 47.48%
・事前に20問知っている場合: 合格率: 52.62%
・事前に21問知っている場合: 合格率: 58.28%
・事前に22問知っている場合: 合格率: 64.01%
・事前に23問知っている場合: 合格率: 68.98%
・事前に24問知っている場合: 合格率: 73.72%
・事前に25問知っている場合: 合格率: 78.03%
・事前に26問知っている場合: 合格率: 82.23%
・事前に27問知っている場合: 合格率: 85.46%
・事前に28問知っている場合: 合格率: 88.60%
・事前に29問知っている場合: 合格率: 92.15%
・事前に30問知っている場合: 合格率: 93.82%
・事前に31問知っている場合: 合格率: 95.53%
・事前に32問知っている場合: 合格率: 96.82%
・事前に33問知っている場合: 合格率: 97.98%
・事前に34問知っている場合: 合格率: 98.56%
・事前に35問知っている場合: 合格率: 99.11%
・事前に36問知っている場合: 合格率: 99.35%
・事前に37問知っている場合: 合格率: 99.66%
・事前に38問知っている場合: 合格率: 99.85%
・事前に39問知っている場合: 合格率: 99.88%
・事前に40問知っている場合: 合格率: 99.94%
・事前に41問知っている場合: 合格率: 99.98%
・事前に42問知っている場合: 合格率: 99.99%
・事前に43問知っている場合: 合格率: 99.99%
・事前に44問知っている場合: 合格率: 100.00%
・事前に45問知っている場合: 合格率: 100.00%
・事前に46問知っている場合: 合格率: 100.00%
・事前に47問知っている場合: 合格率: 99.99%
・事前に48問知っている場合: 合格率: 100.00%
・事前に49問知っている場合: 合格率: 100.00%
・事前に50問知っている場合: 合格率: 100.00%
・事前に51問知っている場合: 合格率: 100.00%
・事前に52問知っている場合: 合格率: 100.00%
・事前に53問知っている場合: 合格率: 100.00%
・事前に54問知っている場合: 合格率: 100.00%
・事前に55問知っている場合: 合格率: 100.00%
・事前に56問知っている場合: 合格率: 100.00%
・事前に57問知っている場合: 合格率: 100.00%
・事前に58問知っている場合: 合格率: 100.00%
・事前に59問知っている場合: 合格率: 100.00%
・事前に60問知っている場合: 合格率: 100.00%

---
※本シミュレーターは、情報セキュリティマネジメント試験のIRT（項目応答理論）採点を厳密に再現するものではなく、
  各問題の配点が上記で設定された値であると仮定した「素点計算」に基づいています。
  実際の試験結果と異なる場合があることをご留意ください。