算法测试系列：Classify the Trade

Classify the Trade

Classify new trades based on their similarity to old trades.

Every trade has 3 features: profit, risk, and latency.

You have a list of old trades. Every old trade has been labeled with a color.

You have a list of new trades. New trades are unlabeled.

Your task is to create an algorithm that uses the old trades to predict the labels of new trades.

Input Format

• A list of feature vectors, representing the old trades.
• A list of labels, corresponding to each of the old trades.
• A list of feature vectors, representing the new trades.

Constraints

Features are floats in the interval [0, 100].

Labels are strings.

Classes may be imbalanced (e.g. ‘red’ trades may greatly outnumber ‘green’ trades).

Classes may not be linearly separable in 3 dimensions.

The data set is small:

• The number of old trades is less than 100.
• The number of new trades is less than 10.

def classify(trades,labels,new_trades):
     green_number = 0
     red_number = 0
     for i in range(labels.__len__()):
          if(labels[i] == "green"):
               green_number = green_number + 1
          else:
               red_number = red_number + 1

     count = 0
     
     profit_green = 0.0
     risk_green = 0.0
     latency_green = 0.0
     
     profit_red = 0.0
     risk_red = 0.0
     latency_red = 0.0
     
     for j in range(trades.__len__()):
          if(count < green_number):
               count = count + 1
               profit_green = profit_green + trades[j][0]
               risk_green = risk_green + trades[j][1]
               latency_green = latency_green + trades[j][2]
          else:
               profit_red = profit_red + trades[j][0]
               risk_red = risk_red + trades[j][1]
               latency_red = latency_red + trades[j][2]


     profit_green = profit_green / green_number
     risk_green = risk_green / green_number
     latency_green = latency_green/ green_number
     
     profit_red = profit_red / red_number
     risk_red = risk_red / red_number
     latency_red = latency_red / red_number
     
     result = []
     
     for k in range(new_trades.__len__()):
          if(abs(new_trades[k][0] - profit_green) < abs(new_trades[k][0] - profit_red)):
               result.append("green")
          elif(abs(new_trades[k][0] - profit_green) > abs(new_trades[k][0] - profit_red)):
               result.append("red")
          else:
               if(abs(new_trades[k][0] - risk_green) < abs(new_trades[k][0] - risk_red)):
                    result.append("green")
               elif(abs(new_trades[k][0] - risk_green) > abs(new_trades[k][0] - risk_red)):
                    result.append("red")
               else:
                    if(abs(new_trades[k][0] - latency_green) < abs(new_trades[k][0] - latency_red)):
                         result.append("green")
                    else:
                         result.append("red")
     return result