字符串处理问题

回文子串的个数

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
("回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。)
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被计为是不同的子串。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        String s2 = sc.nextLine();
        String[] split1 = s1.split("");
        String[] split2 = s2.split("");
        int m = split1.length;
        int n = split2.length;
        int[][] array = new int[m][n];
        array[0][0]=split1[0].equals(split2[0])?0:1;
        for (int i = 1; i < m; i++) {
           if (split1[i].equals(split2[0])){
               array[i][0]=array[i-1][0];
           }else {
               array[i][0]=array[i-1][0]+1;
           }
        }
        for (int j = 1; j < n; j++) {
            if (split2[j].equals(split1[0])){
                array[0][j]=array[j-1][0];
            }else {
                array[0][j]=array[j-1][0]+1;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (split1[i].equals(split2[j])){
                    array[i][j]=Math.min(Math.min(array[i-1][j],array[i][j-1]),array[i-1][j-1]);
                }else {
                    array[i][j]=Math.min(Math.min(array[i-1][j],array[i][j-1]),array[i-1][j-1])+1;
                }
            }
        }
        System.out.println(array[m-1][n-1]);
    }
}

字符串归一化

通过键盘输入一串小写字母(a~z)组成的字符串。
请编写一个字符串归一化程序，统计字符串中相同字符出现的次数，并按字典序输出字符及其出现次数。
例如字符串"babcc"归一化后为"a1b2c2"

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        char[] chars = s.toCharArray();
        int[] array = new int[26];
        for (char a : chars) {
            array[a-97]+=1;
        }
        String str="";
        for (int i = 0; i < array.length; i++) {
            if (array[i]!=0){
                char c=(char)(i+97);
                str=str+""+c+""+array[i];
            }
        }
        System.out.println(str);
    }
}

计算字符串表达式结果

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Scanner;


public class Main {
    public static void main(String[] args) throws ScriptException {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        ScriptEngineManager sem = new ScriptEngineManager();
        ScriptEngine js = sem.getEngineByName("js");
        Object eval = js.eval(s);
        System.out.println(eval);
    }
}

回文素数

import java.util.Scanner;

public class Main3 {
    public static boolean issushu(int num){

        if(num%2==0){
            return false;
        }
        int a=num/2;
        for (int i = 2; i < a; i++) {
            if(num%i==0){
                return false;
            }
        }
        return true;
    }
    public static boolean ishuiwen(int num){
        String s = String.valueOf(num);
        String[] split = s.split("");
        for (int i = 0; i < split.length/2; i++) {
            if(!split[i].equals(split[split.length-1-i])){
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[] split = s.split(" ");
        int m=Integer.parseInt(split[0]);
        int n=Integer.parseInt(split[1]);
        int count=0;
        if(m>=1&&n<1000&&m<=n){
            for (int i=m;i<=n;i++){

                if(ishuiwen(i)&&issushu(i)){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}

中缀表达式转后缀表达式

遍历字符串，如果为字母就输出；如果为运算符，此时栈为空就放入，如果不为空则判断栈顶运算符优先级是否小于当前运算符，如果小于就将当前元素压入栈，如果不小于就将栈中的元素全部弹出在将当前元素压入栈。

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        Stack<Character> stack = new Stack<>();
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if ('a' <= c && c <= 'z') {
                str.append(c);
            } else if (c == '+' || c == '-') {
                if (stack.empty()){
                    stack.push(c);
                }else {
                    while (!stack.empty()){
                        str.append(stack.pop());
                    }
                    stack.push(c);
                }
            } else if (c == '*' || c == '/') {
               if (stack.empty()){
                   stack.push(c);
               }else if (stack.peek()=='+'||stack.peek()=='-'){
                   stack.push(c);
               }else {
                   str.append(stack.pop());
                   stack.push(c);
               }
            }
        }
        while (!stack.empty()){
            str.append(stack.pop());
        }

        System.out.println(str.toString());
    }
}