What's wrong with this program?

Question

def short_distance(origins,(x,y),gap):
for (i,j) in origins.spilt(“ ”):
 h=[]
   h.append(float(math.sqrt ((i-x)*(i-x)+(j-y)*(j-y))))
for n in h:
if not gap < n:
 print 0
if gap < n :
 print n 

Answer 1

I would write the code more like this. If you run the code, it will report any failing tests (of which there are none).

import math

def short_distance(origins, point, gap):
    """
    Describe origins, point, and gap are and what the 
    expected outcome is.

    Then provide an example that tests the code
    >>> short_distance('1,2 3,4', (5,6), 1.5)
    5.65685424949
    2.82842712475
    """
    origins = parse_origins(origins)
    distance_to_point = lambda point2: point_distance(point, point2)
    # what's a better name for h?
    h = map(distance_to_point, origins)
    report(h, gap)

def report(h, gap):
    """
    Take the results of the distances and report on them
    """
    for distance in h:
        if not (gap < distance):
            print 0
        else:
            print distance

def point_distance(p1, p2):
    """
    Calculate the distance between two points

    >>> point_distance((0,0), (1,0))
    1.0

    more than one test here would be good
    """
    x1, y1 = p1
    x2, y2 = p2
    return math.sqrt((x1-x2)**2 + (y1-y2)**2)

def parse_origins(origin_string):
    """
    Parse an origins string.
    >>> parse_origins('1,2 3,4')
    ((1.0, 2.0), (3.0, 4.0))
    """
    points = origin_string.split(' ')
    return tuple(map(parse_point, points))

def parse_point(point_string):
    """
    Take a string like 1,2 and return a tuple of the numbers
    in that string.

    >>> parse_point('1,2.0')
    (1.0, 2.0)
    """
    return tuple(map(float, point_string.split(',')))

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    test()

Answer 2

• the indentation is wrong; the for loops should be indented more than the def
• typo: origins.spilt(" ") should probably be origins.split(" ")

Answer 3

Your code is perhaps for finding points from origins that are close to (x, y). There is a lot of errors in it:

1. Indention is wrong.
2. split() method is spelled wrong.
3. split() method returns flat list while you are expecting a list of pairs.

The former two are easy to fix. Without knowledge of origins string format I can't be sure what dou you wish ere. See this question for solutions on how to convert flat list to list of pairs.

Also note that if statement has else clause, so you can write:

if gap < n:
    print n
else:
    print 0

Answer 4

1. You'll need to import math
2. The indentation is wrong
3. If Origins is a string like '1,1 2,2 3,3', Origins.split(" ") will give you a list of strings ["1,1", "2,2", "3,3"]. You will need to do some extra work to be able to use it with the for loop for (i,j) in ... You need a list of tuples like [(1,1), (2,2), (3,3)]
4. math.sqrt already returns a float, so you can leave that out

Answer 5

Here's the code:

from math import sqrt
def short_distance(origins,(x,y),gap):
    def distance(i, j):
        ix, iy = i - x, j - y
        return sqrt (ix*ix + iy*iy)
    all_distances = (distance(float(i), float(j)) for (i,j) in origins)
    for n in all_distances:
        print (0 if gap >= n else n)

And then use it like this:

>>> origin = (0, 0)
>>> points = [(1, 1), (2, 1), (1, 2), (2, 2)]
>>> gap = 1.5
>>> short_distance(points, origin, gap)
0
2.2360679775
2.2360679775
2.82842712475

My best guess is this does what you want.