public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new FileReader(args[0]));
int tIndex = 0;
int pIndex = 0;
// This will probably change soon (name and implementation)
NgramParser tnp = new NgramParser(args[1]);
ArrayList<String> triplet = tnp.getTriplet();
ArrayList<String> polarity = tnp.getPolarity();
FileWriter sw = new FileWriter(args[2]);
String line = null;
while (((line = br.readLine()) != null)
&& (tIndex < triplet.size())
&& (pIndex < polarity.size())) {
if (line.matches("^[\\d]*:")) {
// System.out.println(line);
sw.write(line + "\n");
} else {
Scanner sc = new Scanner(line);
String trip = sc.findInLine(Pattern.compile("[a-zA-Z]+#[a-z]+[#]?[0-9]*"));
// if (trip != null && trip.equals(triplet.get(tIndex))) {
System.out.println(trip);
if (trip != null && !trip.toLowerCase().contains("no#cl")) {
// System.out.println(triplet.get(tIndex) + ":" +polarity.get(pIndex));
String pol = polarity.get(pIndex);
sw.write(line + " " + pol + "\n");
sc.close();
tIndex++;
pIndex++;
} else {
String pol = "neg";
sw.write("no#a#1" + " " + pol + "\n");
sc.close();
}
}
// sw.flush();
}
sw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* This function evaluates current Lisp expression in inputExpr It return result of the expression
*
* <p>The algorithm:
*
* <p>Step 1 Scan the tokens in the string. Step 2 If you see an operand, push operand object onto
* the thisExprStack Step 3 If you see "(", next token should be an operator Step 4 If you see an
* operator, push operator object onto the thisExprStack Step 5 If you see ")" // steps in
* evaluateCurrentOperation() : Step 6 Pop operands and push them onto thisOpStack until you find
* an operator Step 7 Apply the operator to the operands on thisOpStack Step 8 Push the result
* into thisExprStack Step 9 If you run out of tokens, the value on the top of thisExprStack is is
* the result of the expression.
*/
public double evaluate() {
Scanner inputExprScanner = new Scanner(inputExpr);
// Use zero or more white space as delimiter,
// which breaks the string into single character tokens
inputExprScanner = inputExprScanner.useDelimiter("\\s*");
while (inputExprScanner.hasNext()) {
if (inputExprScanner.hasNextInt()) {
String dataString = inputExprScanner.findInLine("\\d+");
thisExprStack.push(new Double(dataString));
} else {
String aToken = inputExprScanner.next();
char item = aToken.charAt(0);
String nextToken;
char nextItem;
switch (item) {
case '(':
nextToken = inputExprScanner.next();
nextItem = nextToken.charAt(0);
if (nextItem == '+' || nextItem == '-' || nextItem == '*' || nextItem == '/') {
thisExprStack.push(nextItem);
}
break;
case ')':
try {
evaluateCurrentOperation();
} catch (LispExprEvaluatorException e) {
System.out.println("Error: " + e);
} catch (ArithmeticException ae) {
System.out.println("Error: " + ae);
}
break;
default: // error
throw new LispExprEvaluatorException(item + " is not a legal expression operator");
} // end switch
} // end else
} // end while
double result = (Double) thisExprStack.pop();
return result;
}
public static void main(String[] args) {
int[] arr = new int[N];
int[] dp = new int[Q];
int a, b, c, q, k, m, n, i, j, max;
boolean g;
Scanner sc = new Scanner(System.in);
while (true) {
q = (int) (sc.nextDouble() * G);
if (q >= Q) {
while (true) ;
}
n = sc.nextInt();
if (n == 0) {
break;
}
k = 0;
for (i = 0; i < n; ++i) {
m = sc.nextInt();
a = b = c = 0;
g = true;
for (j = 0; j < m; ++j) {
switch (sc.findInLine("[A-Z]:").charAt(0)) {
case 'A':
a += (int) (sc.nextDouble() * G);
if (a > S) {
g = false;
}
break;
case 'B':
b += (int) (sc.nextDouble() * G);
if (b > S) {
g = false;
}
break;
case 'C':
c += (int) (sc.nextDouble() * G);
if (c > S) {
g = false;
}
break;
default:
sc.nextDouble();
g = false;
break;
}
}
if (g && a + b + c <= T) {
arr[k++] = a + b + c;
}
}
for (i = 1; i <= q; ++i) {
dp[i] = 0;
}
dp[0] = 1;
max = 0;
for (i = 0; i < k; ++i) {
for (j = q; j >= arr[i]; --j) {
if (dp[j - arr[i]] == 1) {
dp[j] = 1;
max = Math.max(max, j);
}
}
}
System.out.printf("%.2f%n", (double) max / G);
}
}
public MedlineGenerator(String seed) {
String[] fields = seed.split("\\r?\\n");
for (String fieldData : fields) {
if (fieldData.length() < 4) {
continue;
}
final Scanner scanner = new Scanner(fieldData);
scanner.useDelimiter("\\t");
String fieldName = scanner.next();
scanner.useDelimiter("; ");
scanner.findInLine("\t");
MedlineFieldDefinition defn = MedlineFieldDefinitions.getDefinition(fieldName);
MedlineFieldDefinition.FieldType fieldType =
defn != null ? defn.type : MedlineFieldDefinition.FieldType.SINGLE_TEXT_VALUE;
BaseFieldModel fieldModel = null;
Iterable<Pair<Long, String>> scannerIterator =
new Iterable<Pair<Long, String>>() {
@Override
public Iterator<Pair<Long, String>> iterator() {
return new Iterator<Pair<Long, String>>() {
@Override
public boolean hasNext() {
return scanner.hasNext();
}
@Override
public Pair<Long, String> next() {
String value = "";
String[] data;
do {
String next = scanner.next();
data = next.split("\\t");
if (data.length > 2) {
throw new IllegalStateException(
String.format("Cannot parse word: '%s'", value + next));
}
value += data[0];
} while (data.length < 2);
return new Pair<>(Long.parseLong(data[1]), value);
}
@Override
public void remove() {
throw new NotImplementedException();
}
};
}
};
switch (fieldType) {
case ARRAY_TEXT_VALUES:
case SINGLE_TEXT_VALUE:
case WORDS:
SimpleFieldModel model = new SimpleFieldModel(fieldName, fieldType);
for (Pair<Long, String> pair : scannerIterator) {
model.addValue(pair.getKey(), pair.getValue());
}
fieldModel = model;
break;
case SINGLE_OBJECT_VALUE:
ObjectFieldModel objectModel = new ObjectFieldModel(fieldName);
for (Pair<Long, String> pair : scannerIterator) {
long weight = pair.getKey();
String propertyData = pair.getValue();
int firstColonIndex = propertyData.indexOf(':');
String propertyName = propertyData.substring(0, firstColonIndex);
String propertyValue = propertyData.substring(firstColonIndex);
objectModel.addValue(propertyName, weight, propertyValue);
}
fieldModel = objectModel;
break;
}
fieldModels.put(fieldName, fieldModel);
}
}