Untitled

def valuation(reqArea, area, price):
    def removeOutliers(areaOut, priceOut):
        area_dict = {}
        duplicates = {}

        for a, p in zip(areaOut, priceOut):
            if a in area_dict:
                area_dict[a].append(p)
            else:
                area_dict[a] = [p]

        newArea = []
        newPrice = []

        for a, prices in area_dict.items():
            if len(prices) == 1:
                newArea.append(a)
                newPrice.append(prices[0])
            else:
                mean_price = sum(prices) / len(prices)
                std_price = np.std(prices)
                for p in prices:
                    if abs(p - mean_price) <= 3 * std_price:
                        newArea.append(a)
                        newPrice.append(p)
                    else:
                        if a in duplicates:
                            duplicates[a][0] += p
                            duplicates[a][1] += 1
                        else:
                            duplicates[a] = [p, 2]

        return newArea, newPrice, duplicates

    if reqArea in area:
        areasEqualed = [price[i] for i, a in enumerate(area) if a == reqArea]
        return int(sum(areasEqualed) / len(areasEqualed))

    uniques_Area = []
    uniques_Price = []
    nonUniques_Area = []
    nonUniques_Price = []

    for a, p in zip(area, price):
        if a not in uniques_Area and a not in nonUniques_Area:
            uniques_Area.append(a)
            uniques_Price.append(p)
        else:
            if a in uniques_Area:
                index = uniques_Area.index(a)
                nonUniques_Area.extend([a, a])
                nonUniques_Price.extend([p, uniques_Price[index]])
                uniques_Area.remove(a)
                uniques_Price.remove(uniques_Price[index])
            else:
                nonUniques_Area.append(a)
                nonUniques_Price.append(p)

    a, b, dp = removeOutliers(nonUniques_Area, nonUniques_Price)
    a += uniques_Area
    b += uniques_Price

    if min(a) < reqArea < max(a):
        y1 = max(i for i in a if i < reqArea)
        y2 = min(i for i in a if i > reqArea)
        y1_price = b[a.index(y1)]
        y2_price = b[a.index(y2)]

        if y1 in dp:
            dpVal = dp[y1]
            y1_price = (y1_price + dpVal[0]) / dpVal[1]

        if y2 in dp:
            dpVal = dp[y2]
            y2_price = (y2_price + dpVal[0]) / dpVal[1]

        ans = y1_price + ((y2_price - y1_price) * (reqArea - y1) / (y2 - y1))
        return int(round(ans))
    else:
        if max(a) < reqArea:
            y1 = max(a)
            y2 = max(i for i in a if i != y1)
            y1_price = b[a.index(y1)]
            y2_price = b[a.index(y2)]
        else:
            y1 = min(a)
            y2 = min(i for i in a if i != y1)
            y1_price = b[a.index(y1)]
            y2_price = b[a.index(y2)]

        if y1 in dp:
            dpVal = dp[y1]
            y1_price = (y1_price + dpVal[0]) / dpVal[1]

        if y2 in dp:
            dpVal = dp[y2]
            y2_price = (y2_price + dpVal[0]) / dpVal[1]

        ans = y2_price + (reqArea - y2) * ((y2_price - y1_price) / (y2 - y1))
        ans = min(max(ans, 1000), 1000000)
        return int(round(ans))