public static ArrayList<Symbol> toSymbols(String expression) {
ArrayList<Symbol> symbols = new ArrayList<>();
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (isBracket(c)) {
// bracket
symbols.add(new Symbol(c));
} else if (c == ',') {
symbols.add(new Symbol(c));
} else if (isOperator(c)) {
if (c == '-') {
if (i == 0) {
// must be first +/-, so add 0
symbols.add(new Symbol(BigDecimal.valueOf(0)));
symbols.add(new Symbol(c));
} else {
char previous = expression.charAt(i - 1);
if ((previous == ')') || isNumber(String.valueOf(previous))) {
// must be "minus"
// e.g. sin(3)-5, 100-5,
symbols.add(new Symbol(c));
} else if ((previous == '(') || (previous == ',')) {
// must be "negative"
// e.g. (-3+5)/2
symbols.add(new Symbol(BigDecimal.valueOf(0)));
symbols.add(new Symbol(c));
} else if ((previous == '*') || (previous == '/') || (previous == '^')) {
int end = Symbol.getNumberEndAt(i + 1, expression);
symbols.add(new Symbol(new BigDecimal(expression.substring(i, end))));
i = end - 1;
}
}
} else {
symbols.add(new Symbol(c));
}
} else if (Character.isLetter(c)) {
// function
int end = Symbol.getFunctionEndAt(i, expression);
symbols.add(new Symbol(expression.substring(i, end)));
i = end - 1;
} else if (Character.isDigit(c)) {
int end = Symbol.getNumberEndAt(i, expression);
String number = expression.substring(i, end);
symbols.add(new Symbol(new BigDecimal(number)));
i = end - 1;
}
}
return symbols;
}
/* return string representation of fault code */
public static String GetFaultString(long fault) {
if (fault > 0L) {
StringBuffer sb = new StringBuffer();
if ((fault & TYPE_MASK) == TYPE_J1708) {
// SID: "128/s123/1"
// PID: "128/123/1"
boolean active = DTOBDFault.DecodeActive(fault);
int mid = DTOBDFault.DecodeSystem(fault);
int fmi = DTOBDFault.DecodeFMI(fault);
if (!active) {
sb.append("[");
}
sb.append(mid); // MID
sb.append("/");
if (DTOBDFault.IsJ1708_SID(fault)) {
int sid = DTOBDFault.DecodePidSid(fault);
sb.append("s").append(sid); // SID "128/s123/1"
} else {
int pid = DTOBDFault.DecodePidSid(fault);
sb.append(pid); // PID "128/123/1"
}
sb.append("/");
sb.append(fmi); // FMI
if (!active) {
sb.append("]");
}
return sb.toString();
} else if ((fault & TYPE_MASK) == TYPE_J1939) {
// SPN: "128/1"
boolean active = DTOBDFault.DecodeActive(fault);
int spn = DTOBDFault.DecodeSystem(fault);
int fmi = DTOBDFault.DecodeFMI(fault);
sb.append(spn); // SPN
sb.append("/");
sb.append(fmi); // FMI
return sb.toString();
} else if ((fault & TYPE_MASK) == TYPE_OBDII) {
// DTC: "P0071" [was "024C"]
boolean active = DTOBDFault.DecodeActive(fault);
int sysChar = DTOBDFault.DecodeSystem(fault); // System: powertrain
int subSys = DTOBDFault.DecodeSPID(fault); // Mfg/Subsystem/Problem
if (Character.isLetter((char) sysChar)) {
sb.append((char) sysChar);
} else {
sb.append("U");
}
if ((subSys & 0x8000) != 0) {
sb.append("1");
} else {
sb.append("0");
}
String subSysStr = String.valueOf(1000 + ((subSys & 0xFFF) % 1000));
sb.append(subSysStr.substring(1));
return sb.toString();
} else {
// unrecognized
}
}
return "";
}
/**
* Return a set of the variables in the supplied expression. Note: Substitutions which are in the
* constant table are not included.
*/
public Set<String> getVariablesWithin(String exp) {
Set<String> all = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
String add = null;
if (separators == null) {
StringBuilder sep = new StringBuilder(10);
for (char chr = 0; chr < operators.length; chr++) {
if (operators[chr] != null && !operators[chr].internal) {
sep.append(chr);
}
}
sep.append("()");
separators = sep.toString();
}
for (StringTokenizer tkz = new StringTokenizer(exp, separators, true); tkz.hasMoreTokens(); ) {
String tkn = tkz.nextToken().trim();
if (tkn.length() != 0 && Character.isLetter(tkn.charAt(0))) {
add = tkn;
} else if (tkn.length() == 1 && tkn.charAt(0) == '(') {
add = null;
} else if (add != null && !constants.containsKey(add)) {
all.add(add);
}
}
if (add != null && !constants.containsKey(add)) {
all.add(add);
}
return all;
}
public static boolean isFunctionName(String str) {
/*
* actually checks if all the chars are letters
*/
for (char c : str.toCharArray()) {
if (!Character.isLetter(c)) return false;
}
return true;
}
public static String modify(String in) {
in = in.toLowerCase();
String returnString = "";
for (int i = 0; i < in.length(); i++) {
char current = in.charAt(i);
// Repeat Random Amount
if (current == 'a' || current == 'e' || current == 'i' || current == 'o' || current == 'u') {
if (Math.random() > 0.5) returnString += vowel[(int) Math.random() * 5];
else returnString += Character.toUpperCase(vowel[(int) Math.random() * 5]);
} else {
for (int j = 0; j < (int) Math.random() * 5 + 1; j++) {
if (Math.random() > 0.5) returnString += current;
else returnString += Character.toUpperCase(current);
}
}
}
return returnString;
}
/**
* ** Returns true if the specified character should be hex-encoded in a URL ** @param ch The
* character to test ** @return True if the specified character should be hex-encoded in a URL
*/
private static boolean shouldEncodeArgChar(char ch) {
if (Character.isLetterOrDigit(ch)) {
return false;
} else if ((ch == '_') || (ch == '-') || (ch == '.')) {
return false;
} else {
return true;
}
}
private void validateName(String nam) {
if (!Character.isLetter(nam.charAt(0))) {
throw new IllegalArgumentException(
"Names for constants, variables and functions must start with a letter");
}
if (nam.indexOf('(') != -1 || nam.indexOf(')') != -1) {
throw new IllegalArgumentException(
"Names for constants, variables and functions may not contain a parenthesis");
}
}
public String Decrypt(String C) {
int len = C.length() / 22;
String M = "";
for (int i = 0; i < len; i++) {
String Temp = C.substring(i * 22, i * 22 + 22);
String m = Character.toString((char) Decrypto(new BigInteger(Temp)));
M = M.concat(m);
}
return M;
}
public static int compare(Character o1, Object o2) {
if (o2 == null) {
return 1;
} else if (o2 instanceof Character) {
Character c2 = (Character) o2;
return o1.compareTo(c2);
} else {
return -1;
}
}
public Field(String s) {
String f[] = StringTools.parseString(s, FIELD_VALUE_SEPARATOR);
if ((f.length > 0) && (f[0].length() > 0) && Character.isLetter(f[0].charAt(0))) {
this.isHiRes = (f.length > 0) ? f[0].equalsIgnoreCase("H") : false;
this.type = (f.length > 1) ? StringTools.parseInt(f[1], -1) : -1;
} else {
this.type = (f.length > 0) ? StringTools.parseInt(f[0], -1) : -1;
this.isHiRes = (f.length > 1) ? f[1].equalsIgnoreCase("H") : false;
}
this.index = (f.length > 2) ? StringTools.parseInt(f[2], 0) : 0;
this.length = (f.length > 3) ? StringTools.parseInt(f[3], 0) : 0;
this.isValid = (f.length == 4) && (this.type >= 0) && (this.index >= 0) && (this.length > 0);
}
public static void main(String args[]) {
int NUM_LETTERS = 27;
char[] alfabet = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '?'
};
Scanner in = new Scanner(System.in);
int L = in.nextInt();
in.nextLine();
int H = in.nextInt();
in.nextLine();
// to store the letter in asci artM
char[][] art = new char[H][L * NUM_LETTERS];
String T = in.nextLine(); // text to translate
System.err.println("create array L:" + L + "/H:" + H + "/to translate:" + T);
// saving asci art
for (int i = 0; i < H; i++) {
String ROW = in.nextLine(); // first line of all letters in asci art
// the ROW must be saved in L chars groups
// System.err.println("readed->" + ROW);
char[] aux = ROW.toCharArray();
for (int j = 0; j < aux.length; j++) {
// System.err.println("guardando->["+i+"]["+j+"]" + aux[j]);
art[i][j] = aux[j];
}
}
StringBuilder builder = new StringBuilder();
char[] translation = T.toCharArray();
for (int m = 0; m < H; m++) {
StringBuilder linea = new StringBuilder();
for (int j = 0; j < translation.length; j++) {
// neet to get char -> letter number to get position
int position = returnPosition(Character.toUpperCase(translation[j]), alfabet);
int start = (position * L);
for (int u = start; u < (start + L); u++) {
linea.append(art[m][u]);
}
}
System.out.println(linea);
}
// Write an action using System.out.println()
// To debug: System.err.println("Debug messages...");
}
private static boolean go(int a, int b) {
if (memo[a][b] >= 0) return memo[a][b] == 1;
if (a == b) return true;
if (b - a == 1) return str[a] == ' ' || str[a] == ':' || Character.isLetter(str[a]);
boolean ok = false;
if (b - a == 2) ok |= str[a] == ':' && (str[a + 1] == ')' || str[a + 1] == '(');
if (b - a >= 2 && str[a] == '(' && str[b - 1] == ')') ok |= go(a + 1, b - 1);
for (int x = a + 1; x < b && !ok; x++) ok |= go(a, x) && go(x, b);
memo[a][b] = ok ? 1 : 0;
return ok;
}
// Find and unescape a string.
private String readString() {
StringBuilder sb = new StringBuilder();
char c = next();
if (c != '"') throw new RuntimeException("expecting start of string");
while (true)
switch (c = next()) {
case '"':
return sb.toString();
case '\\':
sb.append(readEscaped());
continue;
default:
if (Character.isISOControl(c)) throw new RuntimeException("illegal character in string");
sb.append(c);
}
}
@Override
public String toString() {
switch (this.type) {
case OPERATOR:
case OPENING_BRACKET:
case CLOSING_BRACKET:
return Character.toString(operator);
case FUNCTION:
return this.function;
case VALUE:
default:
return Arrays.toString(value);
}
}
/**
* ** Returns true if the URL starts with a protocol definition (ie. "http://...") ** @param url
* The URL to test ** @return True if the URL starts with a protocol definition
*/
public static boolean isAbsoluteURL(String url) {
if (url == null) {
return false;
} else {
// per "http://en.wikipedia.org/wiki/URI_scheme" all URL "schemes" contain only
// alphanumeric or "." characters, and appears to be < 16 characters in length.
for (int i = 0; (i < 16) && (i < url.length()); i++) {
char ch = url.charAt(i);
if (ch == ':') {
return true; // A colon is the first non-alphanumeric we ran in to
} else if (!Character.isLetterOrDigit(ch) && (ch != '.')) {
return false;
}
}
return false;
}
}
private double doNamedVal(int beg, int end) {
while (beg < end && Character.isWhitespace(expression.charAt(end))) {
end--;
} // since a letter triggers a named value, this can never reduce to beg==end
String nam = expression.substring(beg, (end + 1));
Double val;
if ((val = constants.get(nam)) != null) {
return val.doubleValue();
} else if ((val = variables.get(nam)) != null) {
isConstant = false;
return val.doubleValue();
} else if (relaxed) {
isConstant = false;
return 0.0;
}
throw exception(beg, "Unrecognized constant or variable \"" + nam + "\"");
}
// To add/remove functions change evaluateOperator() and registration
public double evaluateFunction(String fncnam, ArgParser fncargs) throws ArithmeticException {
switch (Character.toLowerCase(fncnam.charAt(0))) {
case 'a':
{
if (fncnam.equalsIgnoreCase("abs")) {
return Math.abs(fncargs.next());
}
if (fncnam.equalsIgnoreCase("acos")) {
return Math.acos(fncargs.next());
}
if (fncnam.equalsIgnoreCase("asin")) {
return Math.asin(fncargs.next());
}
if (fncnam.equalsIgnoreCase("atan")) {
return Math.atan(fncargs.next());
}
}
break;
case 'c':
{
if (fncnam.equalsIgnoreCase("cbrt")) {
return Math.cbrt(fncargs.next());
}
if (fncnam.equalsIgnoreCase("ceil")) {
return Math.ceil(fncargs.next());
}
if (fncnam.equalsIgnoreCase("cos")) {
return Math.cos(fncargs.next());
}
if (fncnam.equalsIgnoreCase("cosh")) {
return Math.cosh(fncargs.next());
}
}
break;
case 'e':
{
if (fncnam.equalsIgnoreCase("exp")) {
return Math.exp(fncargs.next());
}
if (fncnam.equalsIgnoreCase("expm1")) {
return Math.expm1(fncargs.next());
}
}
break;
case 'f':
{
if (fncnam.equalsIgnoreCase("floor")) {
return Math.floor(fncargs.next());
}
}
break;
case 'g':
{
// if(fncnam.equalsIgnoreCase("getExponent" )) { return
// Math.getExponent(fncargs.next()); } needs Java 6
}
break;
case 'l':
{
if (fncnam.equalsIgnoreCase("log")) {
return Math.log(fncargs.next());
}
if (fncnam.equalsIgnoreCase("log10")) {
return Math.log10(fncargs.next());
}
if (fncnam.equalsIgnoreCase("log1p")) {
return Math.log1p(fncargs.next());
}
}
break;
case 'm':
{
if (fncnam.equalsIgnoreCase("max")) {
return Math.max(fncargs.next(), fncargs.next());
}
if (fncnam.equalsIgnoreCase("min")) {
return Math.min(fncargs.next(), fncargs.next());
}
}
break;
case 'n':
{
// if(fncnam.equalsIgnoreCase("nextUp" )) { return Math.nextUp
// (fncargs.next()); } needs Java 6
}
break;
case 'r':
{
if (fncnam.equalsIgnoreCase("random")) {
return Math.random();
} // impure
if (fncnam.equalsIgnoreCase("round")) {
return Math.round(fncargs.next());
}
if (fncnam.equalsIgnoreCase("roundHE")) {
return Math.rint(fncargs.next());
} // round half-even
}
break;
case 's':
{
if (fncnam.equalsIgnoreCase("signum")) {
return Math.signum(fncargs.next());
}
if (fncnam.equalsIgnoreCase("sin")) {
return Math.sin(fncargs.next());
}
if (fncnam.equalsIgnoreCase("sinh")) {
return Math.sinh(fncargs.next());
}
if (fncnam.equalsIgnoreCase("sqrt")) {
return Math.sqrt(fncargs.next());
}
}
break;
case 't':
{
if (fncnam.equalsIgnoreCase("tan")) {
return Math.tan(fncargs.next());
}
if (fncnam.equalsIgnoreCase("tanh")) {
return Math.tanh(fncargs.next());
}
if (fncnam.equalsIgnoreCase("toDegrees")) {
return Math.toDegrees(fncargs.next());
}
if (fncnam.equalsIgnoreCase("toRadians")) {
return Math.toRadians(fncargs.next());
}
}
break;
case 'u':
{
if (fncnam.equalsIgnoreCase("ulp")) {
return Math.ulp(fncargs.next());
}
}
break;
// no default
}
throw new UnsupportedOperationException(
"MathEval internal function setup is incorrect - internal function \""
+ fncnam
+ "\" not handled");
}
private int skipWhitespace(String exp, int ofs, int end) {
while (ofs <= end && Character.isWhitespace(exp.charAt(ofs))) {
ofs++;
}
return ofs;
}
/**
* Evaluate the next operand of an expression.
*
* @param beg Inclusive begin offset for subexpression.
* @param end Inclusive end offset for subexpression.
* @param pnd Pending operator (operator previous to this subexpression).
* @param lft Left-value with which to initialize this subexpression.
* @param cur Current operator (the operator for this subexpression).
*/
private double _evaluate(int beg, int end, double lft, Operator pnd, Operator cur)
throws NumberFormatException, ArithmeticException {
Operator nxt = OPERAND; // next operator
int ofs; // current expression offset
for (ofs = beg; (ofs = skipWhitespace(expression, ofs, end)) <= end; ofs++) {
boolean fnc = false;
double rgt = Double.NaN; // next operand (right-value) to process
for (beg = ofs; ofs <= end; ofs++) {
char chr = expression.charAt(ofs);
if ((nxt = getOperator(chr)) != OPERAND) {
if (nxt.internal) {
nxt = OPERAND;
} // must kill operator to prevent spurious "Expression ends with a blank sub-expression"
// at end of function
else {
break;
}
} else if (chr == ')' || chr == ',') { // end of subexpression or function argument.
break;
}
}
EvaluateOperand:
{
char ch0 = expression.charAt(beg);
boolean alp = Character.isLetter(ch0);
if (cur.unary != LEFT_SIDE) {
if (ch0 == '+') {
continue;
} // unary '+': no-op; i.e. +(-1) == -1
if (ch0 == '-') {
nxt = getOperator('±');
} // unary '-': right-binding, high precedence operation (different from subtract)
}
if (beg == ofs && (cur.unary == LEFT_SIDE || nxt.unary == RIGHT_SIDE)) {
rgt =
Double
.NaN; // left-binding unary operator; right value will not be used and should be
// blank
} else if (ch0 == '(') {
rgt = _evaluate(beg + 1, end);
ofs =
skipWhitespace(
expression, offset + 1, end); // skip past ')' and any following whitespace
nxt =
(ofs <= end ? getOperator(expression.charAt(ofs)) : OPERAND); // modify next operator
} else if (alp && nxt.symbol == '(') {
rgt = doFunction(beg, end);
ofs =
skipWhitespace(
expression, offset + 1, end); // skip past ')' and any following whitespace
nxt =
(ofs <= end ? getOperator(expression.charAt(ofs)) : OPERAND); // modify next operator
} else if (alp) {
rgt = doNamedVal(beg, (ofs - 1));
} else {
try {
if (stringOfsEq(expression, beg, "0x")) {
rgt = (double) Long.parseLong(expression.substring(beg + 2, ofs).trim(), 16);
} else {
rgt = Double.parseDouble(expression.substring(beg, ofs).trim());
}
} catch (NumberFormatException thr) {
throw exception(
beg, "Invalid numeric value \"" + expression.substring(beg, ofs).trim() + "\"");
}
}
}
if (opPrecedence(cur, LEFT_SIDE)
< opPrecedence(
nxt,
RIGHT_SIDE)) { // correct even for last (non-operator) character, since non-operators
// have the artificial "precedence" zero
rgt =
_evaluate(
(ofs + 1), end, rgt, cur,
nxt); // from after operator to end of current subexpression
ofs = offset; // modify offset to after subexpression
nxt = (ofs <= end ? getOperator(expression.charAt(ofs)) : OPERAND); // modify next operator
}
lft = doOperation(beg, lft, cur, rgt);
cur = nxt;
if (opPrecedence(pnd, LEFT_SIDE) >= opPrecedence(cur, RIGHT_SIDE)) {
break;
}
if (cur.symbol == '(') {
ofs--;
} // operator omitted for implicit multiplication of subexpression
}
if (ofs > end && cur != OPERAND) {
if (cur.unary == LEFT_SIDE) {
lft = doOperation(beg, lft, cur, Double.NaN);
} else {
throw exception(
ofs, "Expression ends with a blank operand after operator '" + nxt.symbol + "'");
}
}
offset = ofs;
return lft;
}