Improved hints for pythagorean theorem.

1 files changed, 30 insertions, 61 deletions

diff --git a/python/problems/introduction/pythagorean_theorem/common.py b/python/problems/introduction/pythagorean_theorem/common.py
index 5f59588..800107e 100644
--- a/python/problems/introduction/pythagorean_theorem/common.py
+++ b/python/problems/introduction/pythagorean_theorem/common.py
@@ -1,73 +1,50 @@
 # coding=utf-8
 
-from python.util import has_token_sequence
+from python.util import has_token_sequence, string_almost_equal
 from server.hints import Hint, HintSequence
 
-id = 1000
+id = 188
 group = 'introduction'
 number = 2
 visible = True
 
 solution = '''\
 from math import *
-g = 10
-kot = float(input("Vnesi kot (v stopinjah): "))
-v = float(input("Vnesi hitrost (v m/s): "))
-kot_rad = kot * 2 * pi / 360
-razdalja = v ** 2 * sin(2 * kot_rad) / g
-print("Kroglo bo odneslo", razdalja, "metrov.")
+a = float(input("Prva kateta: "))
+b = float(input("Druga kateta: "))
+c = sqrt(a ** 2 + b ** 2)
+print("Hipotenuza trikotnika s stranicama", a, "in", b, "je", c)
 '''
 
 hint_type = {
     'plan': Hint('plan'),
-    'name_error': HintSequence('name_error'),
-    'unsupported_operand': HintSequence('unsupported_operand'),
-    'syntax_error' : HintSequence('syntax_error'),
-    'indentation_error': HintSequence('indentation_error'),
+    'name_error': HintSequence('name_error', 4),
+    'unsupported_operand': HintSequence('unsupported_operand', 4),
     'no_input_call' : Hint('no_input_call'),
-    'radians': HintSequence('radians'),
     'printing': Hint('printing'),
     'math_functions': Hint('math_functions')
 }
 
-
-def almostEqual(a, b, prec=1):
-    """ Compares values a and b using at most <code>prec</code> decimal values. """
-    return int(a*10**prec) == int(b*10**prec)
-
-def stringAlmostEqual(s, a):
-    """ Searches string s for a value that is almost equal to a.
-
-    Args:
-        s (str): string to search
-        a (float): value to find in string
-
-    Returns:
-        bool: True if successful, else False
-    """
-    for v in s.split():
-        try:
-            if almostEqual(float(v), a):
-                return True
-    return False 
-
 def test(python, code):
     # List of inputs: (expression to eval, stdin).
     test_in = [
-        (None, '45\n100\n'),
-        (None, '44\n100\n'),
-        (None, '46\n100\n'),
-        (None, '0\n100\n'),
-        (None, '90\n100\n'),
-        (None, '32\n747\n'),
+        (None, '3\n4\n'),
+        (None, '4\n3\n'),
+        (None, '12\n5\n'),
+        (None, '5\n12\n'),
+        (None, '5\n0\n'),
+        (None, '0\n5\n'),
+        (None, '1\n1\n'),
     ]
+
     test_out = [
-        '1000',
-        '999.39',
-        '999.39',
-        '0.0',
-        '0.0',
-        '50153.5'
+        5,
+        5,
+        13,
+        13,
+        5,
+        5,
+        1.414
     ]
 
     # List of outputs: (expression result, stdout, stderr, exception).
@@ -76,32 +53,24 @@ def test(python, code):
 
     n_correct = 0
     for output, correct in zip(outputs, test_out):
-        if stringAlmostEqual(output, correct):
+        if string_almost_equal(output, float(correct)):
             n_correct += 1
     return n_correct, len(test_in)
 
 def hint(python, code):
     # run one test first to see if there are any exceptions
-    test_in = [(None, '45\n')] 
+    test_in = [(None, '3\n4\n')]
     answer = python(code=code, inputs=test_in, timeout=1.0)
     exc = answer[0][3]
     # if have an exception!
     if exc:
         if 'NameError' in exc:
-            return [{'id':'name_error'}]
-        if 'unsupported operand' in exc:
-            return [{'id':'unsupported_operand'}]
-        if 'SyntaxError' in exc:
-            return [{'id':'syntax_error'}]
-        if 'IndentationError' in exc:
-            return [{'id':'indentation_error'}]
-
-    # if result if 893.996, angle is not converted to radians
-    if stringAlmostEqual(answer[0][1], 893.996):
-        return [{'id': 'radians'}]
+            return [{'id':'name_error', 'args': {'exception': exc}}]
+        if 'unsupported operand' in exc or 'TypeError' in exc:
+            return [{'id':'unsupported_operand', 'args': {'exception': exc}}]
 
     # show plan if student is lost
-    if not code or (not has_token_sequence(code, ['input']) and 
+    if len(code.strip()) < 5 or (not has_token_sequence(code, ['input']) and
                     (has_token_sequence(code, ['pi']) or 
                      has_token_sequence(code, ['sin']) or 
                      has_token_sequence(code, ['print']))):
@@ -116,7 +85,7 @@ def hint(python, code):
     # if tokens sqrt or ** are not in code, we have to teach them how to 
     # use math functions.
     if  (not has_token_sequence(code, ['sqrt']) or
-        not has_token_sequence(code, ['**']):
+        not has_token_sequence(code, ['**'])):
         return [{'id' : 'math_functions'}]
 
     # student is not using print function