"Point reflection" or "point symmetry" is a basic concept in geometry where a given point, P, at a given position relative to a mid-point, Q has a corresponding point, P1, which is the same distance from Q but in the opposite direction.

## Task

Given two points P and Q, output the symmetric point of point P about Q.
Each argument is a two-element array of integers representing the point's X and Y coordinates.  Output should be in the same format, giving the X and Y coordinates of point P1.  You do not have to validate the input.

This kata was inspired by the Hackerrank challenge [Find Point](https://www.hackerrank.com/challenges/find-point)

Difficulty: introductory

Starter code:

def symmetric_point(p, q):
	

Solutions:
def symmetric_point(p, q):
    return [2*q[0] - p[0], 2*q[1] - p[1]]

symmetric_point = lambda p, q: [2 * b - a for a, b in zip(p, q)]

def symmetric_point(p, q):
    # your code here
    p1x = (q[0] - p[0]) + q[0]
    p1y = (q[1] - p[1]) + q[1]
    return [p1x, p1y]

symmetric_point = lambda p,q: [2*q[0] - p[0], 2*q[1] - p[1]]

def symmetric_point(p, q):
    #this supposed to be a programing challenge not math
    return [2*q[0]-p[0], 2*q[1]-p[1]]

def symmetric_point(p, q):
    # your code here
    return [a*2-b for a,b in zip(q,p)]

def symmetric_point(p, q):
    return list(b * 2 - a for a, b in zip(p, q))

def symmetric_point(p, q):
    dx = q[0] - p[0]
    dy = q[1] - p[1]
    return [q[0]+dx, q[1]+dy]

def symmetric_point(p, q):
    # your code here
    return [q[0] + q[0]-p[0], q[1] + q[1] - p[1]]

def symmetric_point(p, q):
    return [2 * q[i] - p[i] for i in range(2)]

def symmetric_point(p, center):
    px, py = p
    cx, cy = center
    return [cx - (px - cx), cy - (py - cy)]


def symmetric_point(p, q):
    return [2 * q[i] - p[i] for i in range(0,len(p))]

def symmetric_point(p, q):
    return [q[i]*2-p[i] for i in range(2)]

from typing import List

def symmetric_point(p: List[int], q: List[int]) -> List[int]:
    """ Get the symmetric point of point P about Q. """
    return [2 * q[0] - p[0], 2 * q[1] - p[1]]

def symmetric_point(p, q):
    result = [p[0],q[0]]
    if(p[0] > q[0]):
        result[0] = fromRightToLeft(p[0],q[0])
    else:
        result[0] = fromLeftToRight(p[0],q[0])
    if(p[1] > q[1]):
        result[1] = fromUpToDown(p[1],q[1])
    else:
        result[1] = fromDownToUp(p[1],q[1])
    return result
def fromRightToLeft(p,q):
    return q-abs(p-q)
def fromLeftToRight(p,q):
    return q+abs(p-q)
def fromUpToDown(p,q):
    return q-abs(p-q)
def fromDownToUp(p,q):
    return q+abs(p-q)

from operator import sub
def symmetric_point(p, q):
    qp = list(map(sub, p, q))
    return list(map(sub, q, qp))

def symmetric_point(p, q):
    return [b + (b - a) for a, b in zip(p, q)]

def symmetric_point(p, q):
    return list(map(lambda a, b: a + b, q, list(map(lambda a, b: b - a, p, q))))


symmetric_point = lambda point, ref : [2 * ref[0] - point[0], 2 * ref[1] - point[1]]

import numpy as np
def symmetric_point(p, q):
    
    d = list(np.add(q,np.subtract(q,p)))
    
    return d

symmetric_point = lambda *a: [2 * q - p for p, q in zip(*a)]

def symmetric_point(p, q):
    p_1 = []
    dx = p[0] - q[0]
    dy = p[1] - q[1]
    p_1.append(q[0] - dx)
    p_1.append(q[1] - dy)
    return p_1

symmetric_point = lambda p, q: [2 * y -x for x, y in zip(p,q)]


def symmetric_point(p, q):
    return [2*q[0]-p[0], 2*q[1]-p[1]]
    
    
    
'''Given two points P and Q, output the symmetric point of point P about Q.
Each argument is a two-element array of integers representing the point's X and Y coordinates.
Output should be in the same format, giving the X and Y coordinates of point P1.'''

symmetric_point = lambda p, q: [r+r-s for s,r in zip(p, q)]

def symmetric_point(p, q):
    distance = q[0]-p[0], q[1]-p[1]
    symetric = [q[0] + distance[0], q[1] + distance[1]]
    return symetric

def symmetric_point(p, q):
    x1, y1 = p
    x2, y2 = q
    x3, y3 = (x2-x1)+x2, (y2-y1) +y2
    return [x3,y3]

def symmetric_point(p, q):
    try:
        (a,b),(c,d) = p,q
        x = c-a+c
        m = (d-b)/(c-a)
        i = b-m*a
        return [x,round(m*x+i)]
    except:
        return [0,0]

def symmetric_point(p, q):
    dist_x = p[0] - q[0]
    dist_y = p[1] - q[1]
    return [q[0]-dist_x, q[1]-dist_y]

def symmetric_point(p, q):
    distance_to_p_x = p[0] - q[0]
    distance_to_p_y = p[1] - q[1]
    
    return [q[0] - distance_to_p_x, q[1] - distance_to_p_y]

def symmetric_point(p, q):
    # your code her
    
    return [2*q[0]-p[0],2*q[1]-p[1]]


def symmetric_point(p, q):
    return [p[0] * - 1 + q[0] * 2, p[1] * - 1 + q[1] * 2]

def symmetric_point(p, q):
    pointslist = []
    difference = q[0] - p[0]
    newpoint = q[0] + difference
    difference2 = q[1] - p[1]
    newpoint2 = q[1] + difference2
    pointslist.append(newpoint)
    pointslist.append(newpoint2)
    return pointslist

def symmetric_point(p, q):
    x = [0,0]
    
    x[0] = 2 * q[0] - p[0]
    x[1] = 2 * q[1] - p[1]
    
    return x

def symmetric_point(p, q):
    x = []
    x.append(2 * q[0] - p[0])
    x.append(2 * q[1] - p[1])
    return x

def symmetric_point(p, q):
 
    difference = []


    zip_object = zip(p, q)
    for p, q in zip_object:
        difference.append(2*q-p)
   
    
    return(difference)

def symmetric_point(p, q):
    # q está siempre en medio

    return [(2*q[0]) - p[0], (2*q[1]) - p[1] ]

def symmetric_point(p, q):
    x = q[0] - p[0]
    x = q[0] + x
    y = q[1] - p[1]
    y = q[1] + y
    return [x,y]


def symmetric_point(p, q):
    d1=q[0]-p[0]
    d2=q[1]-p[1]
    return [q[0]+d1, q[1]+d2]

def symmetric_point(p, q):
    
    #Find the difference between midpoint Q and initial point P
    #Add this difference to the midpoint to find end point P1
    #Compatible with negative points
    
    p1x = q[0]+(q[0]-p[0])
    p1y = q[1]+(q[1]-p[1])
    return [p1x,p1y]

def symmetric_point(p, q):
    if q[0] > p[0]:
        x = q[0] + abs(q[0] - p[0])
    elif q[0] < p[0]:
        x = q[0] - abs(p[0] - q[0])
    else:
        x = p[0]
    if q[1] > p[1]:
        y = q[1] + abs(q[1] - p[1])
    elif q[1] < p[1]:
        y = q[1] - abs(p[1] - q[1])
    else:
        y = p[1]   
    return [x, y]

def symmetric_point(p, q):
    return [ 2*(-p[0]/2 + q[0]) , 2*(-p[1]/2 + q[1]) ]

def symmetric_point(p, q):
    new_point = [2*q[0] - p[0], 2*q[1] - p[1]]
    return new_point

def symmetric_point(p, q):

    distance = []
    for a, b in zip(p, q):
        if a > 0 and b > 0:
            distance.append(abs(a-b))
        elif a < 0 and b < 0:
            distance.append(abs(abs(a)-abs(b)))
        else:
            distance.append(abs(a)+abs(b))
            
    final_point = []
    for i, c, d in zip([0, 1],q, distance):
        if p[i] > 0 and q[i] > 0 or p[i] < 0 and q[i] < 0:
             if abs(p[i]) < abs(q[i]):
                 final_point.append(abs(c)+d)               
             else:
                 final_point.append(abs(c)-d)
        else:
           final_point.append(abs(c)+abs(d))
            
        
    return [x * -1 if q[i] < 0 else x for i, x in enumerate(final_point)]


def symmetric_point(p, q):
    # your code here
    r = [2*q[0]-p[0],2*q[1]-p[1]]
    return r

symmetric_point=lambda p,q:[-p[0]+2*q[0],-p[1]+2*q[1]]

def symmetric_point(p, q):
   return [2 * m - a for a, m in zip(p, q)]

def symmetric_point(p, q):
    a = q[0]-abs(p[0]-q[0]) if p[0] > q[0] else q[0]+(q[0]-p[0])
    b = q[1]-abs(p[1]-q[1]) if p[1] > q[1] else q[1]+(q[1]-p[1])
    return [a, b]

def symmetric_point(p, q):
    return [abs(p[i]-q[i]) + q[i] if p[i]<q[i] else q[i] - abs(p[i]-q[i]) for i in [0,1]]

def symmetric_point(p, q):
    # your code here
    x = q[0] - p[0]
    y = q[1] - p[1]
    return [q[0]+x,q[1]+y]

def symmetric_point(p, q):
    # your code here
    a = [0,0]
    a[0] = q[0] - abs(p[0]-q[0]) if (p[0] > q[0]) else q[0] + abs(p[0]-q[0])
    a[1] = q[1] - abs(p[1]-q[1]) if p[1] > q[1] else q[1] + abs(p[1]-q[1])    
    return a

def symmetric_point(p, q):
    # your code here
    q[0]+(q[0]-p[0])
    return [q[0]+(q[0]-p[0]),q[1]+(q[1]-p[1])]

def symmetric_point(p, q):
    # your code here
    [a,b] = p
    [c,d] = q
    p = c - a
    q = d - b
    return [c+p,d+q]

def symmetric_point(p, q):
    deltax = q[0]-p[0]
    deltay = q[1]-p[1]
    p1 = []
    p1.append(q[0]+deltax)
    p1.append(q[1]+deltay)
    return p1

def symmetric_point(p, q):
    q[0] += q[0] - p[0]
    q[1] += q[1] - p[1]
    return q

def symmetric_point(p, q):

    return([2 * a - b for a, b in zip(q, p)])
    
    # Most elegant way :))


def symmetric_point(p, q):

    return([2 * q[x] - p[x] for x in range(len(q))])

def symmetric_point(p, q):
    xnew = q[0] + (q[0] - p[0])
    ynew = q[1] + (q[1] - p[1])
    return [xnew, ynew]

import numpy as np
def symmetric_point(p, q):
    npp = np.array(p)
    npq = np.array(q)
    return (npq - npp + npq).tolist()

def symmetric_point(p, q):
    xp, yp, xq, yq = p+q
    xd, yd = abs(xp-xq), abs(yp-yq)
    return [xq+(xd if xp<xq else -xd), yq+(yd if yp<yq else -yd)]

def symmetric_point(p, q):
    # your code here
    return [(-1)*p[0]+2*q[0],(-1)*(p[1]+(-2)*q[1])]

def symmetric_point(p, q):
    # your code here
    return [
        q[0] + (q[0] - p[0]),   # x
        q[1] + (q[1] - p[1]),   # y
    ]

def symmetric_point(p, q):
    vertical_d = q[1] - p[1]
    horiz_d = q[0] - p[0]
    vertical_d = vertical_d * -1
    horiz_d = horiz_d * -1
    x = q[0] - horiz_d
    y = q[1] - vertical_d
    return [x,y]


def symmetric_point(p, q):
    px, py = p
    qx, qy = q
    xdist = px - qx
    ydist = py - qy
    return [qx - xdist, qy - ydist]

def symmetric_point(p, q):
    x1, y1 = p
    p1, p2 = q

    x2 = p1*2-x1
    y2 = p2*2-y1
    return [x2, y2]

def symmetric_point(p, q):
    x1, y1 = p
    x2, y2 = q
    return [x2 + x2 - x1, y2 + y2 - y1]

def symmetric_point(p, q):
    dx = q[0] - p[0]
    dy = q[1] - p[1]
    nx = dx + q[0]
    ny = dy + q[1]
    return [nx, ny]

def symmetric_point(p, q):
    # your code here
    return [2*q[i]-p[i] for i in range(len(p))]

def symmetric_point(p, q):
    xpos = p[0] < q[0]
    ypos = p[1] < q[1]
    xdiff = max(p[0], q[0]) - min(p[0], q[0])
    ydiff = max(p[1], q[1]) - min(p[1], q[1])
    if xpos: x = q[0] + xdiff
    if not xpos: x = q[0] - xdiff
    if ypos: y = q[1] + ydiff
    if not ypos: y = q[1] - ydiff
    return [x, y]

def symmetric_point(p, q):
    # your code here
    return [q[0]*2+p[0]*-1,(q[1]*2)+p[1]*-1]

def symmetric_point(p, q):
    arr = []
    for i in zip(p, q):
        x = i[1] - i[0]
        arr.append(i[1] + x)
    return arr    


def symmetric_point(p, q):
    c = int(q[0] + (q[0] - p[0]))   
    d = int(q[1] + (q[1] - p[1]))
    return [c, d]

def symmetric_point(p, q):
    # your code here

    r1 = -(p[0] - q[0] - q[0])
    r2 = -(p[1] - q[1] - q[1])
        
    return [r1, r2]

def symmetric_point(p, q):
    return [2 * x[1] - x[0] for x in zip (p, q)]

def symmetric_point(p, q):
    P1=[(2*q[0]- p[0]),(2*q[1]-p[1]) ]
    return P1

def symmetric_point(p, q):
    a, b, c, d = p + q
    return [c * 2 - a, d * 2 - b]

def symmetric_point(p, q):
    dist_x = q[0] - p[0]
    dist_y = q[1] - p[1]
    
    p1_x = q[0] + dist_x
    p2_x = q[1] + dist_y
    
    return [p1_x, p2_x]

def symmetric_point(p, q):
    x = p[0] - 2*q[0]
    y = p[1] - 2*q[1]
    return [-x,-y]    

def symmetric_point(p, q):
    r = []
    r.append(q[0] - p[0] + q[0])
    r.append(q[1] - p[1] + q[1])
    return r

def symmetric_point(p, q):
    return [2*q[0]-p[0],2*q[1]-p[1]]
#Solved on 26th Sept,2019 at 07:07 PM.


def symmetric_point(p, q):
    if p[0]>q[0]:
        x0=q[0]-(p[0]-q[0])
        if p[1]>q[1]:
            y0=q[1]-(p[1]-q[1])
            return [x0,y0]
        else:
            y0=q[1]-(p[1]-q[1])
            return [x0,y0]
    else:
        x0=q[0]-(p[0]-q[0])
        if p[1]>q[1]:
            y0=q[1]-(p[1]-q[1])
            return [x0,y0]
        else:
            y0=q[1]-(p[1]-q[1])
            return [x0,y0]

def symmetric_point(a, b):
    # your code here
    return [2*b[0]-a[0],2*b[1]-a[1]]

def symmetric_point(a,b):
    return([(-a[0]+2*b[0]),(-a[1]+2*b[1])])

def symmetric_point(p, q):
    reflected_x = q[0] + (q[0] - p[0])

    try:
        slope = (q[1] - p[1]) / (q[0] - p[0])
        b = p[1] - slope * p[0]

        reflected_y = slope * reflected_x + b

    except ZeroDivisionError:
        reflected_y = p[1]

    return [round(reflected_x), round(reflected_y)]


def symmetric_point(p, q):
    p2_x = p[0]+2*(q[0]-p[0])
    p2_y = p[1]+2*(q[1]-p[1])
    return [p2_x, p2_y]

def symmetric_point(p, q):
    a=q[0]-p[0]
    b=q[1]-p[1]
    c=a+q[0]
    d=b+q[1]
    return [c,d]  #I solved this Kata on  [1-Sept-2019] ^_^ [07:10 AM]...#Hussam'sCodingDiary

def symmetric_point(p, q):return[2*q[i]-p[i]for i in(0,1)]

def symmetric_point(p, q):return[q[i]+abs(p[i]-q[i])if p[i]<q[i]else q[i]-abs(p[i]-q[i])if p[i]>q[i]else q[i] for i in (0,1)]

def symmetric_point(p, q):
    y=2*q[1]-p[1]
    x=2*q[0]-p[0]
    return [x, y]

import operator
def symmetric_point(p, q):
    return [i*-1+j*2 for i,j in zip(p,q)]

def symmetric_point(p, q):
    x1=int(str(p).split(',')[0].split('[')[1])
    y1=int(str(p).split(',')[1].split(']')[0])
    x2=int(str(q).split(',')[0].split('[')[1])
    y2=int(str(q).split(',')[1].split(']')[0])
    
    return [x2+(x2-x1), y2+(y2-y1)]

def symmetric_point(p, q):
    delta_x, delta_y = abs(q[0] - p[0]), abs(q[1] - p[1])
    return [
        q[0] + delta_x if p[0] < q[0] else q[0] - delta_x
        , q[1] + delta_y if p[1] < q[1] else q[1] - delta_y
    ]

def symmetric_point(p, q):
    return [(-p[0]+2*q[0]),(-p[1]+2*q[1])]

def symmetric_point(p, q):

# the following equality must be satisfied
# q -p = q -p' 

  p_simx = q[0] -p[0]
  p_simy = q[1] -p[1]

  return [q[0] -(-p_simx), q[1] -(-p_simy)]


def symmetric_point(p, q):
    return [y+(y-x) for x, y in zip(p,q)]