<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<!-- question: 0  -->
  <question type="category">
    <category>
      <text>$course$/top/I.6 Brüche am Zahlenstrahl/gekürzt</text>
    </category>
    <info format="html">
      <text></text>
    </info>
    <idnumber></idnumber>
  </question>

<!-- question: 21529  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 10/3 - 13~16~20~23 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{10}{3} \)?</p>
    <canvas id="canvas-10-3-13~16~20~23-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-10-3-13~16~20~23-k");
        drawNumberline(canvas, "13~16~20~23", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21527  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 10/3 - 13~18~20~22 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{10}{3} \)?</p>
    <canvas id="canvas-10-3-13~18~20~22-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-10-3-13~18~20~22-k");
        drawNumberline(canvas, "13~18~20~22", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21543  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 10/3 - 15~16~18~20 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{10}{3} \)?</p>
    <canvas id="canvas-10-3-15~16~18~20-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-10-3-15~16~18~20-k");
        drawNumberline(canvas, "15~16~18~20", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21563  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 10/3 - 20~25~30~32 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{10}{3} \)?</p>
    <canvas id="canvas-10-3-20~25~30~32-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-10-3-20~25~30~32-k");
        drawNumberline(canvas, "20~25~30~32", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21561  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 11/2 - 20~21~22~24 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{11}{2} \)?</p>
    <canvas id="canvas-11-2-20~21~22~24-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-11-2-20~21~22~24-k");
        drawNumberline(canvas, "20~21~22~24", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21575  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 11/2 - 22~24~29~31 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{11}{2} \)?</p>
    <canvas id="canvas-11-2-22~24~29~31-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-11-2-22~24~29~31-k");
        drawNumberline(canvas, "22~24~29~31", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21555  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 11/3 - 17~21~22~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{11}{3} \)?</p>
    <canvas id="canvas-11-3-17~21~22~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-11-3-17~21~22~26-k");
        drawNumberline(canvas, "17~21~22~26", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21559  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 11/3 - 19~22~25~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{11}{3} \)?</p>
    <canvas id="canvas-11-3-19~22~25~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-11-3-19~22~25~26-k");
        drawNumberline(canvas, "19~22~25~26", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21525  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 11/4 - 12~17~19~22 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{11}{4} \)?</p>
    <canvas id="canvas-11-4-12~17~19~22-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-11-4-12~17~19~22-k");
        drawNumberline(canvas, "12~17~19~22", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21435  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/2 - 0~1~4~5 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{2} \)?</p>
    <canvas id="canvas-1-2-0~1~4~5-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-2-0~1~4~5-k");
        drawNumberline(canvas, "0~1~4~5", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21451  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/2 - 3~8~13~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{2} \)?</p>
    <canvas id="canvas-1-2-3~8~13~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-2-3~8~13~16-k");
        drawNumberline(canvas, "3~8~13~16", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21453  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/2 - 4~5~9~11 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{2} \)?</p>
    <canvas id="canvas-1-2-4~5~9~11-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-2-4~5~9~11-k");
        drawNumberline(canvas, "4~5~9~11", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21455  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/2 - 4~9~14~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{2} \)?</p>
    <canvas id="canvas-1-2-4~9~14~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-2-4~9~14~18-k");
        drawNumberline(canvas, "4~9~14~18", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21567  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/2 - 21~22~26~29 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{2} \)?</p>
    <canvas id="canvas-13-2-21~22~26~29-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-2-21~22~26~29-k");
        drawNumberline(canvas, "21~22~26~29", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21573  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/2 - 21~26~28~31 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{2} \)?</p>
    <canvas id="canvas-13-2-21~26~28~31-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-2-21~26~28~31-k");
        drawNumberline(canvas, "21~26~28~31", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21577  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/3 - 22~26~31~32 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{3} \)?</p>
    <canvas id="canvas-13-3-22~26~31~32-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-3-22~26~31~32-k");
        drawNumberline(canvas, "22~26~31~32", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21585  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/3 - 23~24~26~29 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{3} \)?</p>
    <canvas id="canvas-13-3-23~24~26~29-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-3-23~24~26~29-k");
        drawNumberline(canvas, "23~24~26~29", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21587  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/3 - 24~26~27~32 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{3} \)?</p>
    <canvas id="canvas-13-3-24~26~27~32-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-3-24~26~27~32-k");
        drawNumberline(canvas, "24~26~27~32", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21591  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/3 - 26~29~31~34 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{3} \)?</p>
    <canvas id="canvas-13-3-26~29~31~34-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-3-26~29~31~34-k");
        drawNumberline(canvas, "26~29~31~34", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21589  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/3 - 26~29~33~37 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{3} \)?</p>
    <canvas id="canvas-13-3-26~29~33~37-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-3-26~29~33~37-k");
        drawNumberline(canvas, "26~29~33~37", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21581  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/4 - 22~24~26~27 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{4} \)?</p>
    <canvas id="canvas-13-4-22~24~26~27-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-4-22~24~26~27-k");
        drawNumberline(canvas, "22~24~26~27", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21579  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 13/4 - 22~26~27~32 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{13}{4} \)?</p>
    <canvas id="canvas-13-4-22~26~27~32-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-13-4-22~26~27~32-k");
        drawNumberline(canvas, "22~26~27~32", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21447  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/4 - 2~3~6~9 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{4} \)?</p>
    <canvas id="canvas-1-4-2~3~6~9-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-4-2~3~6~9-k");
        drawNumberline(canvas, "2~3~6~9", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21445  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 1/4 - 2~4~6~11 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{1}{4} \)?</p>
    <canvas id="canvas-1-4-2~4~6~11-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-1-4-2~4~6~11-k");
        drawNumberline(canvas, "2~4~6~11", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21459  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 2/3 - 4~5~10~12 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{2}{3} \)?</p>
    <canvas id="canvas-2-3-4~5~10~12-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-2-3-4~5~10~12-k");
        drawNumberline(canvas, "4~5~10~12", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21457  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 2/3 - 4~5~8~12 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{2}{3} \)?</p>
    <canvas id="canvas-2-3-4~5~8~12-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-2-3-4~5~8~12-k");
        drawNumberline(canvas, "4~5~8~12", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21461  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 2/3 - 4~7~8~9 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{2}{3} \)?</p>
    <canvas id="canvas-2-3-4~7~8~9-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-2-3-4~7~8~9-k");
        drawNumberline(canvas, "4~7~8~9", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21523  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 12~15~17~22 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-12~15~17~22-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-12~15~17~22-k");
        drawNumberline(canvas, "12~15~17~22", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21521  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 12~17~21~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-12~17~21~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-12~17~21~26-k");
        drawNumberline(canvas, "12~17~21~26", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21437  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 1~2~6~11 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-1~2~6~11-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-1~2~6~11-k");
        drawNumberline(canvas, "1~2~6~11", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21473  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 5~9~13~17 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-5~9~13~17-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-5~9~13~17-k");
        drawNumberline(canvas, "5~9~13~17", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21483  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 6~9~10~12 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-6~9~10~12-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-6~9~10~12-k");
        drawNumberline(canvas, "6~9~10~12", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21481  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 6~9~13~14 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-6~9~13~14-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-6~9~13~14-k");
        drawNumberline(canvas, "6~9~13~14", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21493  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 7~9~13~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-7~9~13~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-7~9~13~18-k");
        drawNumberline(canvas, "7~9~13~18", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21505  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/2 - 9~12~17~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{2} \)?</p>
    <canvas id="canvas-3-2-9~12~17~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-2-9~12~17~18-k");
        drawNumberline(canvas, "9~12~17~18", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21487  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 3/4 - 6~10~14~15 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{3}{4} \)?</p>
    <canvas id="canvas-3-4-6~10~14~15-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-3-4-6~10~14~15-k");
        drawNumberline(canvas, "6~10~14~15", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21477  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 4/3 - 5~7~8~9 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{4}{3} \)?</p>
    <canvas id="canvas-4-3-5~7~8~9-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-4-3-5~7~8~9-k");
        drawNumberline(canvas, "5~7~8~9", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21495  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 4/3 - 7~8~10~14 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{4}{3} \)?</p>
    <canvas id="canvas-4-3-7~8~10~14-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-4-3-7~8~10~14-k");
        drawNumberline(canvas, "7~8~10~14", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21501  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 4/3 - 8~9~10~13 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{4}{3} \)?</p>
    <canvas id="canvas-4-3-8~9~10~13-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-4-3-8~9~10~13-k");
        drawNumberline(canvas, "8~9~10~13", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21503  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 4/3 - 8~9~13~17 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{4}{3} \)?</p>
    <canvas id="canvas-4-3-8~9~13~17-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-4-3-8~9~13~17-k");
        drawNumberline(canvas, "8~9~13~17", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21433  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 0~4~8~10 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-0~4~8~10-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-0~4~8~10-k");
        drawNumberline(canvas, "0~4~8~10", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21509  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 10~12~15~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-10~12~15~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-10~12~15~18-k");
        drawNumberline(canvas, "10~12~15~18", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21511  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 10~13~17~19 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-10~13~17~19-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-10~13~17~19-k");
        drawNumberline(canvas, "10~13~17~19", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21517  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 11~15~17~22 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-11~15~17~22-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-11~15~17~22-k");
        drawNumberline(canvas, "11~15~17~22", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21441  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 1~4~6~10 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-1~4~6~10-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-1~4~6~10-k");
        drawNumberline(canvas, "1~4~6~10", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21537  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 15~20~21~23 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-15~20~21~23-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-15~20~21~23-k");
        drawNumberline(canvas, "15~20~21~23", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21541  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 15~20~22~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-15~20~22~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-15~20~22~26-k");
        drawNumberline(canvas, "15~20~22~26", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21539  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 15~20~24~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-15~20~24~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-15~20~24~26-k");
        drawNumberline(canvas, "15~20~24~26", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21439  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 1~6~10~15 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-1~6~10~15-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-1~6~10~15-k");
        drawNumberline(canvas, "1~6~10~15", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21547  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 16~18~20~23 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-16~18~20~23-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-16~18~20~23-k");
        drawNumberline(canvas, "16~18~20~23", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21469  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 5~10~11~14 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-5~10~11~14-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-5~10~11~14-k");
        drawNumberline(canvas, "5~10~11~14", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21471  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 5~10~14~15 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-5~10~14~15-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-5~10~14~15-k");
        drawNumberline(canvas, "5~10~14~15", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21499  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 8~10~14~19 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-8~10~14~19-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-8~10~14~19-k");
        drawNumberline(canvas, "8~10~14~19", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21507  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/2 - 9~10~13~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{2} \)?</p>
    <canvas id="canvas-5-2-9~10~13~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-2-9~10~13~16-k");
        drawNumberline(canvas, "9~10~13~16", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21475  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/3 - 5~10~12~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{3} \)?</p>
    <canvas id="canvas-5-3-5~10~12~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-3-5~10~12~16-k");
        drawNumberline(canvas, "5~10~12~16", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21485  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/3 - 6~10~13~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{3} \)?</p>
    <canvas id="canvas-5-3-6~10~13~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-3-6~10~13~16-k");
        drawNumberline(canvas, "6~10~13~16", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21443  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/4 - 1~4~8~10 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{4} \)?</p>
    <canvas id="canvas-5-4-1~4~8~10-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-4-1~4~8~10-k");
        drawNumberline(canvas, "1~4~8~10", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21449  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/4 - 2~4~5~10 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{4} \)?</p>
    <canvas id="canvas-5-4-2~4~5~10-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-4-2~4~5~10-k");
        drawNumberline(canvas, "2~4~5~10", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21463  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/4 - 4~5~10~12 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{4} \)?</p>
    <canvas id="canvas-5-4-4~5~10~12-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-4-4~5~10~12-k");
        drawNumberline(canvas, "4~5~10~12", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21465  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 5/4 - 4~7~9~10 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{5}{4} \)?</p>
    <canvas id="canvas-5-4-4~7~9~10-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-5-4-4~7~9~10-k");
        drawNumberline(canvas, "4~7~9~10", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21515  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 11~14~18~19 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-11~14~18~19-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-11~14~18~19-k");
        drawNumberline(canvas, "11~14~18~19", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21565  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 21~24~25~30 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-21~24~25~30-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-21~24~25~30-k");
        drawNumberline(canvas, "21~24~25~30", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21569  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 21~24~27~32 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-21~24~27~32-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-21~24~27~32-k");
        drawNumberline(canvas, "21~24~27~32", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21571  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 21~25~28~33 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-21~25~28~33-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-21~25~28~33-k");
        drawNumberline(canvas, "21~25~28~33", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21467  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 5~7~9~14 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-5~7~9~14-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-5~7~9~14-k");
        drawNumberline(canvas, "5~7~9~14", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21479  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 6~11~14~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-6~11~14~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-6~11~14~16-k");
        drawNumberline(canvas, "6~11~14~16", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21491  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/2 - 7~12~14~16 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{2} \)?</p>
    <canvas id="canvas-7-2-7~12~14~16-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-2-7~12~14~16-k");
        drawNumberline(canvas, "7~12~14~16", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21533  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/3 - 14~19~23~24 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{3} \)?</p>
    <canvas id="canvas-7-3-14~19~23~24-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-3-14~19~23~24-k");
        drawNumberline(canvas, "14~19~23~24", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21535  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/4 - 14~17~18~20 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{4} \)?</p>
    <canvas id="canvas-7-4-14~17~18~20-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-4-14~17~18~20-k");
        drawNumberline(canvas, "14~17~18~20", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21489  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/4 - 6~9~13~14 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{4} \)?</p>
    <canvas id="canvas-7-4-6~9~13~14-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-4-6~9~13~14-k");
        drawNumberline(canvas, "6~9~13~14", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21497  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 7/4 - 7~12~14~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{7}{4} \)?</p>
    <canvas id="canvas-7-4-7~12~14~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-7-4-7~12~14~18-k");
        drawNumberline(canvas, "7~12~14~18", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21531  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 8/3 - 14~16~17~20 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{8}{3} \)?</p>
    <canvas id="canvas-8-3-14~16~17~20-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-8-3-14~16~17~20-k");
        drawNumberline(canvas, "14~16~17~20", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21551  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 8/3 - 16~18~19~22 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{8}{3} \)?</p>
    <canvas id="canvas-8-3-16~18~19~22-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-8-3-16~18~19~22-k");
        drawNumberline(canvas, "16~18~19~22", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21549  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 8/3 - 16~18~22~27 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{8}{3} \)?</p>
    <canvas id="canvas-8-3-16~18~22~27-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-8-3-16~18~22~27-k");
        drawNumberline(canvas, "16~18~22~27", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21553  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 8/3 - 16~19~20~24 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{8}{3} \)?</p>
    <canvas id="canvas-8-3-16~19~20~24-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-8-3-16~19~20~24-k");
        drawNumberline(canvas, "16~19~20~24", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21519  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/2 - 12~14~18~20 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{2} \)?</p>
    <canvas id="canvas-9-2-12~14~18~20-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-2-12~14~18~20-k");
        drawNumberline(canvas, "12~14~18~20", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~%100%C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21557  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/2 - 18~19~22~26 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{2} \)?</p>
    <canvas id="canvas-9-2-18~19~22~26-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-2-18~19~22~26-k");
        drawNumberline(canvas, "18~19~22~26", 4);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21583  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/2 - 23~27~31~35 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{2} \)?</p>
    <canvas id="canvas-9-2-23~27~31~35-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-2-23~27~31~35-k");
        drawNumberline(canvas, "23~27~31~35", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21593  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/2 - 27~31~32~33 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{2} \)?</p>
    <canvas id="canvas-9-2-27~31~32~33-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-2-27~31~32~33-k");
        drawNumberline(canvas, "27~31~32~33", 6);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~%100%A~B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21513  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/4 - 10~14~17~18 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{4} \)?</p>
    <canvas id="canvas-9-4-10~14~17~18-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-4-10~14~17~18-k");
        drawNumberline(canvas, "10~14~17~18", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~B~C~%100%D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

<!-- question: 21545  -->
  <question type="cloze">
    <name>
      <text>Welche Markierung gehört zu 9/4 - 15~18~23~24 (gekürzt)</text>
    </name>
    <questiontext format="html">
      <text><![CDATA[<p>Welche Markierung gehört zu \( \frac{9}{4} \)?</p>
    <canvas id="canvas-9-4-15~18~23~24-k" style="background-color:#FFF" width="800" height="200">
        </canvas>
    
    <script>
        var canvas = document.getElementById("canvas-9-4-15~18~23~24-k");
        drawNumberline(canvas, "15~18~23~24", 8);
    
    
        //Zeichne einen Zahlenstrahl
        function drawNumberline(canvas, num, denom, minNmb = NaN, maxNmb = NaN, extraLinesLeft = 2, extraLinesRight = 2) {
            //check parameters
            minNmb = parseInt(minNmb);
            maxNmb = parseInt(maxNmb);
            nums = num.split("~");
            numsint = nums.map(a => parseInt(a, 10));
            console.log("nums: ", nums, "numsint: ", numsint);
            num = parseInt(nums[0]);
            denom = parseInt(denom);
            if (isNaN(minNmb) || minNmb >= num / denom) { // Mimimum am Zahlenstrahl berechnen
                minNmb = Math.floor(Math.min(...numsint) / denom);
            }
            if (isNaN(maxNmb) || maxNmb <= num / denom) { // Maximum am Zahlenstrahl berechnen
                maxNmb = Math.ceil(Math.max(...numsint) / denom);
            }
            if (isNaN(extraLinesLeft) || extraLinesLeft < 0) {
                extraLinesLeft = 2;
            }
            if (isNaN(extraLinesRight) || extraLinesRight < 0) {
                extraLinesRight = 2;
            }
            //Defining and Calculating needed values
            var border = 2; //Rand am Canvas  
            var ctx = canvas.getContext("2d");
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height); //delete everything
            var w = canvas.width - 2 * border;
            var h = canvas.height - 2 * border;
            var numOfSections = ((maxNmb - minNmb) * denom + extraLinesLeft + extraLinesRight);
            var lengthPerSection = Math.floor(w / (numOfSections + 1));
            var lineWidth = 2; //Line Thickness - what makes sense?
            var fontSize = Math.floor(h / 6);
    
            // we are drawing in the middle of the canvas
            ctx.lineWidth = lineWidth;
    
            //draw the number line - base line
            ctx.strokeStyle = 'black';
            ctx.beginPath();
            ctx.moveTo(border, h / 2);
            ctx.lineTo(border + (numOfSections + 1) * lengthPerSection, h / 2);
            ctx.stroke();
            //draw the tickmarks
            for (let l = 0; l <= numOfSections; l++) {
                if ((l - extraLinesLeft) % denom == 0) { // Thick tickmarks with text
                    ctx.lineWidth = 2 * lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, h / 3);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 2 * h / 3);
                    ctx.stroke();
                    //Add the text
                    ctx.font = "" + fontSize + "px Arial";
                    ctx.fillStyle = "black";
                    ctx.textAlign = "center";
                    ctx.fillText("" + (minNmb + (l - extraLinesLeft) / denom), border + (l + 0.5) * lengthPerSection, h / 4);
                } else {
                    ctx.lineWidth = lineWidth;
                    ctx.beginPath();
                    ctx.moveTo(border + (l + 0.5) * lengthPerSection, 4 * h / 9);
                    ctx.lineTo(border + (l + 0.5) * lengthPerSection, 5 * h / 9);
                    ctx.stroke();
                }
            }
            // draw the arrow - red lines for chosen numbers
            ctx.strokeStyle = 'red';
            let letternum = 65;
            for (i in nums) {
                var num = parseInt(nums[i]);
                if (!isNaN(num) && extraLinesLeft + num - minNmb * denom < numOfSections) {
                    var numSections = extraLinesLeft + num - minNmb * denom;
                    ctx.beginPath();
                    ctx.moveTo(border + (numSections + 0.5) * lengthPerSection, 2 * h / 9);
                    ctx.lineTo(border + (numSections + 0.5) * lengthPerSection, 7 * h / 9);
                    ctx.stroke();
                    //Text under red line
                    ctx.fillStyle = "red";
                    ctx.fillText(String.fromCharCode(letternum++), border + (numSections + 0.5) * lengthPerSection, 17 * h / 18);
                }
            }
        }
    </script>
    
    <p><br></p>
    <p dir="ltr" style="text-align: left;">{1:MULTICHOICE_H:~A~%100%B~C~D}<br></p>]]></text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <idnumber></idnumber>
  </question>

</quiz>