#4D4D4D

$\text{Check}$

$\text{NEW PROBLEM}$

Fix position and allow selection for all text objects

Empty all input boxes

\phantom{\text{This is the answer.}}

Reset app

\text{This is the error specific hint}

#006758

#B00020

#252525

#757575

#949494

#E44461

#DA2570

#E66B9E

#3A6ED6

#5991FF

#008475

#0F8538

#00a83c

#5145A8

#6557D2

#8575FF

#903D14

#BD6C43

#C75000

#E07415

\text{Try again.}

#eeeeee

#2E006758

#2EB00020

$\text{\bold{SORT NUMBERS}}$

\text{Draw a box-and-whisker plot for the data set given below.}

\text{Use the new information provided to draw the box-and-whisker plot.}

Q2

Q1

Q3

min

max

\text{\bold{Solution}}

\text{Drag to Start}

allRandomSeeds = RandomUniform(0, 0.99, 200)
numRandoms: 16
countQuestion = 0
randIndex: (Mod[countQuestion, floor(Length[allRandomSeeds] / numRandoms)] * numRandoms) + 1
currentRandomSeeds = Take(allRandomSeeds, randIndex, randIndex + numRandoms - 1)
lengthOfRandomLists: 100
currentDataSetSize: 10 + floor((currentRandomSeeds(16) * 5))
moverPart2 = 0 (slider from 0 to 1, step 0.01)
pointSpacing: 45
textAdjuster: (-13, 0)
showq3Segmentcaption = false
showq2Segmentcaption = false
showq1Segmentcaption = false
showmaxSegmentcaption = false
showminSegmentcaption = false
numberLineLength: 600
numberLineXstart: 100
upperLimit: 40
reverseMapper(x) = ((x - numberLineXstart) * upperLimit / numberLineLength)
numberLineYhidden: 280
hiddenNumberLine = Flatten(Join[{Sequence[(16 + i, numberLineYhidden), i, 0, ((numberLineXstart - 16) * 4 / 5), (numberLineXstart - 16) / 5], Sequence[Point[{numberLineXstart + (i * numberLineLength / upperLimit / 2), numberLineYhidden}], i, 0, (upperLimit * 2)]}])
min = Point(hiddenNumberLine)
q1 = Point(hiddenNumberLine)
q2 = Point(hiddenNumberLine)
q3 = Point(hiddenNumberLine)
max = Point(hiddenNumberLine)
activeCaptionCopy: "\text{" + (LaTeX[If[showminSegmentcaption ∧ x(min) ≥ numberLineXstart, "" + (reverseMapper(x(min))), ""]]) + "" + (LaTeX[If[showq1Segmentcaption ∧ x(q1) ≥ numberLineXstart, "" + (reverseMapper(x(q1))), ""]]) + "" + (LaTeX[If[showq2Segmentcaption ∧ x(q2) ≥ numberLineXstart, "" + (reverseMapper(x(q2))), ""]]) + "" + (LaTeX[If[showq3Segmentcaption ∧ x(q3) ≥ numberLineXstart, "" + (reverseMapper(x(q3))), ""]]) + "" + (LaTeX[If[showmaxSegmentcaption ∧ x(max) ≥ numberLineXstart, "" + (reverseMapper(x(max))), ""]]) + "}"
activeCaptionSize: Corner[activeCaptionCopy, 3] - Corner[activeCaptionCopy, 1]
sortedFiveNumberSummary = Sort({x(min), x(q1), x(q2), x(q3), x(max)})
numberLineY: 260
currentDataSet = Zip(1 + floor((A * 40)), A, Take[currentRandomSeeds, 1, currentDataSetSize])
mapper(x) = (x * numberLineLength / upperLimit) + numberLineXstart
mappedDataSet = Zip(mapper(AAA), AAA, currentDataSet)
correctAnswer: {Min[mappedDataSet], Q1[mappedDataSet], Median[mappedDataSet], Q3[mappedDataSet], Max[mappedDataSet]}
inputCurrent: {min, q1, q2, q3, max}
boxHeight: 25
numberLine = Sequence(Point[{numberLineXstart + (i * numberLineLength / upperLimit / 2), numberLineY}], i, 0, (upperLimit * 2))
segmentLength: 10
quartileGap: 35
mover = 0 (slider from 0 to maxMover, step 0.01)
textStartingPoints = Sequence((400, 420) + textAdjuster + (i * (pointSpacing, 0)), i, ((-(currentDataSetSize - 1))) / 2, (currentDataSetSize - 1) / 2)
textEndingPoints = Sequence((400, 380 + (40 * moverPart2)) + textAdjuster + (i * (pointSpacing, 0)), i, ((-(currentDataSetSize - 1))) / 2, (currentDataSetSize - 1) / 2)
movers = Sequence(Min[1, Max[(mover - i + 1) / 3, 0]], i, 1, currentDataSetSize)
movingPoints = Sequence((Element[Sort[textStartingPoints, currentDataSet], i] * (1 - Element[movers, i])) + (Element[textEndingPoints, i] * Element[movers, i]), i, 1, currentDataSetSize)
movingText = Sequence(Text[Element[Sort[currentDataSet], i], Element[movingPoints, i]], i, 1, currentDataSetSize)
firstText = Element(movingText, 1)
lowerStart = Corner(firstText, 1)
leftText = Element(movingText, floor(currentDataSetSize / 2))
lowerEnd = Corner(leftText, 2)
A = (3.4347091871177713, 5.572495645015256)
showanswer = false
showsolution = false
tries = 0
countCorrect = 0
showhint1 = false
correct1: Sort[{x(inputCurrent(1)), x(inputCurrent(2)), x(inputCurrent(3)), x(inputCurrent(4)), x(inputCurrent(5))}] ≟ correctAnswer
correct: correct1
validate = false
showbuttons = true
typicalError1: 0
typicalError2: 0
showhinttypicalerror = false
textCountCorrect: "\text{Number correct: " + (LaTeX[countCorrect]) + " }"
labelBtnValidate: "\text{CHECK (" + (LaTeX[3 - tries]) + ")}"
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16
pixelsTop: 24
borderBox = Polygon(Zip[PixelsToPoint[Corner[1], Corner[3], Corner[5], A], A, {(pixelsLeft, pixelsTop), (pixelsLeft, y(Corner[5]) - pixelsBottom), Corner[5] - (pixelsRight, pixelsBottom), (x(Corner[5]) - pixelsRight, pixelsTop)}])
layoutY: 282
enableInput: tries < 3 ∧ (¬(validate ∧ correct))
layoutX: 16
layoutAppSize = Corner(5)
textFeedback: "" + (LaTeX[If[correct, "$\text{✓ Correct}$", "$\text{✕ " + (If[tries < 3, "Try again", "Maybe next time"]) + "}$"]]) + ""
B = (4.1638207264560645, 6.136241785204535)
StartA = (3.4347091871177713, 5.572495645015256)
StartB = (4.1638207264560645, 6.136241785204535)
count: 0
onboardingCase: 1
layoutCase: 1
layoutHintSolnY: layoutY + Element[{56, 88}, layoutCase]
layoutHintSolnX = Element({If[layoutX ≟ 16, layoutX - 5, 11], layoutX - 5}, layoutCase)
layoutFeedbackX: layoutX + Element[{If[correct ∨ tries ≟ 3, -5, 126], -5}, layoutCase]
layoutFeedbackY: layoutY + Element[{If[correct, 6, 1], If[correct, 6, If[tries ≟ 3, 1, 51]]}, layoutCase]
xMin: 0
xMax: 800
yMin: 0
yMax: 500
staticText = Sequence(Text[Element[currentDataSet, i], Element[textStartingPoints, i]], i, 1, currentDataSetSize)
m = Median(currentDataSet)
medianArrowLength: -15
middleText = Element(movingText, currentDataSetSize / 2)
rightText = Element(movingText, ceil(currentDataSetSize / 2 + 1))
lastText = Element(movingText, currentDataSetSize)
upperEnd = Corner(lastText, 2)
upperStart = Corner(rightText, 1)
method = If(Mod[currentDataSetSize, 4] ≤ 1, "average", "exact")
q1Left = Element(movingText, floor(currentDataSetSize / 4))
q1Right = Element(movingText, floor(currentDataSetSize / 4) + 1)
q1Middle = Element(movingText, floor(currentDataSetSize / 4) + 1)
q3Left = Element(movingText, ceil((3 * currentDataSetSize / 4)))
q3Right = Element(movingText, ceil((3 * currentDataSetSize / 4)) + 1)
q3Middle = Element(movingText, floor((3 * currentDataSetSize / 4)) + 1)
showhint2 = false
moverSpeed: 2
maxMover: currentDataSetSize + 2
q1Location = If(method ≟ "average", Corner[q1Left, 2] / 2 + Corner[q1Right, 1] / 2, Corner[q1Middle, 2] / 2 + Corner[q1Middle, 1] / 2)
q3Location = If(method ≟ "average", Corner[q3Left, 2] / 2 + Corner[q3Right, 1] / 2, Corner[q3Middle, 2] / 2 + Corner[q3Middle, 1] / 2)
textHint: "\text{\color{" + (LaTeX[colorOrange]) + "}\bold{Hint}\\" + (LaTeX[If[showhint1, helpTextHint, ""]]) + "" + (LaTeX[If[showhint2, helpTextHint2, ""]]) + "}"
showq123 = false
median = If(currentDataSetSize / 2 ≟ floor(currentDataSetSize / 2), Segment[Corner[leftText, 2] / 2 + Corner[rightText, 1] / 2 + (0, medianArrowLength), Corner[leftText, 2] / 2 + Corner[rightText, 1] / 2], Segment[Corner[middleText, 2] / 2 + Corner[middleText, 1] / 2 + (0, medianArrowLength), Corner[middleText, 2] / 2 + Corner[middleText, 1] / 2])
q1Arrow = Segment(q1Location + (0, medianArrowLength), q1Location)
q3Arrow = Segment(q3Location + (0, medianArrowLength), q3Location)
captionAdjuster: (((-x(activeCaptionSize))) / 2 + 3, 78)
activeCaptionLocation = If(showminSegmentcaption, min + captionAdjuster, If[showq1Segmentcaption, q1 + captionAdjuster, If[showq2Segmentcaption, q2 + captionAdjuster, If[showq3Segmentcaption, q3 + captionAdjuster, If[showmaxSegmentcaption, max + captionAdjuster, (0, 0)]]]])
minLocation: Corner[firstText, 2] / 2 + Corner[firstText, 1] / 2
maxLocation: Corner[lastText, 2] / 2 + Corner[lastText, 1] / 2
minArrow = Segment(minLocation + (0, medianArrowLength), minLocation)
maxArrow = Segment(maxLocation + (0, medianArrowLength), maxLocation)
userBoxplot = BoxPlot(numberLineYhidden + boxHeight, boxHeight, sortedFiveNumberSummary(1), sortedFiveNumberSummary(2), sortedFiveNumberSummary(3), sortedFiveNumberSummary(4), sortedFiveNumberSummary(5))
numberLineSegment = Segment((numberLineXstart, numberLineY), (numberLineXstart + numberLineLength, numberLineY))
minorTickFrequency: 1
minorTickSize: 6
majorTickSize: 14
majorTickFrequency: 5
majorTicks = Sequence(Segment[Element[numberLine, i] + (0, majorTickSize / 2), Element[numberLine, i] + (0, ((-majorTickSize)) / 2)], i, 1, Length[numberLine], (majorTickFrequency * 2))
majorTickTextAdjuster: (-5, -25)
majorTickTexts = Sequence(Text[reverseMapper(x(Element[numberLine, i])), Element[numberLine, i] + If[reverseMapper(x(Element[numberLine, i])) < 10, majorTickTextAdjuster, If[reverseMapper(x(Element[numberLine, i])) < 100, ((2 * x(majorTickTextAdjuster)), y(majorTickTextAdjuster)), ((3 * x(majorTickTextAdjuster)), y(majorTickTextAdjuster))]]], i, 1, Length[numberLine], (2 * majorTickFrequency))
minorTicks = Sequence(Segment[Element[numberLine, i] + (0, minorTickSize / 2), Element[numberLine, i] + (0, ((-minorTickSize)) / 2)], i, 1, Length[numberLine], (minorTickFrequency * 2))
activeCaption: "\text{" + (LaTeX[If[showminSegmentcaption ∧ x(min) ≥ numberLineXstart, "" + (reverseMapper(x(min))), ""]]) + "" + (LaTeX[If[showq1Segmentcaption ∧ x(q1) ≥ numberLineXstart, "" + (reverseMapper(x(q1))), ""]]) + "" + (LaTeX[If[showq2Segmentcaption ∧ x(q2) ≥ numberLineXstart, "" + (reverseMapper(x(q2))), ""]]) + "" + (LaTeX[If[showq3Segmentcaption ∧ x(q3) ≥ numberLineXstart, "" + (reverseMapper(x(q3))), ""]]) + "" + (LaTeX[If[showmaxSegmentcaption ∧ x(max) ≥ numberLineXstart, "" + (reverseMapper(x(max))), ""]]) + "}"
inputSaved: {(625, 280), (190, 280), (407.5, 280), (310, 280), (685, 280)}
enableBtnValidate: inputCurrent ≠ inputSaved ∧ sortedFiveNumberSummary(1) ≥ numberLineXstart
pulsing = 0.7 (slider from 0 to 1, step 0.1)
pulsingSpeed: 8
showPulsing = true
solutionOffset: 160
solutionNumberLineSegment = Translate(numberLineSegment, (0, (-solutionOffset)))
solutionMajorTicks = Translate(majorTicks, (0, (-solutionOffset)))
solutionMinorTicks = Translate(minorTicks, (0, (-solutionOffset)))
solutionMajorTickTexts = Sequence(Text[reverseMapper(x(Element[numberLine, i])), Element[numberLine, i] + If[reverseMapper(x(Element[numberLine, i])) < 10, Vector[majorTickTextAdjuster + (0, (-solutionOffset))], If[reverseMapper(x(Element[numberLine, i])) < 100, ((2 * x(majorTickTextAdjuster)), y(majorTickTextAdjuster) - solutionOffset), ((3 * x(majorTickTextAdjuster)), y(majorTickTextAdjuster) - solutionOffset)]]], i, 1, Length[numberLine], (2 * majorTickFrequency))
correctBoxplot = BoxPlot(numberLineYhidden + boxHeight - solutionOffset, boxHeight, mappedDataSet)
newBoxHeight: 25
minSegment = Tool6(min)
maxSegment = Tool6(max)
q1Segment = Tool6(q1)
q2Segment = Tool6(q2)
q3Segment = Tool6(q3)
puslingSegment = expandSegment(Point[maxSegment, 0], Point[maxSegment, 1], (7 * pulsing), Corner[1], Corner[3], Corner[5])
onboardingY: 207
onboardingX: x(max) + 16

Tool: PixelsToPoint
PixelsToPoint(Corner1,Corner3,Corner5,PixelCoords)
Input: Corner1, Corner3, Corner5, InputPixels
Output: OutputPoint

InputPixels: (100, 200)
xRight: x(Corner3)
xLeft: x(Corner1)
yTop: y(Corner3)
yBottom: y(Corner1)
yCoord: yTop - (y(InputPixels) / y(Corner5) * (yTop - yBottom))
xCoord: (x(InputPixels) / x(Corner5) * (xRight - xLeft)) + xLeft
OutputPoint: (xCoord, yCoord)

Tool: expandSegment
expandSegment(A,B,pixelGap,Corner1,Corner3,Corner5)
Input: A, B, pixelGap, Corner1, Corner3, Corner5
Output: newPoly

distanceX: (pixelGap / x(Corner5) * (x(Corner3) - x(Corner1)))
distanceY: (pixelGap / y(Corner5) * (y(Corner3) - y(Corner1)))
pointGap: distanceX
xyScale: distanceY / distanceX
A: (0, 0)
vecAB: B - A
pVec: (20 * UnitVector[(((-y(vecAB))) / xyScale, (x(vecAB) * xyScale))])
pVecAngle = Angle(xAxis, Line[(0, 0), pVec])
realAngle = If(pVecAngle ≟ pi / 2 ∨ pVecAngle ≟ (3 * pi / 2), pVecAngle, atand(tan(pVecAngle) / xyScale))
curveFunction = CurveCartesian((pointGap * cos(u)), ((pointGap * xyScale) * sin(u)), u, 0, (2 * pi))
K: curveFunction(realAngle)
vSpace = Vector(K)
allPoints: {A + vSpace, A - vSpace, B - vSpace, B + vSpace}
newPoly = Polygon(allPoints)

Tool: onboardingTextOffset
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: Tool4
Input: F, boxHeight
Output: g

boxHeight: 50
E: F + (0, boxHeight)
g = Segment(E, F)

Tool: dragableSegment
dragableSegment[ <Point>, <Number> ]
Input: E, newBoxHeight
Output: j_1

newBoxHeight: 20
j_1 = Segment(E, E + (0, newBoxHeight))

Tool: Tool6
Input: G
Output: s_1

s_1 = Segment(G, G + (0, 50))