$\textsf{Solución alternativa}$

$\math{\alpha}$

#4D4D4D

$\text{Check}$

$\text{NUEVO}$

Fix position and allow selection for all text objects

Empty all input boxes

\text{This is the answer.}

$\math{\alpha=}$

Reset app

\text{Asegúrate de iniciar la\medición desde 0°.}

#006758

#B00020

#252525

#757575

#949494

#E44461

#DA2570

#E66B9E

#3A6ED6

#5991FF

#008475

#0F8538

#00a83c

#5145A8

#6557D2

#8575FF

#903D14

#BD6C43

#C75000

#E07415

\text{Asegúrate de que un lado\del ángulo coincida con el\borde del transportador.}

#eeeeee

#2E006758

#2EB00020

$\textsf{SOLUCIÓN PASO A PASO}$

Prev

Replay

Next

PrevF

ReplayF

NextF

\textsf{Introduce un número entre 0 y 180.}

\textsf{\bold{Solución}}\\textsf{Observa la construcción.}

onboardingStage = 1
allRandomSeeds = RandomUniform(0, 0.99, 200)
Center: (0, 0)
graphicArea = Polygon({(-4.5, -3.7), (4.5, -3.7), (4.5, 3.7), (-4.5, 3.7)})
countQuestion = 0
PointsRayMovable = Sequence(((2 * cos(ii)), (2 * sin(ii))), ii, 0°, 360°, 1°)
EndPointRay2 = Point(PointsRayMovable)
numRandoms: 2
randIndex: (Mod[countQuestion, floor(Length[allRandomSeeds] / numRandoms)] * numRandoms) + 1
currentRandomSeeds = Take(allRandomSeeds, randIndex, randIndex + numRandoms - 1)
PointsRayFixed = Sequence(((2 * cos(ii)), (2 * sin(ii))), ii, 5°, 360°, 2°)
randomNum2: 1 + floor((currentRandomSeeds(1) * (Length[PointsRayFixed] - 1)))
EndPointRay1 = Element(PointsRayFixed, randomNum2)
Ray1 = IntersectPath(Ray[Center, EndPointRay1], graphicArea)
reg1 = If(Defined[Slope[Ray1]], y ≥ (Slope[Ray1] * x), x ≥ 0)
rotAngleRightProt = Min(Angle[Vector[EndPointRay1], Vector[(1, 0)]], Angle[Vector[(1, 0)], Vector[EndPointRay1]])
RotateRight: x(EndPointRay1) ≥ 0 ∨ rotAngleRightProt ≟ 0
angles = Sequence(10, 175, 1)
randomNum1: 1 + floor((currentRandomSeeds(1) * (Length[angles] - 1)))
randomAngle = Element(angles, randomNum1)
r = 3.8 (slider from 3 to 10)
IniCorrectArc = Dilate(EndPointRay1, r / 2)
EndCorrectArc = Rotate(IniCorrectArc, (randomAngle° * If[RotateRight, 1, -1]))
standardSol: IsInRegion[EndPointRay2, reg1] ≟ IsInRegion[EndCorrectArc, reg1]
ProtractorCenter_{1}: (1, -3)
ProtractorCircle_{1} = Circle(ProtractorCenter_{1}, r)
ProtractorLeft_{1} = Point(ProtractorCircle_{1})
ProtractorLeftDyn_{1} = DynamicCoordinates(ProtractorLeft_{1}, x(ProtractorLeft_{1}), y(ProtractorLeft_{1}))
ProtractorRight_{1} = Point(ProtractorCircle_{1})
ProtractorRightDyn_{1} = DynamicCoordinates(ProtractorRight_{1}, x(ProtractorRight_{1}), y(ProtractorRight_{1}))
c = Arc(ProtractorCircle_{1}, ProtractorRightDyn_{1}, ProtractorLeftDyn_{1})
D, E = Intersect(c, LineBisector[ProtractorRightDyn_{1}, ProtractorLeftDyn_{1}])
quadrantProtractorCenter = If(x(D) ≥ 0 ∧ y(D) ≥ 0, If[standardSol, 1, 3], x(D) < 0 ∧ y(D) ≥ 0, If[standardSol, 2, 4], x(D) < 0 ∧ y(D) < 0, If[standardSol, 3, 1], If[standardSol, 4, 2])
altSol = false
IniIncorrectArc = Dilate(Dilate[EndPointRay1, r / 2], 1.02)
u: Vector[EndPointRay1] + Vector[EndPointRay2]
v: (1.5 * If[abs(u) ≠ 0, Vector[u / abs(u)], Vector[Rotate[Vector[EndPointRay1], -90°] / 2]])
inputSaved: {NaN, NaN}
angleToShow = Angle(Vector[EndPointRay1], Vector[EndPointRay2])
onboarding = true
input1 = NaN
showwarning: (¬(0 ≤ input1 ≤ 180)) ∧ Defined[input1]
inputCurrent: {EndPointRay2}
input2: NaN
onboardingText: "\text{Arrastra para " + (LaTeX[If[onboardingStage ≟ 1, "mover el transportador", "construir el ángulo"]]) + "}"
B = (5.000341064524864, 5.69392166828734)
validate = false
showanswer = false
showsolution = false
tries = 0
countCorrect = 0
showhint = false
InputBox1 = Textfield(input1)
correct2: input2 ≟ randomNum2
correct1: abs(angleToShow - randomAngle°) ≤ 1°
correct: correct1
showbuttons = true
typicalError1: 0
typicalError2: 0
showhinttypicalerror = false
enableBtnValidate: inputCurrent ≠ inputSaved ∧ inputCurrent ≟ RemoveUndefined[inputCurrent] ∧ (¬onboarding) ∧ (¬showwarning)
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16
pixelsTop: 24
layoutY: 130
enableInput: tries < 3 ∧ (¬(validate ∧ correct))
layoutX: 16
layoutAppSize = Corner(5)
pulsingSpeed: 8
pulsing = 0.8 (slider from 0 to 1, step 0.1)
haloPixels: (pulsing * 7)
onboardingDisplayText: "" + (LaTeX[onboardingText]) + ""
A = (4.591072725036432, 5.892161020227049)
C = (4.917208433066277, 6.084005554362252)
pulsingObject = sectorPixels(A, B, C, haloPixels + 40, Corner[1], Corner[3], Corner[5])
displayAngle = sectorPixels(A, B, C, 40, Corner[1], Corner[3], Corner[5])
layoutOnboarding = PointToPixels(Corner[onboardingDisplayText, 2], Corner[1], Corner[3], Corner[5])
onboardingX: 356 - 16
onboardingY: (y(Corner[4] - If[onboardingStage ≟ 1, ProtractorLeftDyn_{1}, EndPointRay2]) * 500 / y(Corner[4] - Corner[1])) + 16
onboardingCase: 2
OnboardingTextOffset = onboardingTextOffset(Corner[onboardingText, 1], Corner[onboardingText, 3], onboardingCase, Corner[1], Corner[3], Corner[5])
Cor1 = (-9.87351, -4.809300000000002)
Cor3 = (5.008990000000001, 4.496179999999998)
Ray2 = IntersectPath(Ray[Center, EndPointRay2], graphicArea)
LabelPosAngleToShow = Translate((0, 0), v)
step = 0
anim = 0 (slider from 0 to 1, step 0.01)
animSpeed: 5
wait = 1 (slider from 0 to 1)
LegendPositions: {(0.5, 1), (-0.5, 1), (-0.5, -0.5), (0.5, -0.5), (-4, -4)}
quadrantLegend = If(quadrantProtractorCenter ≟ 4, If[altSol, 4, 2], quadrantProtractorCenter ≟ 2, If[altSol, 2, 4], quadrantProtractorCenter ≟ 3, If[altSol, 3, 1], If[altSol, 1, 3])
Legend2 = Element(LegendPositions, quadrantLegend)
Legend1: Legend2 + ((1.5, 0) * If[2 ≤ quadrantLegend ≤ 3, -1, 1])
Legend3 = Translate(Legend1, (0, -0.5))
Legend4 = Translate(Legend2, (0, -0.5))
segmentLegendCorrect = Segment(Legend2, Legend1)
segmentLegendIncorrect = Segment(Legend4, Legend3)
CorrectArc1 = Sector(x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), IniCorrectArc, EndCorrectArc)
CorrectArc2 = Sector(x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), EndCorrectArc, IniCorrectArc)
EndIncorrectArc = Dilate(Dilate[EndPointRay2, r / 2], 1.02)
IncorrectArc1 = Arc(x^(2) + y^(2) = Distance[Center, IniIncorrectArc]^(2), IniIncorrectArc, EndIncorrectArc)
IncorrectArc2 = Arc(x^(2) + y^(2) = Distance[Center, IniIncorrectArc]^(2), EndIncorrectArc, IniIncorrectArc)
segmentCorrect = Segment(Center, EndIncorrectArc)
labelPointIncorrect = Text((input1 * "°"), (x(Dilate[EndIncorrectArc, 1.1]), Max[y(Dilate[EndIncorrectArc, 1.1]), -3.55]), true, true, 0, 0)
animCurve = 1 (slider from 0 to 1, step 0.01)
IniCorrectArc' = Rotate(IniCorrectArc, ((anim * randomAngle°) * If[RotateRight, 1, -1]))
arcAnim1 = Arc(x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), IniCorrectArc, IniCorrectArc')
arcAnim2 = Arc(x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), IniCorrectArc', IniCorrectArc)
onboardingwidth: (x(Corner[onboardingText, 2] - Corner[onboardingText, 1]) / x(Corner[2] - Corner[1]) * 800)
pulsingObjectLeft = circlePixels(ProtractorLeftDyn_{1}, 5 + (7 * pulsing), Corner[1], Corner[3], Corner[5])
pulsingObjectRight = circlePixels(ProtractorRightDyn_{1}, 5 + (7 * pulsing), Corner[1], Corner[3], Corner[5])
pulsingObjectCenter = circlePixels(ProtractorCenter_{1}, 5 + (7 * pulsing), Corner[1], Corner[3], Corner[5])
labelAngleToShow = Text("\alpha", LabelPosAngleToShow, true, true, 0, 0)
IniIncorrectArc' = Mirror(IniIncorrectArc, Line[(0, 0), EndPointRay1])
EndIncorrectArc' = Mirror(EndIncorrectArc, Line[(0, 0), EndPointRay1])
EndIncorrectArc'_{1} = Mirror(EndIncorrectArc, Line[(0, 0), EndPointRay1])
IniIncorrectArc'_{1} = Mirror(IniIncorrectArc, Line[(0, 0), EndPointRay1])
IniCorrectArc'_{1} = Mirror(IniCorrectArc, Line[(0, 0), EndPointRay1])
EndCorrectArc' = Mirror(EndCorrectArc, Line[(0, 0), EndPointRay1])
EndCorrectArc'_{1} = Mirror(EndCorrectArc, Line[(0, 0), EndPointRay1])
IniCorrectArc'_{2} = Mirror(IniCorrectArc, Line[(0, 0), EndPointRay1])
rotAngleLeftProt = Min(Angle[Vector[EndPointRay1], Vector[(-1, 0)]], Angle[Vector[(-1, 0)], Vector[EndPointRay1]])
isTypicalError: abs(180° - randomAngle° - angleToShow) ≤ 2°
pic1' = Rotate(pic1, 180°)
segAnim = Segment(Center, IniCorrectArc')
show1: CorrectArc1 ≥ CorrectArc2 ∧ If[standardSol, ¬altSol, altSol] ∨ (¬(CorrectArc1 ≥ CorrectArc2)) ∧ If[standardSol, ¬altSol, altSol]
CorrectArc1' = Sector(Mirror[x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), Line[(0, 0), EndPointRay1]], IniCorrectArc'_{1}, EndCorrectArc')
CorrectArc2' = Sector(Mirror[x^(2) + y^(2) = Distance[Center, IniCorrectArc]^(2), Line[(0, 0), EndPointRay1]], EndCorrectArc'_{1}, IniCorrectArc'_{2})
EndPointRay2Ini = (-1.7492394142788077, -0.9696192404926451)
pulsingObjectAngle = circlePixels(EndPointRay2, 9 + (7 * pulsing), Corner[1], Corner[3], Corner[5])
labelBtnValidate: "\text{CHEQUEAR (" + (LaTeX[3 - tries]) + ")}"
legendCorrect = Text("\textsf{ Solución correcta\\}", Legend1, true, true, If[2 ≤ quadrantLegend ≤ 3, -1, 1], 0)
legendIncorrect = Text("\textsf{ Tu construcción\\}", Legend3, true, true, If[2 ≤ quadrantLegend ≤ 3, -1, 1], 0)
text2: "\textsf{\textcolor{" + (LaTeX[colorTealSuccess]) + "}\bold{Posible solución}\\Paso " + (LaTeX[step]) + ":\\" + (LaTeX[If[step ≟ 1, "Ubica el transportador para que\\su centro coincida con el\\vértice del ángulo.", step ≟ 2, "Gira el transportador para que \\el lado inicial del ángulo \\coincida con 0°.", step ≟ 3, "Usa la escala del transportador\\para hallar la medida del ángulo."]]) + "}"
textCountCorrect: "\text{Correctos: " + (LaTeX[countCorrect]) + " }"
textHint: "\text{\color{" + (LaTeX[colorOrange]) + "}\bold{Pista}\\" + (LaTeX[If[showhinttypicalerror, helpTextHintTypicalError]]) + "" + (LaTeX[If[showhint ∧ showhinttypicalerror, "\\"]]) + "" + (LaTeX[If[showhint, helpTextHint]]) + "}"
textFeedback: "" + (LaTeX[If[correct, "$\text{✓ Correcto}$", "$\text{✕ " + (If[tries < 3, "Reinténtalo", "Quizás la próxima vez"]) + "}$"]]) + ""
textQuestion: "\text{Construye un ángulo de " + (LaTeX[randomAngle]) + "°.} "

Tool: PointToPixels
PointToPixels(InputPoint,Corner1,Corner3,Corner5)
Input: InputPoint, Corner1, Corner3, Corner5
Output: OutputPixels

xLeft: x(Corner1)
xRight: x(Corner3)
yTop: y(Corner3)
yBottom: y(Corner1)
yPixels: (y(Corner5) * (yTop - y(InputPoint)) / (yTop - yBottom))
xPixels: (x(Corner5) * (x(InputPoint) - xLeft) / (xRight - xLeft))
OutputPixels: (xPixels, yPixels)

Tool: sectorPixels
sectorPixels(Midpoint,B,C,pixelRadius,Corner1,Corner3,Corner5
Input: A, B, C, pixelRadius, Corner1, Corner3, Corner5
Output: newSector

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
BPrime: A + (pointRadius * UnitVector[B - A])
newSector = CircleSector(A, BPrime, C)

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: circlePixels
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
newCircle = Circle(A, pointRadius)