def tangencyPointProblem(): try: d = random.randint(11, 20) t = random.randint(21, 30) x = ((t**2) - (d**2)) / (2 * d) sol = round(x + d, 4) solution = r"" + str(sol) question = r"You are walking towards a circular swimming pool. At some moment you are standing " + str( d ) + r"ft from the border, while your distance to the point of tangency is " + str( t) + r"ft. How many ft are you from the center of the pool?: " alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def lhospitalProblem(): try: a1 = random.randint(2,10) b1 = random.randint(2,10) c1 = random.randint(2,11) if a1==b1: return lhospitalProblem() sol1 = "-inf" if (a1/b1<1 and c1%2==1) else "inf" a = random.randint(2,10) b = random.randint(2,10) c = random.randint(2,10) d = random.randint(2,10) sol=round((a/b)+(c/(d*3)),4) solution="" question="" a0 = random.randint(0,1) if a0==1: question="find the limit(x->0) of ["+str(a*d)+"ln(x+1)*x^3+"+str(b*c)+"xtan(x)-"+str(b*c)+"x^2]/["+str(b*d)+"x^4]" solution=str(sol) else: question="find the limit(x->inf) of ["+str(round(a1/b1,4))+"^x+ln(x)]/[x^"+str(c1)+"]" solution=sol1 alternatives = coursesFunctionsBll.multipleOptions([sol],3) tempAlternatives =[] for y in range(3): tempAlternatives.append(str(alternatives[y][0])) options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': 'inf', 'e': '-inf'})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def densityProblem(): try: a = random.randint(2,10) b = random.randint(2,10) c = random.randint(2,10) d = random.randint(2,10) e = random.randint(11,20) mass= random.randint(2,25) a1= (a*c)-(2*a*c) b1= -(2*c*b) c1= (a*d) if (b1*b1)<=(4*a1*c1): return densityProblem() t1= ((-b1)+math.sqrt((b1*b1)-(4*a1*c1)))/(2*a1) t2= ((-b1)-math.sqrt((b1*b1)-(4*a1*c1)))/(2*a1) vol1= (a*t1+b)/(c*t1**2+d)+e vol2= (a*t2+b)/(c*t2**2+d)+e denMax = round((mass/vol1),4) if (mass/vol1)>(mass/vol2) else round((mass/vol2),4) denMin = round((mass/vol1),4) if (mass/vol1)<(mass/vol2) else round((mass/vol2),4) question = "A certain object, which mass is equal to "+str(mass)+"kg, has a volume (in cm^3) equal to ("+str(e*c)+"t^2+"+str(a)+"t+"+str(b+(e*d))+")/("+str(c)+"t^2+"+str(d)+") (t is celcius). Find the maximum and minimum density: " solution= "minimum="+str(denMin)+"kg/cm^3. maximum="+str(denMax)+"kg/cm^3" proportion= denMax/denMin alternatives = coursesFunctionsBll.multipleOptions([denMin],5) tempAlternatives =[] for y in range(5): tempAlternatives.append("minimum="+str(alternatives[y][0])+"kg/cm^3. maximum="+str(round(alternatives[y][0]*proportion,4))+"kg/cm^3") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def circleRegularPolygonProblem2(): try: x = random.randint(10, 20) s = random.randint(3, 10) angle = (s - 2) * 180 / (s * 2) h = (x / 2) * math.tan(angle * math.pi / 180) area = round(math.pi * h * h, 4) solution = r"" + str(area) question = r"For a regular polygon of " + str( s) + " sides, where each side have a length of " + str( x ) + r", find the area of the circle inscribed in this polygon: " alternatives = coursesFunctionsBll.multipleOptions([area], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def quadrilateralProblem(): try: c1 = random.randint(1, 45) c2 = random.randint(1, 45) a1 = random.randint(2, 10) a2 = random.randint(2, 10) sol = round((180 - (c1 + c2)) / (a1 + a2), 4) solution = r"" + str(sol) question = r"A quadrilateral incribed in a circle has inner opposite angles A and B, where A degrees are " + str( a1) + r"x+" + str(c1) + r" and B degrees are " + str( a2) + r"x+" + str(c2) + r". Which is the value of x?:" alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def varianceProblem(): try: cards = [] for i in range(5): cards.append(random.randint(1, 20)) sums = [] for x in range(5): y = x + 1 while y < 5: sums.append(cards[x] + cards[y]) #sum+=cards[x]+cards[y] y += 1 sol1 = round((sum(s for s in sums)) / 10, 4) sol2 = round((sum((s - sol1)**2 for s in sums)) / 10, 4) sol3 = round(sol2**(1 / 2), 4) solution = r"Expected value=" + str(sol1) + r", variance=" + str( sol2) + r", standard deviation=" + str(sol3) + r"" question = r"In a card game a player has a hand of 5 cards with cards of next values: " + str( cards[0] ) + r"," + str(cards[1]) + r"," + str(cards[2]) + r"," + str( cards[3] ) + r"," + str( cards[4] ) + r". For taking two of this 5 cards find the expected value, variation and standard deviation: " alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2, sol3], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"Expected value=" + str(alternatives[ta][0]) + r", variance=" + str(alternatives[ta][1]) + r", standard deviation=" + str(alternatives[ta][2]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def confidenceComparisonSamplesProblem(): try: n1 = random.randint(41, 50) n2 = random.randint(31, 40) u1 = random.randint(31, 40) u2 = random.randint(41, 50) s1 = random.randint(2, 5) s2 = random.randint(6, 9) pOptions = [0.2, 0.1, 0.05, 0.02, 0.01, 0.005] p = pOptions[random.randint(0, 5)] z = coursesFunctionsBll.normalDistributionInverse(1 - (p / 2)) sol = round(z * ((((s1**2) / n1) + ((s2**2) / n2))**0.5), 4) solution = r"" + str(abs(u1 - u2)) + r" \pm " + str(sol) + r"" question = r'In a software company the average age of programmers have standard deviation of ' + str( s1 ) + r' years, and for human resources they have a standard deviation of ' + str( s2 ) + r' years. \\ In a sample of ' + str( n1 ) + r' programmers the average age was ' + str( u1 ) + r' years, and in a sample of ' + str( n2 ) + r' human resources employees the average age was ' + str( u2 ) + r' years. \\ Find the confidence interval for the difference of height with a level of ' + str( round(100 * (1 - p), 2)) + r'\%. Choose the closest option: ' alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(abs(u1 - u2)) + r" \pm " + str(alternatives[ta][0]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def circleKiteProblem(): try: z = random.randint(30, 150) a = b = 0 while True: a = random.randint(5, 20) b = random.randint(5, 20) if a < b: break area = a * b * math.sin(z * math.pi / 180) c = ((a**2) + (b**2) - (2 * a * b * math.cos(z * math.pi / 180)))**(1 / 2) z1 = z / 2 #short = round(2*area/long,4) #height = short/2 z2 = math.asin((a / c) * math.sin(z * math.pi / 180)) * 180 / math.pi z3 = 180 - z1 - z2 b2 = b * math.sin(z1 * math.pi / 180) / math.sin(z3 * math.pi / 180) b3 = round(math.sin(z2 * math.pi / 180) * b2, 4) solution = r"" + str(b3) question = r"For a kite with side A with length " + str( a ) + r" and side B with length " + str( b ) + r", and angle between them equals to " + str( z ) + r" degrees, find the radio of the circle inscribed in the kite: " alternatives = coursesFunctionsBll.multipleOptions([b3], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def hyperGeometricVarianceProblem(): try: nk = random.randint(32, 64) nx = random.randint(8, 16) k = random.randint(8, 16) p = k / nk q = 1 - p sol1 = round(nx * p, 4) sol2 = round(nx * p * q * (nk - nx) / (nk - 1), 4) sol3 = round(sol2**(1 / 2), 4) solution = r"Expected value=" + str(sol1) + r", variance=" + str( sol2) + r", standard deviation=" + str(sol3) + r"" question = r"A glasses factory for this month make " + str( nk ) + r" glasses, the quality engineer finds that " + str( k ) + r" glasses are broken. for a group of " + str( nx ) + r" glasses randomly chosen, find a) \mu b) \sigma^{2} c) \sigma: " alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2, sol3], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"Expected value=" + str(alternatives[ta][0]) + r", variance=" + str(alternatives[ta][1]) + r", standard deviation=" + str(alternatives[ta][2]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def kiteSinAreaProblem(): try: z = random.randint(30, 150) a = b = 0 while True: a = random.randint(5, 20) b = random.randint(5, 20) if a != b: break area = round(a * b * math.sin(z * math.pi / 180), 4) long = ((a**2) + (b**2) - (2 * a * b * math.cos(z * math.pi / 180)))**(1 / 2) short = round(2 * area / long, 4) solution = r"area: " + str(area) + r", diagonal: " + str(short) + r"" question = r"For a kite with side A with length " + str( a ) + r" and side B with length " + str( b ) + r", and angle between them equals to " + str( z ) + r" degrees, find the area of the kite and the length of diagonal which connects the two congruent angles of the kite: " alternatives = coursesFunctionsBll.multipleOptions([area, short], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"area: " + str(alternatives[ta][0]) + r", diagonal: " + str(alternatives[ta][1]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def coneProblem(): try: z = random.randint(2, 10) h = random.randint(75, 100) d = random.randint(50, 75) h0 = random.randint(25, 50) sol = round((z*4*(h**2))/(math.pi*(d**2)*(h0**2)),4) solution = r""+str(sol)+r"\frac{cm}{s}" question=r"A cone turned upside down (so it looks like a v) is being filled with water from the faucet at speed of "+str(z)+r"cm^3/s. If the cone height is "+str(h)+r"cm and base diameter is "+str(d)+r"cm, find the rate change of height of filled cone when this height is "+str(h0)+r"cm: " alternatives = coursesFunctionsBll.multipleOptions([sol],5) tempAlternatives =[] for m in range(5): tempAlternatives.append(r""+str(alternatives[m][0])+r"\frac{cm}{s}") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def confidenceBigSamplesProblem(): try: x = random.randint(50, 100) m = random.randint(150, 175) s = random.randint(5, 10) pOptions = [0.2, 0.1, 0.05, 0.02, 0.01, 0.005] p = pOptions[random.randint(0, 5)] z = coursesFunctionsBll.normalDistributionInverse(1 - (p / 2)) sol = round(z * s / (x**0.5), 4) solution = r"" + str(m) + r" \pm " + str(sol) + r"" question = r'A sample of ' + str( x ) + r' school girls give an average height of ' + str( m ) + r' cms and standard deviation of ' + str( s ) + r' cms. Find the confidence limit with a ' + str( round(100 * (1 - p), 1) ) + r'\% for the real height of all the school girls (choose the closest option): ' alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(m) + r" \pm " + str(alternatives[ta][0]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def tStudentProblem(): try: x = random.randint(5, 25) m = random.randint(100, 200) s = random.randint(5, 10) pOptions = [0.2, 0.1, 0.05, 0.02, 0.01, 0.005] p = pOptions[random.randint(0, 5)] t = abs(coursesFunctionsBll.tStudentAprox(p / 2, x - 1)) sol = round(t * s / (x**0.5), 4) solution = r"" + str(m) + r" \pm " + str(sol) + r"" question = r'A sample of ' + str( x ) + r' canned tunas give an average weight of ' + str( m ) + r' grams and standard deviation of ' + str( s ) + r' grams. Find the confidence limit with a ' + str( round(100 * (1 - p), 1) ) + r'\% for the real weight of all the canned tunas (choose the closest option): ' alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(m) + r" \pm " + str(alternatives[ta][0]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def balloonProblem(): try: volumeChange = random.randint(1,50) diameter = random.randint(50,100) unit= random.randint(0,2) ratio= diameter/2 units=[["milimeters","mm",10],["micrometers","um",10000],["nanometers","nm",10000000]] sol=round((units[unit][2]*volumeChange)/(4*math.pi*(ratio**2)),4) question = "A perfectly spherical balloon is inflated and its volume increase by a constant of "+str(volumeChange)+"cm^3/s. How fast changes its ratio when the diameter is "+str(diameter)+"cm? write the answer in "+str(units[unit][0])+"/second ("+str(units[unit][1])+"/s):" solution= str(sol)+str(units[unit][1])+"/s" alternatives = coursesFunctionsBll.multipleOptions([sol],5) tempAlternatives =[] for y in range(5): tempAlternatives.append(str(alternatives[y][0])+str(units[unit][1])+"/s") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def carDistanceProblem(): try: x = random.randint(250, 500) y = random.randint(250, 500) dx = random.randint(25, 50) dy = random.randint(25, 50) h=((x**2)+(y**2))**(1/2) sol = round(((x*dx)+(y*dy))/h,4) solution = str(sol)+r"\frac{km}{h}" question=r"two police cars left the police station (not necessarily at same time), car A moves to the west at speed of "+str(dx)+r"km/h and car B moves the the north at speed of "+str(dy)+r"km/h. At some point car A is at a distance of "+str(x)+r"km from the police station, while car B is at a distance of "+str(y)+r"km from the police station. How fast is increasing the distance between the two cars?: " alternatives = coursesFunctionsBll.multipleOptions([sol],5) tempAlternatives =[] for m in range(5): tempAlternatives.append(str(alternatives[m][0])+r"\frac{km}{h}") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def apothemProblem(): try: s0 = random.randint(5, 10) #number of sides l0 = random.randint(10, 100) #apothem a0 = (s0 - 2) * (math.pi) #total inner angle a1 = a0 / s0 #angle per corner b0 = (l0 * 2) / math.tan(a1 / 2) #base per side area = round((l0 * b0 / 2) * s0, 4) perimeter = round(b0 * s0, 4) solution = r"area= " + str(area) + r"cm^{2}, perimeter=" + str( perimeter) + r"cm" question = r"A regular polygon of " + str( s0) + r" sides have an apothem of " + str( l0) + r" cm. Find its area and perimeter: " alternatives = coursesFunctionsBll.multipleOptions([area, perimeter], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"area= " + str(alternatives[ta][0]) + r"cm^{2}, perimeter=" + str(alternatives[ta][1]) + r"cm") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def sinTheoremProblem(): try: z = random.randint(10, 20) a = b = 90 while True: a = random.randint(1, 178) b = random.randint(1, 178) if a + b < (180): break c = 180 - a - b constant = z / math.sin(c * math.pi / 180) y = constant * math.sin(b * math.pi / 180) x = constant * math.sin(a * math.pi / 180) sol = round(x + y + z, 4) solution = r"" + str(sol) + r"cm" question = r"a triangle has angles A, B and C, where angle A is " + str( a) + r"°, angle B is " + str( b) + r"° and the length of side AB is " + str( z) + r"cm. Find the perimeter of the triangle: " alternatives = coursesFunctionsBll.multipleOptions([sol], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0]) + r"cm") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def coinProblem(): try: f = random.randint(6, 9) e = random.randint(2, 5) ne = random.randint(2, 5) sol1 = round( math.factorial(f) / (math.factorial(e) * math.factorial(f - e) * (2**f)), 4) sol2 = 0 for i in range(ne): sol2 += math.factorial(f) / (math.factorial(i) * math.factorial(f - i) * (2**f)) sol2 = round(sol2, 4) solution = r"a) " + str(sol1) + r" b)" + str(sol2) question = r"from flipping a fair coin " + str( f) + r" times, a) what is the probability of get exactly " + str( e) + r" heads b) less than " + str(ne) + r" heads: " alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"a) " + str(alternatives[ta][0]) + r" b)" + str(alternatives[ta][1])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def pascalVarianceProblem(): try: r = random.randint(6, 15) p = random.randint(1, 9) / 10 q = 1 - p sol1 = round(r / p, 4) sol2 = round(r * q / (p**2), 4) sol3 = round(sol2**(1 / 2), 4) solution = r"Expected value=" + str(sol1) + r", variance=" + str( sol2) + r", standard deviation=" + str(sol3) + r"" question = r"Probability for a soccer player to score in a match is " + str( round(p * 100)) + r"\%. To arrive to " + str( r) + r" matches scoring, find a) \mu b) \sigma^{2} c) \sigma: " alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2, sol3], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"Expected value=" + str(alternatives[ta][0]) + r", variance=" + str(alternatives[ta][1]) + r", standard deviation=" + str(alternatives[ta][2]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def balloonFlyProblem(): try: z = random.randint(1, 10)/100 angleChange = z*math.pi a = random.randint(2, 10) angle = math.pi/a d = random.randint(100, 1000) dh = round(((1/math.cos(angle))**2)*angleChange*d,4) h = round(math.tan(angle)*d,4) solution = r"h="+str(h)+r"mt, \frac{dh}{dt}=\frac{"+str(dh)+r"mt}{m}" question=r"A person is watching a balloon, placed in front at "+str(d)+r"mt of distance. Suddenly the balloon begins to fly vertically. The angle between the person and the balloon changes at a constant speed of \frac{"+str(z)+r"\pi}{m}. When angle is \frac{\pi}{"+str(a)+r"}, find height of the balloon and its height change per minute: " alternatives = coursesFunctionsBll.multipleOptions([h, dh],5) tempAlternatives =[] for m in range(5): tempAlternatives.append(r"h="+str(alternatives[m][0])+r"mt, \frac{dh}{dt}=\frac{"+str(alternatives[m][1])+r"mt}{m}") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def geometryVarianceProblem(): try: p = random.randint(11, 50) / 100 q = 1 - p sol1 = round(1 / p, 4) sol2 = round(q / (p**2), 4) sol3 = round(sol2**(1 / 2), 4) solution = r"Expected value=" + str(sol1) + r", variance=" + str( sol2) + r", standard deviation=" + str(sol3) + r"" question = r"The probability to call a station radio and get a response is " + str( round(p * 100)) + r"\%. Find a) \mu b) \sigma^{2} c) \sigma: " alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2, sol3], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"Expected value=" + str(alternatives[ta][0]) + r", variance=" + str(alternatives[ta][1]) + r", standard deviation=" + str(alternatives[ta][2]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def optimizationProblem(): try: a = random.randint(10,100) b = random.randint(1,10) a1=-2*b b1=-8*(b**2) c1=2*a*b x1=(-b1+math.sqrt((b1**2)-(4*a1*c1)))/(2*a1) x2=(-b1-math.sqrt((b1**2)-(4*a1*c1)))/(2*a1) xMax= x1 if x1>x2 else x2 yMax = (a-(2*b*xMax))/(xMax+(2*b)) solution= round(xMax*yMax*b,4) question="A box without top use a total of "+str(a)+"cm^2 of material. Which is the volume if box height is "+str(b)+"cm and dimensions of the box allows the biggest volume possible: " alternatives = coursesFunctionsBll.multipleOptions([solution],5) tempAlternatives =[] for y1 in range(5): tempAlternatives.append(str(alternatives[y1][0])) options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def errorProportionProblem(): try: m = random.randint(100, 150) p = random.randint(200, 1000) a = random.randint(10, 90) / 100 sol1 = round(((a * (1 - a)) / (m))**(1 / 2), 4) sol2 = round((((a * (1 - a)) / (m)) * ((p - m) / (p - 1)))**(1 / 2), 4) solution = r"a) " + str(sol1) + r", b) " + str(sol2) + r"" question = r'In a car factory the ' + str( round(a * 100) ) + r'\% of productions has mechanical problems. If you make a sample of ' + str( m ) + r' cars a) find the standard error of proportion supposing factory made infinite cars (or it is a sample with replacement) b) standard error of proportion if total cars made are ' + str( p) + r': ' alternatives = coursesFunctionsBll.multipleOptions([sol1, sol2], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"a) " + str(alternatives[ta][0]) + r", b) " + str(alternatives[ta][1]) + r"") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def newtonCoolingProblem(): try: tempIni = random.randint(76,100) tempFin = random.randint(51,75) tempFin2 = random.randint(26,50) tempEnvi = random.randint(1,25) t= random.randint(2,30) d = random.randint(2,20) t = random.randint(2,20) k = math.log((tempFin-tempEnvi)/(tempIni-tempEnvi))/t sol=round(math.log((tempFin2-tempEnvi)/(tempIni-tempEnvi))/k,4) sol2=round(k*(tempIni-tempEnvi)*(math.e**(k*sol)),4) question = "A drink with an initial temperature of "+str(tempIni)+"°F is put on a fridge with a environment temperature equals to "+str(tempEnvi)+"°F. After "+str(t)+" minutes the drink's temperature is "+str(tempFin)+"°F. How many minutes will be need until drink has cooled to "+str(tempFin2)+"°F and which will be the rate of change (F/m) in that moment? use the newton law of cooling: " solution= "time="+str(sol)+"m and rate change="+str(sol2)+"°F/m" alternatives = coursesFunctionsBll.multipleOptions([sol,sol2],5) tempAlternatives =[] for y in range(5): tempAlternatives.append("time="+str(alternatives[y][0])+"m and rate change="+str(alternatives[y][1])+"°F/m") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def positionProblem(): try: a = random.randint(2,20) b = random.randint(2,20) c = random.randint(2,20) d = random.randint(2,20) t = random.randint(2,20) a1= a*3 b1=b*2 a2=a1*2 velocity= (a1*t*t)+(b1*t)+c acceleration= (a2*t)+b1 question = "A particle position (through time) is given by the function x="+str(a)+"t^3 + "+str(b)+"t^2 + "+str(c)+"t + "+str(d)+". Finds velocity and acceleration when t="+str(t)+"s:" solution= "velocity="+str(velocity)+"m/s and acceleration="+str(acceleration)+"m/s^2" alternatives = coursesFunctionsBll.multipleOptions([velocity, acceleration],5) tempAlternatives =[] for y in range(5): tempAlternatives.append("velocity="+str(alternatives[y][0])+"m/s and acceleration="+str(alternatives[y][1])+"m/s^2") options =json.loads(json.dumps({'a':tempAlternatives[0], 'b':tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4]})) jsonResponse = json.dumps({"question":coursesFunctionsBll.replaceSpace(question), "solution":coursesFunctionsBll.replaceSpace(solution), "options":coursesFunctionsBll.replaceOptions(options)}) return [jsonResponse] except Exception as er: return er
def pyramidRegularPolygonProblem(): try: x = random.randint(10, 20) s = random.randint(3, 10) h = random.randint(10, 20) angle = (s - 2) * 180 / (s * 2) op = (x / 2) * math.tan(angle * math.pi / 180) base = op * x * s / 2 volume = round((1 / 3) * base * h, 4) solution = r"" + str(volume) question = r"For a pyramid where base is a regular polygon of " + str( s) + " sides where each side have a length of " + str( x) + r",and the pyramid height is " + str( h) + r", find the volume of the pyramid: " alternatives = coursesFunctionsBll.multipleOptions([volume], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"" + str(alternatives[ta][0])) options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er
def orthoCenterProblem(): try: point = [] while True: point = [ [ random.randint(1, 10) * (random.randint(0, 1) * 2 - 1), random.randint(1, 10) * (random.randint(0, 1) * 2 - 1) ], [ random.randint(1, 10) * (random.randint(0, 1) * 2 - 1), random.randint(1, 10) * (random.randint(0, 1) * 2 - 1) ], [ random.randint(1, 10) * (random.randint(0, 1) * 2 - 1), random.randint(1, 10) * (random.randint(0, 1) * 2 - 1) ] ] if (point[0][0] != point[1][0] and point[0][1] != point[1][1] ) and (point[0][0] != point[2][0] and point[0][1] != point[2][1]) and (point[1][0] != point[2][0] and point[1][1] != point[2][1]): if ((point[0][1] - point[1][1]) / (point[0][0] - point[1][0])) != ( (point[0][1] - point[2][1]) / (point[0][0] - point[2][0])): break m1 = -1 / ((point[0][1] - point[1][1]) / (point[0][0] - point[1][0])) c1 = point[2][1] - (m1 * point[2][0]) m2 = -1 / ((point[0][1] - point[2][1]) / (point[0][0] - point[2][0])) c2 = point[1][1] - (m2 * point[1][0]) x = round((c2 - c1) / (m1 - m2), 4) y = round((m2 * x) + c2, 4) solution = r"(" + str(x) + r"," + str(y) + r")" question = r"Find the orthocenter of triangle with vertices at (" + str( point[0][0]) + r"," + str(point[0][1]) + r") (" + str( point[1][0]) + r"," + str(point[1][1]) + r") (" + str( point[2][0]) + r"," + str(point[2][1]) + r"): " alternatives = coursesFunctionsBll.multipleOptions([x, y], 5) tempAlternatives = [] for ta in range(5): tempAlternatives.append(r"(" + str(alternatives[ta][0]) + r"," + str(alternatives[ta][1]) + r")") options = json.loads( json.dumps({ 'a': tempAlternatives[0], 'b': tempAlternatives[1], 'c': tempAlternatives[2], 'd': tempAlternatives[3], 'e': tempAlternatives[4] })) jsonResponse = json.dumps({ "question": coursesFunctionsBll.replaceSpace(question), "solution": coursesFunctionsBll.replaceSpace(solution), "options": coursesFunctionsBll.replaceOptions(options) }) return [jsonResponse] except Exception as er: return er