62,615
社区成员
发帖
与我相关
我的任务
分享正则100分.送分题.欢迎@imfang @dreamhyz来挑战!
已知SUM()是一个求和的方法.并且SUM有以下的格式.
SUM()
SUM(1,2)
SUM(1,2,3) // 里面可以传递不确定的参数.
SUM(1,2,SUM(SUM(1,3)),3)//SUM()可以作为返回值传递给SUM()方法,所以SUM()可能存在多层嵌套
所以存在类似
这样的字符串,为了降低难度里面,假设SUM()都是正常格式,不存在空格在里面.
现在我要求是列出所有SUM的方法.
如上面的字符串的话需要列出如下答案:(注:顺序不一定如下,具体按照自己的算法)
SUM(1,2,SUM(1,2,3))
SUM(1,2,3)
SUM(1,3)
SUM()
SUM(SUM())
SUM(SUM(SUM()))
SUM(2,SUM(1,3),4,SUM(SUM(SUM())))
特别欢迎 @imfang @dreamhyz
这两天我在论坛赚了挺多分的.分多就是任性.呵呵
SUM()
SUM(1,2)
SUM(1,2,3) // 里面可以传递不确定的参数.
SUM(1,2,SUM(SUM(1,3)),3)//SUM()可以作为返回值传递给SUM()方法,所以SUM()可能存在多层嵌套
所以存在类似
SUM(1,2,SUM(1,2,3))+SUM(2,SUM(1,3),4,SUM(SUM(SUM())))
这样的字符串,为了降低难度里面,假设SUM()都是正常格式,不存在空格在里面.
现在我要求是列出所有SUM的方法.
如上面的字符串的话需要列出如下答案:(注:顺序不一定如下,具体按照自己的算法)
SUM(1,2,SUM(1,2,3))
SUM(1,2,3)
SUM(1,3)
SUM()
SUM(SUM())
SUM(SUM(SUM()))
SUM(2,SUM(1,3),4,SUM(SUM(SUM())))
特别欢迎 @imfang @dreamhyz 这两天我在论坛赚了挺多分的.分多就是任性.呵呵
...全文
请发表友善的回复…
发表回复
qq_24080831 2015-10-10
- 打赏
- 举报
u010053498 2015-10-10
- 打赏
- 举报
这个代码是以前做计算器时候捣鼓的。蛮长时间了，稍微修改了一下，还能用。
csdn这是什么bug 怎么代码都显示绿色啊..u010053498 2015-10-10
- 打赏
- 举报
/**
* 正则表达式 判断是否为小数
* @param str
* @return
*/
private boolean isNumeric(String str){
Pattern pattern = Pattern.compile("[-+]{0,1}\\d+\\.\\d*");
Matcher isNum = pattern.matcher(str);
if( !isNum.matches() ){
return false;
}
return true;
}
/**
* 正贼表达式 判断是否为数字
* @param str
* @return
*/
private boolean isNumeric2(String str){
/*正则表达式最后为‘+’不为‘*’,避免‘+-’误判为数字*/
Pattern pattern = Pattern.compile("[-+]{0,1}[0-9]+");
Matcher isNum = pattern.matcher(str);
if( !isNum.matches() ){
return false;
}
return true;
}
private boolean isDqMarks(String str)
{
/*貌似匹配的是一双引号开头结尾的字符串*/
Pattern pattern = Pattern.compile("\"([^\"]+)\"");
Matcher isNum = pattern.matcher(str);
if( !isNum.matches() ){
return false;
}
return true;
// if(str.charAt(0)==34&&str.charAt(str.length()-1)==34)
// {
// return true;
// }
// return false;
}
/**
* 根据方法名称取得反射方法的参数类型(没有考虑同名重载方法使用时注意)
* @param obj 类实例
* @param methodName 方法名
* @return
* @throws ClassNotFoundException
*/
@SuppressWarnings("rawtypes")
public static Class[] getMethodParamTypes(String methodName) throws ClassNotFoundException
{
Object classInstance = null;
try
{
classInstance = InfixIntoPostfixExpression.class.newInstance();
} catch (InstantiationException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
Class[] paramTypes = null;
Method[] methods = classInstance.getClass().getMethods();//全部方法
for (int i = 0; i< methods.length; i++) {
if(methodName.equals(methods[i].getName())){//和传入方法名匹配
Class[] params = methods[i].getParameterTypes();
paramTypes = new Class[ params.length] ;
for (int j = 0; j < params.length; j++) {
paramTypes[j] = Class.forName(params[j].getName());
}
break;
}
}
return paramTypes;
}
/**
* operatorMap key为运算符, value为优先级
* @param operatorMap
*/
private void addOperatorMap(Map<String,Integer> operatorMap)
{
operatorMap.put("max",3);
operatorMap.put("min",3);
operatorMap.put("SUM",3);
operatorMap.put("ave",3);
operatorMap.put("strn",3);
operatorMap.put("*",2);
operatorMap.put("/",2);
operatorMap.put("+",1);
operatorMap.put("-",1);
operatorMap.put(",",0);
}
private void addOperatorList(List<Character> operatorList)
{
operatorList.add('+');
operatorList.add('-');
operatorList.add('*');
operatorList.add('/');
operatorList.add(',');
operatorList.add('(');
operatorList.add(')');
}
/**
* 不同的运算符对应的算法
* @param pop0
* @param pop1
* @param operator
* @return
*/
private BigDecimal logic(BigDecimal pop0,BigDecimal pop1,String operator)
{
if(operator.equals("*"))
{
return pop0.multiply(pop1);
}
else if(operator.equals("/"))
{
return pop0.divide(pop1);
}
else if(operator.equals("+"))
{
return pop0.add(pop1);
}
else if(operator.equals("-"))
{
return pop0.subtract(pop1);
}
return new BigDecimal(-1);
}
/**
* 不同的运算符对应的算法
* @param pop0
* @param pop1
* @param operator
* @return
*/
private String logic(String pop0,BigDecimal pop1,String operator)
{
String result = pop0 + operator + String.valueOf(pop1);
return result;
}
/**
* 不同的运算符对应的算法
* @param pop0
* @param pop1
* @param operator
* @return
*/
private String logic(BigDecimal pop0,String pop1,String operator)
{
String result = String.valueOf(pop0) + operator + pop1;
return result;
}
/**
* 不同的运算符对应的算法
* @param pop0
* @param pop1
* @param operator
* @return
*/
private String logic(String pop0,String pop1,String operator)
{
String result = pop0 + operator + pop1;
return result;
}
/**
* 计算最大值函数
* @param number
* @return
*/
public BigDecimal max(BigDecimal ...number)
{
BigDecimal max = number[0];
for(BigDecimal num : number)
{
if(num.compareTo(max)>0)
{
max = num;
}
}
return max;
}
/**
* 计算最小值函数
* @param number
* @return
*/
public BigDecimal min(BigDecimal ...number)
{
BigDecimal min = number[0];
for(BigDecimal num : number)
{
if(num.compareTo(min)<0)
{
min = num;
}
}
return min;
}
/**
* 计算和值函数
* @param number
* @return
*/
public BigDecimal SUM(BigDecimal ...number)
{
BigDecimal sum = new BigDecimal(0);
for(BigDecimal num : number)
{
sum = sum.add(num);
}
return sum;
}
/**
* 计算平均值函数
* @param number
* @return
*/
public BigDecimal ave(BigDecimal ...number)
{
return SUM(number).divide(new BigDecimal(number.length));
}
public String strn(String ...strings)
{
String strN = "'哈哈：";
for(String str : strings)
{
strN += str.substring(1,str.length()-1);
}
return strN+"'";
}
public static void main(String[] args)
{
InfixIntoPostfixExpression infixIntoPostfixExpression = new InfixIntoPostfixExpression();
String infixExpression = "SUM(1,2,SUM(1,2,3*6+SUM()))+SUM(2,SUM(1,3),4,4+SUM(SUM(SUM())))";
System.out.println("中缀表达式：");
System.out.println(infixExpression);
System.out.println("--------------------------------");
String postfixExpression = infixIntoPostfixExpression.getPostfixExpression(infixExpression);
System.out.println("后缀表达式(逆波兰表达式)：");
System.out.println(postfixExpression);
System.out.println("--------------------------------");
String logicResult = infixIntoPostfixExpression.getLogicResult(infixExpression);
System.out.println("--------------------------------");
System.out.println("最终计算结果：");
System.out.println(logicResult);
System.out.println("--------------------------------");
}
}
u010053498 2015-10-10
- 打赏
- 举报
/**
* 如果给定中缀表达式中的‘-’左边为空或‘(’则补0处理
* 替换'()'为'(0)'
* @param infixExpression
* @return
*/
private String minusFilter(String infixExpression)
{
String infixExpression0 = minusFilter0(infixExpression,0);
return infixExpression0.replaceAll("\\(\\)", "(0)");
}
private String minusFilter0(String infixExpression,int trim)
{
for(int i = trim;i < infixExpression.length();i++)
{
if(34 == infixExpression.charAt(i)||i == infixExpression.length()-1)
{
int newTrim = i;
if(i != infixExpression.length()-1)
{
for(int j = i;j < infixExpression.length();j++)
{
if(j>i&&34==infixExpression.charAt(j))
{
i = j;
break;
}
}
}
int off = i - newTrim + 1;
String trimString = infixExpression.substring(trim,newTrim);
trimString = trimString.replaceAll("\\s*", "");
trimString = trimString.replace("(-", "(0-");
trimString = trimString.replace(",-", ",0-");
infixExpression = infixExpression.substring(0,trim) + trimString + infixExpression.substring(newTrim);
if(infixExpression.charAt(0)==45)
{
infixExpression = "0"+infixExpression;
newTrim = 1 + trim + trimString.length() + off;
}
else
{
newTrim = trim + trimString.length() + off;
}
return minusFilter0(infixExpression,newTrim);
}
}
return infixExpression;
}
/**
* 计算后缀表达式
* @param finalResultListExpression
* @return
*/
@SuppressWarnings("unchecked")
public List<String> calculatePostfixExpression(List<String> finalResultListExpression)
{
List<Object> resultStack = new ArrayList<Object>();
List<String> stringResult = new ArrayList<String>();
System.out.println("依后缀表达式顺序输出结果答案（同题主顺序）：");
for(String s : finalResultListExpression)
{
if(operatorMap.containsKey(s))
{
Object pop0 = null;
Object pop1 = null;
if(!resultStack.isEmpty())
{
pop0 = resultStack.get(resultStack.size()-1);
resultStack.remove(resultStack.size()-1);
}
if(!resultStack.isEmpty())
{
pop1 = resultStack.get(resultStack.size()-1);
resultStack.remove(resultStack.size()-1);
}
if(s.equals(","))
{
List<Object> tempList = new ArrayList<Object>();
if(pop0 instanceof ArrayList)
{
System.out.println(pop0);
tempList.addAll((List<Object>)pop0);
}
else if(isNumeric(String.valueOf(pop0))||isNumeric2(String.valueOf(pop0)))
{
tempList.add(new BigDecimal(String.valueOf(pop0)));
}
else
{
tempList.add(pop0);
}
if(pop1 instanceof ArrayList)
{
tempList.addAll((List<Object>)pop1);
}
else if(isNumeric(String.valueOf(pop1))||isNumeric2(String.valueOf(pop1)))
{
tempList.add(new BigDecimal(String.valueOf(pop1)));
}
else
{
tempList.add(pop1);
}
resultStack.add(tempList);
}
else if(operatorMap.get(s)==3)
{
InfixIntoPostfixExpression expression2 = new InfixIntoPostfixExpression();
Object methodValue = null;
if(null!=pop1)
resultStack.add(pop1);
if(s.equals("max")||s.equals("min")||s.equals("SUM")||s.equals("ave"))
{
BigDecimal[] methodParamArray = {};
if(pop0 instanceof ArrayList)
{
List<Object> top = (List<Object>)pop0;
methodParamArray = new BigDecimal[top.size()];
for(int i = 0;i < top.size();i++)
{
String methodParam = String.valueOf(top.get(i));
methodParamArray[top.size()-1-i] = new BigDecimal(methodParam);
}
}
else
{
methodParamArray= new BigDecimal[1];
methodParamArray[0] = new BigDecimal(String.valueOf(pop0));
}
/**
* java反射机制
*/
try
{
Method cc=expression2.getClass().getMethod(s,BigDecimal[].class);
methodValue = cc.invoke(expression2,(Object)methodParamArray);
System.out.println(methodValue);
} catch (Exception e)
{
e.printStackTrace();
}
}
else if(s.equals("strn"))
{
String[] methodParamArray = {};
if(pop0 instanceof ArrayList)
{
List<Object> top = (List<Object>)pop0;
methodParamArray= new String[top.size()];
for(int i = 0;i < top.size();i++)
{
String methodParam = String.valueOf(top.get(i));
methodParamArray[top.size()-1-i] = new String(methodParam);
}
}
else
{
methodParamArray= new String[1];
methodParamArray[0] = String.valueOf(pop0);
}
/**
* java反射机制
*/
try
{
Method cc=expression2.getClass().getMethod(s,String[].class);
methodValue = cc.invoke(expression2,(Object)methodParamArray);
} catch (Exception e)
{
e.printStackTrace();
}
}
resultStack.add(methodValue);
}
else
{
String methodParam0 = String.valueOf(pop0);
String methodParam1 = String.valueOf(pop1);
if((isNumeric(methodParam0)||isNumeric2(methodParam0))&&(isNumeric(methodParam1)||isNumeric2(methodParam1)))
resultStack.add(logic(new BigDecimal(methodParam1),new BigDecimal(methodParam0),s).toString());
else if((!(isNumeric(methodParam0)||isNumeric2(methodParam0)))&&(isNumeric(methodParam1)||isNumeric2(methodParam1)))
resultStack.add(logic(new BigDecimal(methodParam1),methodParam0,s));
else if((isNumeric(methodParam0)||isNumeric2(methodParam0))&&(!(isNumeric(methodParam1)||isNumeric2(methodParam1))))
resultStack.add(logic(methodParam1,new BigDecimal(methodParam0),s));
else
resultStack.add(logic(methodParam1,methodParam0,s));
}
}
else
resultStack.add(s);
}
for(Object obj : resultStack)
{
stringResult.add(String.valueOf(obj));
}
return stringResult;
}
u010053498 2015-10-10
- 打赏
- 举报
package com.csdn.light;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 将中缀表达式转换为后缀表达式 并计算后缀表达式
* @author wwwdeno1
*
*/
public class InfixIntoPostfixExpression
{
/*中间结果栈*/
private List<String> inResultStack = new ArrayList<String>();
/*运算符栈*/
private List<String> operatorStack = new ArrayList<String>();
/*所有运算符*/
private Map<String,Integer> operatorMap = new HashMap<String,Integer>();
/*运算符列表*/
private List<Character> operatorList = new ArrayList<Character>();
/**
* 得到后缀表达式
* @param infixExpression
* @return
*/
public String getPostfixExpression(String infixExpression)
{
if(!inResultStack.isEmpty())
{
inResultStack.clear();
}
List<String> finalResultList = infixIntoPostfixExpression(infixExpression);
return resultString(finalResultList);
}
/**
* 得到最终计算结果
* @param infixExpression
* @return
*/
public String getLogicResult(String infixExpression)
{
if(!inResultStack.isEmpty())
{
inResultStack.clear();
}
List<String> finalResultList = infixIntoPostfixExpression(infixExpression);
List<String> logicList = calculatePostfixExpression(finalResultList);
return resultString(logicList);
}
/**
* 将List转换为字符串
* @param resultList
* @return
*/
private String resultString(List<String> resultList)
{
String[] resultArray = new String[resultList.size()];
resultList.toArray(resultArray);
String result = "";
for(String r : resultArray)
{
result += r+" ";
}
return result;
}
/**
* 将中缀表达式转换为后缀表达式
* @param infixExpression 中缀表达式
* @return List形式的后缀表达式
*/
private List<String> infixIntoPostfixExpression(String infixExpression)
{
this.addOperatorMap(operatorMap);
this.addOperatorList(operatorList);
infixExpression = minusFilter(infixExpression);
// validateExpression(infixExpression);
List<String> finalResultList = getFinalResultStack(infixExpression);
return finalResultList;
}
/**
* 将中缀表达式转换为后缀表达式
* @param infixExpression
* @return
*/
private List<String> getFinalResultStack(String infixExpression)
{
for(int i = 0;i < infixExpression.length();i++)
{
if(34 == infixExpression.charAt(i))
{
for(int j = i;j < infixExpression.length();j++)
{
if(j>i&&34==infixExpression.charAt(j))
{
i = j;
break;
}
}
}
if(operatorList.contains(infixExpression.charAt(i)))
{
String operand = infixExpression.substring(0,i);
char operator = infixExpression.charAt(i);
if(operator=='(')
{
if(!"".equals(operand))
inOperatorHandle(operand);
inOperatorHandle(String.valueOf(operator));
}
else
{
if(!"".equals(operand)&&!isNumeric(operand)&&!isNumeric2(operand)&&!isDqMarks(operand))
{
String message = "非法参数异常,参数'"+operand+"'异常";
System.out.println(message);
return null;
}
if(!"".equals(operand))
inResultStack.add(operand);
inOperatorHandle(String.valueOf(operator));
}
if(i < infixExpression.length()-1)
{
infixExpression = infixExpression.substring(i+1);
return getFinalResultStack(infixExpression);
}
}
}
if(infixExpression.charAt(infixExpression.length()-1)!=')')
inResultStack.add(infixExpression);
while(!operatorStack.isEmpty())
{
inResultStack.add(operatorStack.get(operatorStack.size()-1));
operatorStack.remove(operatorStack.size()-1);
}
return inResultStack;
}
/**
* 对表达式中遇到的的运算符或括号 进行处理
* @param inOperator
*/
private void inOperatorHandle(String inOperator)
{
/**
* 这里判断的顺序非常重要
*/
if(!operatorMap.containsKey(inOperator)&&!inOperator.equals("(")&&!inOperator.equals(")"))
{
String message = "非法函数异常,系统中不存在函数'"+inOperator+"'";
System.out.println(message);
return;
}
else if(inOperator.equals("("))
{
operatorStack.add(inOperator);
}
else if(inOperator.equals(")"))
{
boolean ck = false;
for(int k = operatorStack.size()-1;k >= 0;k--)
{
if(!ck&&operatorStack.get(k).equals("("))
{
List<String> inPopOperator = operatorStack.subList(k+1,operatorStack.size());
List<String> popOperator = new ArrayList<String>();
for(int l = 0;l < inPopOperator.size();l++)
{
popOperator.add(inPopOperator.get(inPopOperator.size()-1-l));
}
inResultStack.addAll(popOperator);
operatorStack = operatorStack.subList(0, k);
ck = true;
}
}
}
else if(operatorStack.isEmpty()||operatorStack.get(operatorStack.size()-1).equals("("))
{
operatorStack.add(inOperator);
}
else
{
while(!operatorStack.isEmpty()&&!operatorStack.get(operatorStack.size()-1).equals("(")&&operatorMap.get(inOperator)<=operatorMap.get(operatorStack.get(operatorStack.size()-1)))
{
inResultStack.add(operatorStack.get(operatorStack.size()-1));
operatorStack.remove(operatorStack.size()-1);
}
operatorStack.add(inOperator);
}
}
rickylin86 2015-10-10
- 打赏
- 举报
package net.csdn.question;
//SUM(1,2,SUM(1,2,3))+SUM(2,3,4)
//http://www.cjsdn.net/post/view?bid=1&id=147604&tpg=1&ppg=1&sty=1&age=0#147604
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
public class GetSumMethod {
public static void main(String[] args) {
String regex = "SUM\\([^(]*?\\)";
String content = "SUM(1,2,SUM(1,2,3*6+SUM()))+SUM(2,SUM(1,3),4,4+SUM(SUM(SUM())))";
ArrayList<String> results = new ArrayList<String>();
results = getResults(content,regex,results);
String[] sums = recoveryArray(results);
for(int i = 0 ; i < sums.length ; i ++){
System.out.println(sums[i]);
}
}
private static String[] recoveryArray(ArrayList<String> results){
//这个方法用于恢复原来的被ArrayList[//d]所替代的内容
String regex = "ArrayList\\[(\\d)\\]";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = null;
int arrayListSize = results.size();
String[] sums = new String[arrayListSize];
String sum = null;
for(int i = 0 ; i < arrayListSize ; i ++ ){
sum = results.get(i);
matcher = pattern.matcher(sum);
while(matcher.find()){
int index = new Integer(matcher.group(1));
sum = sum.replaceFirst(regex,results.get(index));
matcher = pattern.matcher(sum);
}
sums[i] = sum;
}
return sums;
}
private static ArrayList<String> getResults(String content,String regex,ArrayList<String> results){
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(content);
String sum = null;
if(matcher.find()){
sum = matcher.group();
results.add(sum);
content = content.replaceFirst(regex,"ArrayList[" + (results.size() - 1) + "]");
getResults(content,regex,results);
}
return results;
}
}
rickylin86 2015-10-09
- 打赏
- 举报
呵呵。睡啊。不过夜猫子习惯了,所以每天都晚睡晚起的那种
dreamhyz 2015-10-09
- 打赏
- 举报
不睡觉的啊，呵呵，这个不好搞
rickylin86 2015-10-09
- 打赏
- 举报
恩。是的。需要分步骤来处理的.之前在CJSDN上看到的.需要考虑到一些数据结构正则之类的东西.
suciver 2015-10-09
- 打赏
- 举报
这个java的正则做不了,因为java正则没有平衡组,自己去扫描整个字符串,进行平衡判断
FANJAH 2015-10-09
- 打赏
- 举报
[align=left][align=left][align=center]
[/align][/align][/align]rickylin86 2015-10-09
- 打赏
- 举报
补充下:甚至还存在以下格式
SUM(1,2,SUM(1,2,3*6+SUM()))+SUM(2,SUM(1,3),4,4+SUM(SUM(SUM())))
tony4geek 2015-10-09
- 打赏
- 举报
如果能用平衡组 就好了
