题目一
- 1.题目要求
- 2.分析
这就是一个简单的堆栈应用,求后缀表达式的值,不过需要注意的是分隔符为一个或多个空格。可以使用String类的split方法,该方法支持正则表达式,正则表达式 \s 表示匹配任何空白字符,+表示匹配一次或多次。所以这样既可:
String[] paras = expr.split("\\s+");
前面的 \ 表示转义 - 3.代码
/*一个对于一个单行的逆波兰表达式,由如下元素构成:
数字:十进制数字字符构成的正整数,比如 223
运算符:支持三种运算符^+和*,分别代表自增,加法和乘法
分隔符:一个或者多个空格
例如下面的字符串就是个逆波兰表达式
2 3 4 * ^ 5 +
逆波兰表达式在一个基于栈的虚拟机中求解,虚拟机的栈能保存16个整数,虚拟机从左向右扫描表达式,遇到整数就压栈,
遇到表达式则从栈顶弹出若干个整数进行计算,计算结果重新压回栈中。其中运算符^从栈顶弹出一个整数,增加1之后压栈;运算符+和*从栈顶弹出两个整数,
分别做相加和相乘运算后压栈。如果遇到运算符的时候,栈内没有足够的整数,称为下溢出,返回-1;
把整数压栈的时候,如果栈没有足够的空间,称为上溢出,返回-2;如果整个计算过程中没有发生溢出,在整个表达式求解完成后,返回栈顶的整数。*/
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main1 {
public static void main(String[] args) {
ArrayList<Integer> inputs = new ArrayList<Integer>();
Scanner in = new Scanner(System.in);
String line = in.nextLine();
if(line != null && !line.isEmpty()) {
int res = resolve(line.trim());
System.out.println(String.valueOf(res));
}
}
// write your code here
public static int resolve(String expr) {
int size = 16;
String[] stack = new String[size];
int top = -1;
String[] paras = expr.split("\\s+");
for(String para: paras){
if(para.equals("^")){
if(top < 0){
return -1;
}
int tmp = Integer.parseInt(stack[top--]);
tmp++;
stack[++top] = String.valueOf(tmp);
}else if(para.equals("*")){
if(top < 1){
return -1;
}
int tmp1 = Integer.parseInt(stack[top--]);
int tmp2 = Integer.parseInt(stack[top--]);
int tmp3 = tmp1*tmp2;
stack[++top] = String.valueOf(tmp3);
}else if(para.equals("+")){
if(top < 1){
return -1;
}
int tmp1 = Integer.parseInt(stack[top--]);
int tmp2 = Integer.parseInt(stack[top--]);
int tmp3 = tmp1+tmp2;
stack[++top] = String.valueOf(tmp3);
}else {
if(top==15){
return -2;
}
stack[++top] = para;
}
}
return Integer.parseInt(stack[top]);
}
}
我这个代码提交之后显示通过了。
题目二
- 1.题目要求
大概意思就是进行模式匹配。
其中 * 表示可以匹配任意个字符
? 表示匹配一个字符
如字符串是
200-trade-done
模式为
2*trade?done
这样则匹配成功,应该输出1
再如,字符串:
100-trade-fail
模式为
200?*trade-fail
这样则匹配失败,应该输出0。
输入:
第一行,需要过滤的字符串 第二行,匹配模式
输出:
匹配结果,匹配成功返回1,匹配失败返回0
- 2.分析
我觉得这个可以一个个字符去看,用模式来和字符串进行一步步的匹配。
分别用来个“指针”,开始时分别指向字符串和模式的首字符,然后判断模式的字符。
如果是“?”,则不需要比较,两个指针直接往后挪一位
如果是“*”,则在字符串中依次往后查找,直到找到某个字符和模式中的下一个字符相同为止。
如果是其他字符,则比较模式和字符串当前位置的字符是否相同,相同则继续往后挪,不同则终止。
最后判断两个指针是否都过了最末尾,如果都过了,说明匹配成功了。如果没到,说明匹配失败了。
package alibaba;
import java.util.Scanner;
public class Main3 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
String pattern = in.nextLine();
//System.out.println(pattern.length());
int strIndex = 0, patternIndex = 0;
while(strIndex<str.length() && patternIndex<pattern.length()){
if(pattern.charAt(patternIndex) == '?'){
strIndex++;
patternIndex++;
}else if (pattern.charAt(patternIndex) == '*') {
while((patternIndex+1)<pattern.length() && strIndex<str.length() && pattern.charAt(patternIndex+1) != str.charAt(strIndex)){
strIndex++;
}
patternIndex++;
}else {
if(pattern.charAt(patternIndex) == str.charAt(strIndex)){
strIndex++;
patternIndex++;
}else {
break;
}
}
}
if(strIndex==str.length() && patternIndex==pattern.length()){
System.out.println(1);
}else {
System.out.println(0);
}
}
}
但我这样的想法是错的,如输入:
200 - trade- - -done
200*-done
应该是匹配成功,正确的输出是1。
但我的输出是0。
- 我也不知道该怎么样处理了。难点就在于如何实现 *匹配任意多个字符。
- 我百度了一下,也没有找到相应的解决方案。有一个文字写了,但我不是太懂,实现一个正则表达式匹配算法,.匹配任意一个字符,*匹配0个或者多个前导字符
在牛客网上看到了一个类似的题目,从他人的回答中 披萨大叔的回答 我找到了一些灵感。我觉得可以用递归的方法去进行*的匹配,这样就可以实现了。直接上代码,我觉得从代码中就可以看清其中的思想。
package alibaba;
import java.util.Scanner;
public class Main4 {
public static boolean match(char[] str, char[] pattern){
int strIndex = 0;
int patternIndex = 0;
return match(str, strIndex,pattern,patternIndex);
}
public static boolean match(char[] str, int strIndex, char[] pattern, int patternIndex){
//两个都匹配到了最后位置之后,说明已经全部匹配了,返回true
if(patternIndex==pattern.length && strIndex==str.length){
return true;
}
//模式串到达了最后,但是源字符串还未匹配完,返回false
if(patternIndex==pattern.length && strIndex<str.length){
return false;
}
//源字符串到达了最后,但是模式串还未匹配完,则继续看模式串的字符,如果不是*,则一定是false;否则有可能匹配成功,要继续看模式串后面的字符
if(patternIndex<pattern.length && strIndex==str.length){
if(pattern[patternIndex] != '*') return false;
else {
return match(str, strIndex,pattern,patternIndex+1);
}
}
//模式串和源字符串都还未匹配完,要根据模式串的字符进行判断
if(patternIndex<pattern.length && strIndex<str.length){
if(pattern[patternIndex] == '?'){// ?则直接都往后判断
return match(str, strIndex+1,pattern,patternIndex+1);
}else if (pattern[patternIndex] == '*') {// *有两种情况,一种是*代表0个匹配字符,模式串往后移动一个;另一种是代表一个任意字符,*保持,源字符串继续往后
return match(str, strIndex,pattern,patternIndex+1) || match(str, strIndex+1,pattern,patternIndex);
}else {// 其他字符则比较模式串字符和源字符串字符是否相同,相同继续往后比较,不同直接返回false
if(pattern[patternIndex] == str[strIndex]){
return match(str, strIndex+1,pattern,patternIndex+1);
}else {
return false;
}
}
}
return true;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String srcStr = in.nextLine();
String srcPattern = in.nextLine();
char[] str = srcStr.toCharArray();
char[] pattern = srcPattern.toCharArray();
boolean isMatch = match(str, pattern);
if(isMatch){
System.out.println(1);
}else {
System.out.println(0);
}
}
}
我在本地运行之后测试了题目中的例子全部通过,但我也不确定是不是完全正确。。。我觉得思想应该是对的。。