using System;
using System.Collections;
using System.IO;

public class cogmod {	

	public static void Main(string[] argv) {
		data_point[] training_data = read(argv[0]);
		data_point[] test_data = read(argv[1]);

		double[] weights = new double[3];
		weights[0] = 0.3;
		weights[1] = 0.6;
		weights[2] = 0.5;

		double[,] res = calc(training_data, test_data, weights);

		for (int i=0; i<res.Length; i++) {
			Console.WriteLine("{0} - {1}", res[i,0], res[i,1]);
		}
	}

	static data_point[] read(string path) {
		ArrayList l = new ArrayList();
		StreamReader sr = new StreamReader(path);
		string line = sr.ReadLine();
		while (line != null) {
			if (string.Empty == line.Trim()) continue;
			string[] f = line.Split(',');
			l.Add(new data_point(f));
			line = sr.ReadLine();
		}
		sr.Close();
		return (data_point[])l.ToArray(typeof(data_point));
	}

	static double[,] calc(data_point[] training_data,
												data_point[] test_data,
												double[] weights) {
		double[,] ret = new double[test_data.Length,2];

		for (int i=0; i<test_data.Length; i++) {
			data_point p = test_data[i];
			if (!p.is_conjunction()) {
				ret[i, 0] = calc_single_membership(p, p.category[0], training_data,
																					 weights);
				ret[i, 1] = p.score;
			} else {
			}
		}

		return ret;
	}

	static double calc_single_membership(data_point p,
																			int category,
																			data_point[] training_data,
																			double[] weights) {
		double sim = 0;
		double total = 0;

		foreach (data_point t in training_data) {
			if (!t.is_in_category(category)) {
				continue;
			}
			double v = t.sim(p, weights);
			sim += v;
			total += v;
		}

		return sim/total;
	}
	
}


public class data_point {
	public char[] values;
	public int[] category;
	public double score;

	/**
	 * Dim 1, Dim 2, Dim 3
	 */
	public data_point(string[] fields) {
		if (fields.Length != 4 && fields.Length != 5) {
			throw new Exception(string.Format("Wrong field count {0}", fields.Length));
		}

		values = new char[3];
		values[0] = c(fields[0]);
		values[1] = c(fields[1]);
		values[2] = c(fields[2]);

		category = parse_category(fields[3]);

		if (fields.Length == 5) {
			score = Convert.ToDouble(fields[4]);
		}
	}

	static char c(string s) {
		s = s.Trim();
		if (s.Length > 1) {
			Console.WriteLine("Found {0} when expected single character.", s);
			throw new Exception();
		}
		return s[0];
	}
	
	/**
	 * category x
	 * categories x and y
	 */
	int[] parse_category(string s) {
		int[] category;
		string[] t = s.Split(' ');
		if (t[0] == "category") {
			category = new int[1];
			category[0] = c(t[1]) - 'A';
		} else if (t[0] == "categories") {
			category = new int[2];
			category[0] = c(t[1]) - 'A';
			category[1] = c(t[3]) - 'A';
		} else {
			throw new Exception();
		}
		return category;
	}

	public bool is_in_category(int c) {
		for (int i=0; i<category.Length; i++) {
			if (i == c) {
				return true;
			}
		}
		return false;
	}

	public bool is_conjunction() {
		return category.Length == 2;
	}

	public double sim(data_point p, double[] weights) {
		double sim = 0;

		for (int i=0; i<values.Length; i++) {
			if (p.values[i] != values[i]) {
				sim *= weights[i];
			}
		}

		return sim;
	}
}