MathPlotAI Logo MathPlotAI

Card Sort: Multiplying and Dividing Integers

Card Sort: Multiplying and Dividing Integers
Loading the math board and drawing, please wait…
2023-08-03 05:18
This example demonstrates integer multiplication and division through a card sorting activity. It focuses on understanding the rules for multiplying and dividing positive and negative numbers, including sign rules and order of operations. The construction uses GeoGebra commands like Sample, Shuffle, Polygon, and Sequence to create and arrange cards. Suitable for grades 6-8 for classroom practice and homework to reinforce integer arithmetic skills.

GeoGebra Commands & Parameters

  1. Sample(Sequence[26, 34], 3) → indices4, {27, 32, 31}
  2. Sample(Sequence[17, 25], 3) → indices3, {24, 17, 18}
  3. Sample(Sequence[9, 16], 3) → indices2, {15, 16, 11}
  4. Sample(Sequence[8], 3) → indices1, {4, 1, 2}
  5. Shuffle(Join[{indices1, indices2, indices3, indices4}]) → indicesAll, {2, 11, 27, 4, 15, 16, 1, 31, 18, 32, 17, 24}
  6. Take(indicesAll, 1, 8) → indices
  7. RemoveUndefined(Zip[IndexOf[kk, indices], kk, indices4]) → indices4coded
  8. RemoveUndefined(Zip[IndexOf[kk, indices], kk, indices3]) → indices3coded
  9. RemoveUndefined(Zip[IndexOf[kk, indices], kk, indices2]) → indices2coded
  10. RemoveUndefined(Zip[IndexOf[kk, indices], kk, indices1]) → indices1coded
  11. RemoveUndefined(Zip[Sort[ll], ll, {indices1coded, indices2coded, indices3coded, indices4coded}]) → expected
  12. Polygon({(-2.5, -2.68), (-2.5, -2.68) + (wid2, 0), (-2.5, -2.68) + (wid2, (6 * hei2) + 0.1), (-2.5, -2.68) + (0, (6 * hei2) + 0.1)}) → DropArea1
  13. Sequence(Vertex[DropArea1, 4] - ((0, hei2) * ii) + (0.1, 0), ii, 1, 6) → target1
  14. Translate(target1, vec) → target2
  15. Translate(target2, vec) → target3
  16. Translate(target3, vec) → target4
  17. IndexOf(true, Zip[Defined[IndexOf[C8, ll]], ll, {target1, target2, target3, target4}]) → box8In
  18. IndexOf(true, Zip[Defined[IndexOf[C7, ll]], ll, {target1, target2, target3, target4}]) → box7In
  19. IndexOf(true, Zip[Defined[IndexOf[C6, ll]], ll, {target1, target2, target3, target4}]) → box6In
  20. IndexOf(true, Zip[Defined[IndexOf[C5, ll]], ll, {target1, target2, target3, target4}]) → box5In
  21. IndexOf(true, Zip[Defined[IndexOf[C4, ll]], ll, {target1, target2, target3, target4}]) → box4In
  22. IndexOf(true, Zip[Defined[IndexOf[C3, ll]], ll, {target1, target2, target3, target4}]) → box3In
  23. IndexOf(true, Zip[Defined[IndexOf[C2, ll]], ll, {target1, target2, target3, target4}]) → box2In
  24. IndexOf(true, Zip[Defined[IndexOf[C1, ll]], ll, {target1, target2, target3, target4}]) → box1In
  25. RemoveUndefined(Sequence[If[Element[{box1In, box2In, box3In, box4In, box5In, box6In, box7In, box8In}, kk] ≟ 4, kk], kk, 1, 8]) → boxesInT4
  26. If(Length[boxesInT4] ≥ 1, Zip[Element[indicesAll, kk], kk, boxesInT4], {}) → indicesInT4
  27. RemoveUndefined(Sequence[If[Element[{box1In, box2In, box3In, box4In, box5In, box6In, box7In, box8In}, kk] ≟ 3, kk], kk, 1, 8]) → boxesInT3
  28. If(Length[boxesInT3] ≥ 1, Zip[Element[indicesAll, kk], kk, boxesInT3], {}) → indicesInT3
  29. RemoveUndefined(Sequence[If[Element[{box1In, box2In, box3In, box4In, box5In, box6In, box7In, box8In}, kk] ≟ 2, kk], kk, 1, 8]) → boxesInT2
  30. If(Length[boxesInT2] ≥ 1, Zip[Element[indicesAll, kk], kk, boxesInT2], {}) → indicesInT2
  31. RemoveUndefined(Sequence[If[Element[{box1In, box2In, box3In, box4In, box5In, box6In, box7In, box8In}, kk] ≟ 1, kk], kk, 1, 8]) → boxesInT1
  32. If(Length[boxesInT1] ≥ 1, Zip[Element[indicesAll, kk], kk, boxesInT1], {}) → indicesInT1
  33. Zip(Sort[ll], ll, KeepIf[Length[ll] ≥ 1, ll, inputCurrent]) → inputCurrentNoEmpty
  34. Zip(Defined[IndexOf[ll, inputCurrentNoEmpty]], ll, expected) → comparing
  35. Zip(indicesInT1 \ ll, ll, {indices1, indices2, indices3, indices4}) → setDiff1
  36. Defined(IndexOf[0, Zip[Length[LL], LL, setDiff1]]) → correct1
  37. Zip(indicesInT2 \ ll, ll, {indices1, indices2, indices3, indices4}) → setDiff2
  38. Defined(IndexOf[0, Zip[Length[LL], LL, setDiff2]]) → correct2
  39. Zip(indicesInT3 \ ll, ll, {indices1, indices2, indices3, indices4}) → setDiff3
  40. Defined(IndexOf[0, Zip[Length[LL], LL, setDiff3]]) → correct3
  41. Zip(indicesInT4 \ ll, ll, {indices1, indices2, indices3, indices4}) → setDiff4
  42. Defined(IndexOf[0, Zip[Length[LL], LL, setDiff4]]) → correct4
  43. Sequence(Random[0, 99] / 100, A, 1, 200) → allRandomSeeds, {0.08, 0.85, 0.14, 0.23, 0.81, 0.05, 0.71, 0.24, 0.87, 0.07, 0.95, 0.94, 0.13, 0.82, 0.46, 0.62, 0.51, 0.89, 0.21, 0.11, 0.62, 0.56, 0.17, 0.84, 0.14, 0.94, 0.58, 0.54, 0.13, 0.63, 0.3, 0.07, 0.2, 0.92, 0.52, 0.53, 0.9, 0.88, 0.89, 0.18, 0.81, 0.18, 0.98, 0.46, 0.22, 0.25, 0.28, 0.07, 0.01, 0.97, 0.12, 0.61, 0.53, 0.03, 0.83, 0.59, 0.26, 0.21, 0.7, 0.36, 0.04, 0.35, 0.76, 0.91, 0.13, 0.7, 0.13, 0.15, 0.92, 0.63, 0, 0.35, 0.13, 0.77, 0.41, 0.91, 0.65, 0.56, 0.68, 0.31, 0.5, 0.45, 0.57, 0.88, 0.96, 0.88, 0.2, 0.46, 0.74, 0.4, 0.65, 0.18, 0.72, 0.03, 0.74, 0.37, 0.31, 0.3, 0.22, 0.97, 0.44, 0.43, 0.95, 0.66, 0.58, 0.62, 0.73, 0.82, 0.58, 0.77, 0.96, 0.55, 0.41, 0.53, 0.67, 0.42, 0.89, 0.35, 0.74, 0.54, 0.7, 0.68, 0.83, 0.66, 0.08, 0.18, 0.31, 0.08, 0.37, 0.79, 0.56, 0.83, 0.88, 0.67, 0.58, 0.96, 0.73, 0.3, 0.01, 0.57, 0.73, 0.67, 0.38, 0.43, 0.59, 0.73, 0.8, 0.62, 0.05, 0.37, 0.95, 0.99, 0.85, 0.17, 0.8, 0.78, 0.99, 0.48, 0.79, 0.86, 0.16, 0.71, 0.04, 0.78, 0.13, 0.56, 0.06, 0.61, 0.42, 0.93, 0.31, 0.7, 0.94, 0.63, 0.18, 0.39, 0.6, 0.77, 0.42, 0.44, 0.49, 0.09, 0.71, 0.97, 0.84, 0.67, 0.19, 0.52, 0.83, 0.5, 0.27, 0.44, 0.07, 0.96, 0.77, 0.36, 0.88, 0.73, 0.98, 0.72}
  44. Take(allRandomSeeds, randIndex, randIndex + numRandoms - 1) → currentRandomSeeds
  45. Corner(5) → layoutAppSize
  46. Polygon(inputPoint, TriA, TriB) → tri, b, inputpoint, a
  47. onboardingTextOffset(Corner[onboardingText, 1], Corner[onboardingText, 3], onboardingCase, Corner[1], Corner[3], Corner[5]) → OnboardingTextOffset
  48. KeepIf(GCD[kk, numA] ≟ 1, kk, Sequence[1, 3]) → nums2
  49. Element(nums2, numB) → num2
  50. Join({groupAB, groupBA, groupABMin, groupBAMin}) → groupsAll
  51. Polygon(C1, C1 + (wid, 0), C1 + (wid, hei), C1 + (0, hei)) → q1, c1, f, g, h
  52. Polygon(C2, C2 + (wid, 0), C2 + (wid, hei), C2 + (0, hei)) → q2, c2, i, j, k
  53. Polygon(C3, C3 + (wid, 0), C3 + (wid, hei), C3 + (0, hei)) → q3, c3, l, m, n
  54. Polygon(C4, C4 + (wid, 0), C4 + (wid, hei), C4 + (0, hei)) → q4, c4, p, q, r
  55. Polygon(C5, C5 + (wid, 0), C5 + (wid, hei), C5 + (0, hei)) → q5, c5, s, t, c
  56. Polygon(C6, C6 + (wid, 0), C6 + (wid, hei), C6 + (0, hei)) → q6, c6, d, e, f_1
  57. Polygon(C7, C7 + (wid, 0), C7 + (wid, hei), C7 + (0, hei)) → q7, c7, g_1, h_1, i_1
  58. Polygon(C8, C8 + (wid, 0), C8 + (wid, hei), C8 + (0, hei)) → q8, c8, j_1, k_1, l_1
  59. Translate(DropArea1, vec) → DropArea2
  60. Translate(DropArea2, vec) → DropArea3
  61. Translate(DropArea3, vec) → DropArea4
  62. Translate(p_1, ((Corner[4] - Corner[1]) / 500 * 16)) → m_1
  63. Sequence((-4.85, 1) + ((ii * 0.05), ((-ii) * 0.1)), ii, 0, 8) → home
  64. Join({target1, target2, target3, target4, home}) → FixedPoints
  65. Zip(¬Defined[IndexOf[PP, FixedPoints]], PP, {C1, C2, C3, C4, C5, C6, C7, C8}) → boxesInMovement
  66. Zip(If[kk, 180, 226] / 255, kk, boxesInMovement) → red
  67. Zip(If[kk, 170, 223] / 255, kk, boxesInMovement) → green
  68. Zip(If[kk, 248, 252] / 255, kk, boxesInMovement) → blue
  69. Zip(Area[IntersectPath[q2, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox2
  70. Zip(Area[IntersectPath[q1, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox1
  71. Zip(Area[IntersectPath[q3, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox3
  72. Zip(Area[IntersectPath[q4, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox4
  73. Zip(Area[IntersectPath[q5, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox5
  74. Zip(Area[IntersectPath[q6, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox6
  75. Zip(Area[IntersectPath[q7, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox7
  76. Zip(Area[IntersectPath[q8, pp]], pp, {DropArea1, DropArea2, DropArea3, DropArea4}) → intersectionsBox8
  77. IndexOf(Max[RemoveUndefined[intersectionsBox1]], intersectionsBox1) → box1To
  78. IndexOf(Max[RemoveUndefined[intersectionsBox2]], intersectionsBox2) → box2To
  79. IndexOf(Max[RemoveUndefined[intersectionsBox3]], intersectionsBox3) → box3To
  80. IndexOf(Max[RemoveUndefined[intersectionsBox4]], intersectionsBox4) → box4To
  81. IndexOf(Max[RemoveUndefined[intersectionsBox5]], intersectionsBox5) → box5To
  82. IndexOf(Max[RemoveUndefined[intersectionsBox6]], intersectionsBox6) → box6To
  83. IndexOf(Max[RemoveUndefined[intersectionsBox7]], intersectionsBox7) → box7To
  84. IndexOf(Max[RemoveUndefined[intersectionsBox8]], intersectionsBox8) → box8To
  85. CountIf(x ≟ 1, locationOfEachBox) → inTarget1
  86. CountIf(x ≟ 2, locationOfEachBox) → inTarget2
  87. CountIf(x ≟ 3, locationOfEachBox) → inTarget3
  88. CountIf(x ≟ 4, locationOfEachBox) → inTarget4
  89. Element({box1To, box2To, box3To, box4To, box5To, box6To, box7To, box8To}, IndexOf[true, boxesInMovement]) → numActiveDropArea
  90. Element({DropArea1, DropArea2, DropArea3, DropArea4}, numActiveDropArea) → ActiveDropAreaW
  91. Translate(ec1, ((x(Corner[2] - Corner[1]) / 800 * 16), 0)) → ec1'
  92. Sequence(IndexOf[true, Zip[Defined[IndexOf[kk, LL]], LL, {indices1coded, indices2coded, indices3coded, indices4coded}]], kk, 1, 8) → shouldbe
  93. Zip(Element[{groupAB(1), groupBA(1), groupABMin(1), ("-" * groupBA(1))}, kk], kk, shouldbe) → complementText
  94. Text(Element[groupsAll, indices(1)] + (If[showsolution, ("=" * complementText(1)), ""]), Centroid[q1], true, true, 0, 0) → text1
  95. Text(Element[groupsAll, indices(2)] + (If[showsolution, ("=" * complementText(2)), ""]), Centroid[q2], true, true, 0, 0) → text2
  96. Text(Element[groupsAll, indices(3)] + (If[showsolution, ("=" * complementText(3)), ""]), Centroid[q3], true, true, 0, 0) → text3
  97. Text(Element[groupsAll, indices(4)] + (If[showsolution, ("=" * complementText(4)), ""]), Centroid[q4], true, true, 0, 0) → text4
  98. Text(Element[groupsAll, indices(5)] + (If[showsolution, ("=" * complementText(5)), ""]), Centroid[q5], true, true, 0, 0) → text5
  99. Text(Element[groupsAll, indices(6)] + (If[showsolution, ("=" * complementText(6)), ""]), Centroid[q6], true, true, 0, 0) → text6
  100. Text(Element[groupsAll, indices(7)] + (If[showsolution, ("=" * complementText(7)), ""]), Centroid[q7], true, true, 0, 0) → text7
  101. Text(Element[groupsAll, indices(8)] + (If[showsolution, ("=" * complementText(8)), ""]), Centroid[q8], true, true, 0, 0) → text8
  102. expandQuad(home(8), home(8) + (wid, 0), home(8) + (wid, hei), home(8) + (0, hei), (7 * pulsing), Corner[1], Corner[3], Corner[5]) → pulsingObject
  103. Reverse(Sort[Zip[Element[corners, kk], kk, boxesInT1]]) → cornersInT1
  104. Zip("C" + (IndexOf[PP, corners]), PP, cornersInT1) → cornersInT1names
  105. Reverse(Sort[Zip[Element[corners, kk], kk, boxesInT2]]) → cornersInT2
  106. Reverse(Sort[Zip[Element[corners, kk], kk, boxesInT3]]) → cornersInT3
  107. Reverse(Sort[Zip[Element[corners, kk], kk, boxesInT4]]) → cornersInT4
  108. Zip("C" + (IndexOf[PP, corners]), PP, cornersInT2) → cornersInT2names
  109. Zip("C" + (IndexOf[PP, corners]), PP, cornersInT3) → cornersInT3names
  110. Zip("C" + (IndexOf[PP, corners]), PP, cornersInT4) → cornersInT4names
  111. If(Length[boxesInT1] ≠ 0, Zip[(((("SetValue(" * ii) * ",") * PP) * ")"), ii, cornersInT1names, PP, target1], {}) → organizet1
  112. If(Length[boxesInT2] ≠ 0, Zip[(((("SetValue(" * ii) * ",") * PP) * ")"), ii, cornersInT2names, PP, target2], {}) → organizet2
  113. If(Length[boxesInT3] ≠ 0, Zip[(((("SetValue(" * ii) * ",") * PP) * ")"), ii, cornersInT3names, PP, target3], {}) → organizet3
  114. If(Length[boxesInT4] ≠ 0, Zip[(((("SetValue(" * ii) * ",") * PP) * ")"), ii, cornersInT4names, PP, target4], {}) → organizet4
  115. Zip(LL ∈ expected, LL, inputCurrent) → correctGroups
  116. Sequence((((((((("SetDynamicColor(DropAreaBG" * kk) * ",If(correctGroups(") * kk) * "),210,241)/255,If(correctGroups(") * kk) * "),228,210)/255,If(correctGroups(") * kk) * "),226,216)/255)"), kk, 1, 4) → colorDropAreasBg
  117. If(correctSol, 5, -5) → speedAnim
  118. Text(If[correctSol, "$\textsf{YOUR SOLUTION}$", "$\textsf{SHOW SOLUTION}$"], (0, 0), true, true) → labelBtnAnimSol
  119. Sequence((((((((((((((("SetDynamicColor(DropArea" * kk) * ",If((showhint∨showsolution)&&(anim==0∨anim==1)&&Length(inputCurrent(") * kk) * ")) ≥ 1,If(correctGroups(") * kk) * "),0,176),101)/255,If((showhint∨showsolution)&&(anim==0∨anim==1)&&Length(inputCurrent(") * kk) * ")) ≥ 1,If(correctGroups(") * kk) * "),103,0),87)/255,If((showhint∨showsolution)&&(anim==0∨anim==1)&&Length(inputCurrent(") * kk) * ")) ≥ 1,If(correctGroups(") * kk) * "),88,32),210)/255)"), kk, 1, 4) → colorDropAreas

AI Drawing Prompt Reference

Create a card sorting activity demonstrating integer multiplication and division rules. Randomly generate four sets of number cards, each containing three cards from the ranges 26-34, 17-25, 9-16, and 8. Mix and sort all the cards, then select the first eight. Assign the numbers on the cards to four different areas, each representing a category. The final image should clearly show the process and result of card sorting, illustrating the sign rules and order of operations for integer multiplication and division.
The prompt above was compiled from the original drawing commands and is for reference only.