asdf

$\text{Überprüfen}$

$\text{Neuer Versuch}$

$\text{\bold{Neue Aufgabe}}$

No selection allowed for all input boxes

Selection allowed for all input boxes

Fix position and allow selection for all text objects

Empty all input boxes

\text{Text for just the correct answer.}

\underline\text{Helper scripts for template}

\underline\text{Helper scripts for authors}

$\textsf{input1=}$

$\textsf{input2=}$

\textsf\colorbox{ebe7f8}{Du hast die Koordinaten\
vertauscht.

Auflösung X

Auflösung Y

DevReset

$\textsf{Nochmal!}$

EmptyInputBoxesReal

SelectionAllowed

\textsf{0}

\textsf{1. Achse}

\textsf{2. Achse}

\textsf{A}

\textsf{B}

\textsf{C}

\textsf{D}

\textsf\colorbox{ebe7f8}{Achte auf das Vorzeichen.

\textsf{\colorbox{ebe7f8}{Verschiebe den orangen\
Eckpunkt
 an die richtige\
Stelle.}}

\textsf{\textcolor{50c0ce}{\bold{Zieh mich!}}}

\textsf{\infty}

listpos = 1
PunkteFeld = Sequence(Sequence[(i, k), k, 0, 8], i, 0, 8)
QE4: (0, 8)
HelperX = Shuffle(Sequence[1, 7])
UrsprungXListe = Join({{0}, HelperX})
ux: UrsprungXListe(listpos)
HelperY = Shuffle(Sequence[1, 7])
UrsprungYListe = Join({{0}, HelperY})
uy: UrsprungYListe(listpos)
Ursprung: (ux, uy)
AYList = Shuffle(Sequence[1, 7])
ay: AYList(1)
distanceAposY: 8 - ay
distanceAnegY: ay
AXList = Shuffle(Sequence[1, 7])
ax: AXList(1)
A: (ax, ay)
aCoords = Vector(Ursprung, A)
i = Line(A, A + (-1, 0))
h = Line(A, A + (0, 1))
distanceAnegX: ax
distanceAposX: 8 - ax
maxf = Max({distanceAnegX, distanceAposX, distanceAnegY, distanceAposY})
fList = Shuffle(Sequence[3, maxf, 1])
fwert: fList(1)
erando = Random(1, fwert - 1)
c = Circle(A, fwert)
CSucheNegY, CSuchePosY = Intersect(c, h)
CSuchePosX, CSucheNegX = Intersect(c, i)
QE3: (8, 8)
QE2: (8, 0)
QE1: (0, 0)
coordsystem, qe1, qe2, qe3, qe4 = Polygon(QE1, QE2, QE3, QE4)
CyOptionen = RemoveUndefined({If[IsInRegion[CSuchePosY, coordsystem], y(CSuchePosY)], If[IsInRegion[CSuchePosX, coordsystem], y(CSuchePosX)], If[IsInRegion[CSucheNegX, coordsystem], y(CSucheNegX)], If[IsInRegion[CSucheNegY, coordsystem], y(CSucheNegY)]})
CxOptionen = RemoveUndefined({If[IsInRegion[CSuchePosY, coordsystem], x(CSuchePosY)], If[IsInRegion[CSuchePosX, coordsystem], x(CSuchePosX)], If[IsInRegion[CSucheNegX, coordsystem], x(CSucheNegX)], If[IsInRegion[CSucheNegY, coordsystem], x(CSucheNegY)]})
Crando = Random(1, Length[CxOptionen])
C: (CxOptionen(Crando), CyOptionen(Crando))
cCoords = Vector(Ursprung, C)
MittelpunktDeltoid: A + (Vector[A, C] * erando / fwert)
j = Segment(A, C)
k = OrthogonalLine(MittelpunktDeltoid, j)
InputPunkt = Point(PunkteFeld)
QuadratKanten: {Segment[QE1, QE2], Segment[QE2, QE3], Segment[QE4, QE3], Segment[QE4, QE1]}
AbstaendeMittelpunkt: {Distance[MittelpunktDeltoid, QuadratKanten(1)], Distance[MittelpunktDeltoid, QuadratKanten(2)], Distance[MittelpunktDeltoid, QuadratKanten(3)], Distance[MittelpunktDeltoid, QuadratKanten(4)]}
maxe = Min(AbstaendeMittelpunkt)
eList = Shuffle(Sequence[1, maxe])
ewert: eList(1)
d = Circle(MittelpunktDeltoid, ewert)
D, B = Intersect(d, k)
dCoords = Vector(Ursprung, D)
bCoords = Vector(Ursprung, B)
gesuchtList = Shuffle({2, 4})
gesucht: gesuchtList(1)
solx = If(gesucht ≟ 1, x(aCoords), gesucht ≟ 2, x(bCoords), gesucht ≟ 3, x(cCoords), gesucht ≟ 4, x(dCoords))
soly = If(gesucht ≟ 1, y(aCoords), gesucht ≟ 2, y(bCoords), gesucht ≟ 3, y(cCoords), gesucht ≟ 4, y(dCoords))
SolPunkt: Ursprung + (solx, soly)
ValidateCircle = Circle(SolPunkt, 0.35)
correctInputPunkt = IsInRegion(InputPunkt, ValidateCircle)
input2 = NaN
input1 = NaN
correctCoords: gesucht ≟ 1 ∧ input1 ≟ x(aCoords) ∧ input2 ≟ y(aCoords) ∨ gesucht ≟ 2 ∧ input1 ≟ x(bCoords) ∧ input2 ≟ y(bCoords) ∨ gesucht ≟ 3 ∧ input1 ≟ x(cCoords) ∧ input2 ≟ y(cCoords) ∨ gesucht ≟ 4 ∧ input1 ≟ x(dCoords) ∧ input2 ≟ y(dCoords)
correct: correctInputPunkt ∧ (gesucht ≟ 1 ∧ input1 ≟ x(aCoords) ∧ input2 ≟ y(aCoords) ∨ gesucht ≟ 2 ∧ input1 ≟ x(bCoords) ∧ input2 ≟ y(bCoords) ∨ gesucht ≟ 3 ∧ input1 ≟ x(cCoords) ∧ input2 ≟ y(cCoords) ∨ gesucht ≟ 4 ∧ input1 ≟ x(dCoords) ∧ input2 ≟ y(dCoords))
Blue = (-5.32, 4.5)
Green = (-5.28, 3.68)
Orange = (-5.2, 2.86)
Red = (-5.32, 2.04)
Purple = (-5.34, 1.12)
Gray = (-5.34, 0.32)
GrayDark = (-5.36, -0.7)
validate = false
showanswer = false
showsolution = false
attemptCount = 0
correctCount = 0
textCountCorrect: "\text{Richtig gelöste Aufgaben: " + (LaTeX[correctCount]) + " }"
showButtonNew = false
showButtonTryAgain = false
showButtonValidate = true
showhint = false
InputBox1 = Textfield(input1)
InputBox2 = Textfield(input2)
showcorrecttext = false
questionCount = 1
PtopLeftCornerFeedback = (10.482140011117316, 8.452286826112278)
PbottomRightCornerFeedback = (13.481666401718272, 7.428036641300232)
PtopRightCornerFeedback: (x(PbottomRightCornerFeedback), y(PtopLeftCornerFeedback))
PbottomLeftCornerFeedback: (x(PtopLeftCornerFeedback), y(PbottomRightCornerFeedback))
rectangleCorrect, rectangleCorrectS3, rectangleCorrectS4, rectangleCorrectS2, rectangleCorrectS1 = Polygon(PtopLeftCornerFeedback, PtopRightCornerFeedback, PbottomRightCornerFeedback, PbottomLeftCornerFeedback)
showhinttypicalerror = false
allowCountIncrement = true
randomNosForX = Shuffle(Sequence[Random[0, 10], i, 1, 100])
numX = Element(randomNosForX, Mod[questionCount, 100] + 1)
randomNosForY = Shuffle(Sequence[Random[0, 10], i, 1, 100])
numY = Element(randomNosForY, Mod[questionCount, 100] + 1)
stayX = Append(true, Sequence[If[randomNosForX(i) ≟ randomNosForX(i - 1), false, true], i, 2, 100])
stayY = Append(true, Sequence[If[randomNosForY(i) ≟ randomNosForY(i - 1), false, true], i, 2, 100])
randomNosForXwithoutRepeat = Remove(Sequence[If[stayX(i), randomNosForX(i), 0], i, 1, 100], Sequence[0, i, 1, 100])
randomNosForYwithoutRepeat = Remove(Sequence[If[stayY(i), randomNosForY(i), 0], i, 1, 100], Sequence[0, i, 1, 100])
numXwithoutRepeat = Element(randomNosForXwithoutRepeat, Mod[questionCount, Length[randomNosForXwithoutRepeat]] + 1)
numYwithoutRepeat = Element(randomNosForYwithoutRepeat, Mod[questionCount, Length[randomNosForYwithoutRepeat]] + 1)
fixed: Defined[(input1 * input2)] ∨ correctCoords
isTypicalError: false
showbuttons: true
isFlink: true
tries: attemptCount
resx = 800 (slider from 0 to 1000, step 10)
resy = 600 (slider from 0 to 1000, step 10)
correctpartially: (¬correct) ∧ (correctInputPunkt ∨ correctCoords)
correctText: "\textsf{" + (LaTeX[If[correct, "\vphantom{✘}✓ Richtig", If[correctpartially, "\vphantom{✓}✘ Teilweise richtig", "\vphantom{✓}✘ Falsch"]]]) + ""
showButtonRestart = false
ResX: "|\\|" + (LaTeX[If[resy > 60, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 150, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 240, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 330, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 420, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 510, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 600, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 690, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 780, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 870, "\\|\\|\\|"]]) + "" + (LaTeX[If[resy > 960, "\\|\\|"]]) + ""
ResY: "" + (If[resx > 0, "------------------", ""]) + "" + (If[resx > 100, "-----------------", ""]) + "" + (If[resx > 200, "----------------", ""]) + "" + (If[resx > 300, "-----------------", ""]) + "" + (If[resx > 400, "-----------------", ""]) + "" + (If[resx > 500, "----------------", ""]) + "" + (If[resx > 600, "-----------------", ""]) + "" + (If[resx > 700, "-----------------", ""]) + "" + (If[resx > 800, "----------------", ""]) + "" + (If[resx > 900, "-----------------", ""]) + ""
Text1: "\textsf{" + (LaTeX[If[gesucht ≟ 1, "A", gesucht ≟ 2, "B", gesucht ≟ 3, "C", gesucht ≟ 4, "D"]]) + " = (      |      )}"
GrenzPunkteOben = Sequence(QE4 + (Vector[QE4, QE3] / 8 * i), i, 1, 7)
GrenzPunkteUnten = Sequence(QE1 + (Vector[QE1, QE2] / 8 * i), i, 1, 7)
GrenzPunkteLinks = Sequence(QE1 + (Vector[QE1, QE4] / 8 * i), i, 1, 7)
GrenzPunkteRechts = Sequence(QE2 + (Vector[QE1, QE4] / 8 * i), i, 1, 7)
GitterVertikal = Sequence(Segment[GrenzPunkteOben(i), GrenzPunkteUnten(i)], i, 1, 9)
GitterHorizontal = Sequence(Segment[GrenzPunkteRechts(i), GrenzPunkteLinks(i)], i, 1, 9)
HelpP1: Ursprung - (0, 1)
HelpP2: Ursprung + (1, 0)
f = Line(Ursprung, HelpP1)
g = Line(Ursprung, HelpP2)
EndXPos = Intersect(g, QuadratKanten(2))
EndXNeg = Intersect(g, QuadratKanten(4))
EndYNeg = Intersect(f, QuadratKanten(1))
EndYPos = Intersect(f, QuadratKanten(3))
yAchsel = Segment(EndYPos, EndYNeg)
xAchsel = Segment(EndXPos, EndXNeg)
v1, c_{1}, c_2, a, d_1 = Polygon(C, B, A, D)
solb = Segment(C, B)
sola = Segment(B, A)
sold = Segment(A, D)
solc = Segment(D, C)
AchsenpunkteX = Sequence(EndXNeg + (Vector[EndXNeg, EndXPos] * i / 8), i, 1, 7)
AchsenpunkteY = Sequence(EndYNeg + (Vector[EndYNeg, EndYPos] * i / 8), i, 1, 7)
BeschriftungXAchse = Sequence(Distance[AchsenpunkteX(i), Ursprung], i, 1, 7)
BeschriftungYAchse = Sequence(Distance[AchsenpunkteY(i), Ursprung], i, 1, 7)
BeschriftungXAchse2: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(2)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(2)]) + "}"
BeschriftungXAchse1: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(1)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(1)]) + "}"
BeschriftungXAchse4: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(4)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(4)]) + "}"
BeschriftungXAchse5: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(5)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(5)]) + "}"
BeschriftungXAchse6: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(6)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(6)]) + "}"
BeschriftungXAchse7: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(7)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(7)]) + "}"
BeschriftungXAchse3: "\textsf{" + (LaTeX[If[x(AchsenpunkteX(3)) < x(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungXAchse(3)]) + "}"
BeschriftungYAchse1: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(1)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(1)]) + "}"
BeschriftungYAchse2: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(2)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(2)]) + "}"
BeschriftungYAchse3: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(3)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(3)]) + "}"
BeschriftungYAchse4: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(4)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(4)]) + "}"
BeschriftungYAchse5: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(5)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(5)]) + "}"
BeschriftungYAchse6: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(6)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(6)]) + "}"
BeschriftungYAchse7: "\textsf{" + (LaTeX[If[y(AchsenpunkteY(7)) < y(Ursprung), "-", ""]]) + "" + (LaTeX[BeschriftungYAchse(7)]) + "}"
solutionText: "\text{Lösung:\\" + (LaTeX[If[gesucht ≟ 1, "A", gesucht ≟ 2, "B", gesucht ≟ 3, "C", gesucht ≟ 4, "D"]]) + " = ( \(" + (LaTeX[solx]) + "\) | \(" + (LaTeX[soly]) + "\) )"
OrangeCoords = Vector(Ursprung, InputPunkt)
BeschAP: A + (Vector[MittelpunktDeltoid, A] / Length[Vector[MittelpunktDeltoid, A]] * 0.5)
BeschBP: B + (Vector[MittelpunktDeltoid, B] / Length[Vector[MittelpunktDeltoid, B]] * 0.5)
BeschCP: C + (Vector[MittelpunktDeltoid, C] / Length[Vector[MittelpunktDeltoid, C]] * 0.5)
BeschDP: D + (Vector[MittelpunktDeltoid, D] / Length[Vector[MittelpunktDeltoid, D]] * 0.5)
BeschTextA = Text(BeschHelpA, BeschAP, false, true, 0, 0)
BeschTextB = Text(BeschHelpB, BeschBP, false, true, 0, 0)
BeschTextC = Text(BeschHelpC, BeschCP, false, true, 0, 0)
BeschTextD = Text(BeschHelpD, BeschDP, false, true, 0, 0)
hintText: "\textsf\colorbox{ebe7f8}{Der Wert der 1. Koordinate\\
beträgt " + (LaTeX[solx]) + ".}"
vorzeichenfehler: (¬correctCoords) ∧ (input1 ≟ (-solx) ∨ input2 ≟ (-soly))
devhintcheck = false
BeschInputPunkt: "\textsf{" + (LaTeX[If[gesucht ≟ 1, "A", gesucht ≟ 2, "B", gesucht ≟ 3, "C", "D"]]) + "}"
e = Circle(InputPunkt, 0.3)
questionText: "\text{Von einem Deltoid sind 3 Eckpunkte gegeben.\\Vervollständige zuerst das Deltoid und bestimme dann die Koordinaten\\
des fehlenden Eckpunkts " + (LaTeX[If[gesucht ≟ 1, "A", gesucht ≟ 2, "B", gesucht ≟ 3, "C", gesucht ≟ 4, "D"]]) + ".}"
E: (8.01, 8.74844)
LA = 0.45 (slider from 0 to 3, step 0.01)
l = Segment(E, E + (0, (-LA)))
gezogen = false