The image shows how we can obtain the Harmonic Conjugated Point of three aligned points A, B, C.

- We choose any point L, that is not in the line with A, B and C. We form the triangle ABL

- Then we draw a line from point C that intersects the sides of this triangle at points M and N respectively.

- We draw the diagonals of the quadrilateral ABNM; they are AN and BM and they intersect at point K

- We unit, with a line L and K, and this line intersects the line of points A, B and C at point D

The point D is named the Conjugated Harmonic Point of the points A, B, C.
You can get more knowledge related with this point at: (https://en.wikipedia.org/wiki/Projective_harmonic_conjugate)

If we apply the theorems of Ceva (https://en.wikipedia.org/wiki/Ceva%27s_theorem)
and Menelaus (https://en.wikipedia.org/wiki/Menelaus%27_theorem) we will have this formula:



AC, in the above formula is the length of the segment of points A to C in this direction and its value is:

```AC = xA - xC```

Transform the above formula using the coordinates ```xA, xB, xC and xD```

The task is to create a function ```harmon_pointTrip()```, that receives three arguments, the coordinates of points xA, xB and xC, with values such that : ```xA < xB < xC```, this function should output the coordinates of point D for each given triplet, such that

`xA < xD < xB < xC`, or to be clearer

let's see some cases:
```python
harmon_pointTrip(xA, xB, xC) ------> xD # the result should be expressed up to four decimals (rounded result)
harmon_pointTrip(2, 10, 20) -----> 7.1429 # (2 < 7.1429 < 10 < 20, satisfies the constraint)
harmon_pointTrip(3, 9, 18) -----> 6.75
```


Enjoy it and happy coding!!

Difficulty: introductory

Starter code:

def harmon_pointTrip(xA, xB, xC):
	

Solutions:
def harmon_pointTrip(xA, xB, xC):
    a, b, c = list(map(float, [xA, xB, xC]))
    # Yay for algebra!
    d = ((a * c) + (b * c) - (2 * a * b)) / (2 * c - a - b)
    return round(d, 4)


def harmon_pointTrip(xA, xB, xC):
    return round((xA*xC + xB*xC - 2*xA*xB) / (2*xC - xA - xB), 4)

def harmon_pointTrip(a, b, c):
    return round((a*c + b*c - 2*a*b) / (2*c - a - b), 4)

def harmon_pointTrip(a, b, c):
    return round(float(2 * a * b - c * b - a * c) / (a - 2 * c + b), 4)

def harmon_pointTrip(a, b, c):
    return round((2.0*a*b - b*c - a*c) / (a + b - 2*c), 4)

harmon_pointTrip=lambda a,b,c:round(((c-a)*b+(c-b)*a)/(1.0*(c-b)+(c-a)),4)

def harmon_pointTrip(xA, xB, xC):
    return round((xA * xC + xB * xC - 2 * xA * xB) / float(2 * xC - xA - xB), 4)

def harmon_pointTrip(xA, xB, xC):
 n=((-1)*(xB-xC))/((xA-xC)*1.0)
 xD=((n*xA)-xB)/(n-1)
 return round(xD,4)

harmon_pointTrip=lambda a,b,c:round(1.*(b*(c-a)+a*(c-b))/((c-a)+(c-b)),4)

def harmon_pointTrip(xA, xB, xC): #coordinates of points A, B and C such that
    return round((2*xA*xB-xC*(xA+xB))/(xA+xB-2*xC),4)