java连续最大和统计回文

Posted 2023-03-30 奋斗小温

目录

1.连续最大和

2.统计回文

---

1.连续最大和

链接：连续最大和_牛客题霸_牛客网 (nowcoder.com)

描述：一个数组有 N 个元素，求连续子数组的最大和。 例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3

输入描述：输入为两行。 第一行一个整数n(1 <= n <= 100000)，表示一共有n个元素 第二行为n个数，即每个元素,每个整数都在32位int范围内。以空格分隔。

输出描述：所有连续子数组中和最大的值。

示例1

输入：

3

-1 2 1

输出：

3

🔎做题思路：使用 动态规划 来完成这个代码

状态方程式：max(dp[i]) = getMax(max(dp[i-1]) + arr[i], arr[i])             dp[i]：以 i 结尾的子数组最大和

会涉及到一个以上的状态方程式，接下来我们来仔细分析一下，求 dp[i] 的时候有两种情况

1️⃣dp[i] = dp[i - 1] + arr[i]

2️⃣arr[i]

    import java.util.Scanner;
    public static int getMax(int a, int b) 
        return a > b ? a : b;//找两个数的最大值
    

    public static void main(String[] args) 
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//首先需要定义n
        int[] arr = new int[n];//定义一个数组
        for (int i = 0; i < n; i++) 
            arr[i] = scanner.nextInt();
        

        int cur = arr[0];//连续子数组和
        int max = arr[0];//当前最大子数组和

        for (int i = 1; i < n; i++) 
            cur = getMax(cur + arr[i], arr[i]);//判断两个值的最大值
            if (cur > max) 
                max = cur;
            
        
        System.out.println(max);
    

2.统计回文

链接：统计回文_牛客题霸_牛客网 (nowcoder.com)

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少种插入办法可以使新串是一个回文串。如果字符串B插入的位置不同就考虑为不一样的办法。
例如：
A = “aba”，B = “b”。这里有4种把B插入A的办法：
* 在A的第一个字母之前: "baba" 不是回文
* 在第一个字母‘a’之后: "abba" 是回文
* 在字母‘b’之后: "abba" 是回文
* 在第二个字母'a'之后 "abab" 不是回文
所以满足条件的答案为2

输入描述：每组输入数据共两行。 第一行为字符串A 第二行为字符串B 字符串长度均小于100且只包含小写字母

输出描述：输出一个数字，表示把字符串B插入字符串A之后构成一个回文串的方法数

示例1

输入：

aba

b

输出：2

🔎做题思路：逆置

1️⃣在合适的位置插入

2️⃣通过 逆置 判断是否为回文

在进行逆置的时候需要注意的是：❗❗❗1️⃣只有 StringBuffer 和 StringBuilder 有逆置，并且不可以直接逆置，直接逆置会将学原来的StringBuffer也逆置，只能重新定义一个StringBuffer

2️⃣逆置相比较的时候，不可以直接使用equals，因为StringBuffer不是字符串类型，需要用to.String变成字符串类型

import java.util.Scanner;

public class Main 
    //做题思路：逆置
    //1️⃣在合适的位置插入
    //2️⃣通过 逆置 判断是否为回文
    //在进行逆置的时候需要注意的是：❗❗❗只有 StringBuffer 和 StringBuilder 有逆置，
    // 并且逆置相比较的时候，不可以直接使用equals，因为StringBuffer不是字符串类型，需要用to.String变成字符串类型

    Scanner scanner = new Scanner(System.in);
        String str1 = scanner.nextLine();
        String str2 = scanner.nextLine();

        int len = str1.length();
        int count = 0;

        for (int i = 0; i <= len; i++) //可以放在最后，所以i <= len
            StringBuffer str3 = new StringBuffer(str1);
            str3.insert(i, str2);//在str3的每一个位置都插入str2

            //只有 StringBuffer 和 StringBuilder 有逆置，并且不可以直接逆置，如果直接str3.reverse，那么str3也将会逆置，只能重新第一一个StringBuffer
            StringBuffer str4 = new StringBuffer(str3);
            StringBuffer str5 = str4.reverse();
            //逆置相比较的时候，不可以直接使用equals
            //因为StringBuffer不是字符串类型，需要用to.String变成字符串类型
            if (str5.toString().equals(str3.toString())) 
                count++;
            
        
        System.out.println(count);
    

素数，回文，统计单词

素数

设计思想

 按照除k取余的思想，循环进行除法取余数，余数为零表示可以被其他数整出，则不是素数。

package numbe;

import java.util.Scanner;

public class Prime {

    public static void main(String[] args) {
        int i = 0;
        System.out.println("1. 3-100 2. 任意两数 3. 最大十个和最小十个");
        Scanner sc = new Scanner(System.in);
        i = sc.nextInt();
        switch (i) {
        case 1:
            isprime();
            break;
        case 2:
            isprime1();
            break;
        case 3:
            isprime2();
            break;
        }
    }

    public static void isprime() {
        int n;
        int i = 2;
        int m = 0;
        for (n = 3; n >= 3 && n <= 100; n++) {
            int j = 0;
            if (n % 2 == 0)
                j = 1;
            for (i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0)
                    j = 1;
            }
            if (j == 0) {
                m++;
                System.out.print(n + "  ");
                if (m % 5 == 0)
                    System.out.println();
            }
        }
        System.out.println();
    }

    public static void isprime1() {
        System.out.println("请输入两个整数：");
        Scanner sc = new Scanner(System.in);
        int num1, num2;
        System.out.println("number1:");
        num1 = sc.nextInt();
        System.out.println("number2:");
        num2 = sc.nextInt();
        int n;
        int i = 2;
        int m = 0;
        for (n = num1; n >= num1 && n <= num2; n++) {
            int j = 0;
            if (n % 2 == 0)
                j = 1;
            for (i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0)
                    j = 1;
            }
            if (j == 0) {
                m++;
                System.out.print(n + "  ");
                if (m % 5 == 0)
                    System.out.println();
            }
        }
    }

    public static void isprime2() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数：");
        int num1, num2;
        System.out.println("number1:");
        num1 = sc.nextInt();
        System.out.println("number2:");
        num2 = sc.nextInt();
        System.out.println("十个最小：");
        int n;
        int i = 2;
        int m = 0;
        int k = 0;
        int a[] = new int[100];
        for (n = num1; n >= num1 && n <= num2; n++) {
            int j = 0;
            if (n % 2 == 0)
                j = 1;
            for (i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0)
                    j = 1;
            }
            if (j == 0) {
                m++;
                a[m] = n;
                if (m <= 10)
                    System.out.print(a[m] + "  ");
            }
        }
        System.out.println();
        System.out.println("十个最大：");
        for (k = m - 10; k <= m; k++) {
            System.out.print(a[m] + "  ");
        }

    }
}

素数

结果截图

 

总结

输出时换行出现异常，通过更改换行位置实现了正常输出。

使用数组实现了最大十个和最小十个数的输出。

回文

设计思想

从键盘随意输入一个字符串，并将其赋值给一个数组，然后用递归进行，否则从数组的首元素与尾元素进行比较，若相等，则进行i++与j--，不断向中间靠拢，直到达到判断条件i>=j(i=j是输入的字符串的长度为偶数个，i>j是输入的字符串有奇数个)，中间若有一次不符合判断，直接跳出递归，结束进程，输出不是回文字符串。（i是指的字符串的第一个元素的下标，j是指的字符串的最后一个元素的下标）

package 回文;

import java.util.Scanner;

public class Huiwen {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s;
        int j;
        int i = 0;
        Scanner input = new Scanner(System.in);
        System.out.println("请输入 一个字符串：");
        s = input.next();
        char a[];
        a = s.toCharArray();
        j = a.length - 1;
        for (int k = 0; k < s.length(); k++) {
            System.out.print(a[k]);
        }
        huiwen(a, j, i);
    }

    public static void huiwen(char a[], int j, int i) {
        if (i >= j) {
            if (a[i] == a[j])

                System.out.println("是回文");
            System.exit(0);
        }
        if (a[i] == a[j])
            huiwen(a, --j, ++i);
        else {
            System.out.println("不是回文！");
            System.exit(0);
        }
    }
}

回文

实验截图

统计单词

设计思路

每遇到段落中的空格和标点，便生成一个新的单词，与之前的单词进行比较，并在总数加一

package 统计单词;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Statistical {
    
    public static void main(String[] args){
        File file = new File("D:/test.txt");
        String text =txtString(file);
        findEnglishNum(text);
        }
    
    public static String txtString(File file){
        StringBuilder result = new StringBuilder();
   try{
       BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
       String s = null;
       while((s = br.readLine())!=null){//使用readLine方法，一次读一行
           result.append(s/*+System.lineSeparator()*/);
       }
       br.close();    
   }catch(Exception e){
       e.printStackTrace();
   }
   return result.toString();
}
public static void findEnglishNum(String text){
    //找出所有的单词
    String[] array = {".", " ", "?", "!"};
        for (int i = 0; i < array.length; i++) {
            text = text.replace(array[i],",");
        }
        String[] textArray = text.split(",");
        //遍历 记录
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (int i = 0; i < textArray.length; i++) {
            String key = textArray[i];
            //转为小写
            String key_l = key.toLowerCase();
            if(!"".equals(key_l)){
                Integer num = map.get(key_l);
                if(num == null || num == 0){
                    map.put(key_l, 1);
                }else if(num > 0){
                    map.put(key_l, num+1);
                }
            }
        }
        //输出到控制台
        System.out.println("各个单词出现的频率为：");
        Iterator<String> iter = map.keySet().iterator();
        while(iter.hasNext()){
            String key = iter.next();
            Integer num = map.get(key);
            System.out.println(key + "	" + num + "次");
        }
    }
}

单词

实验截图

总结

没有实现出现最多次数和最少次数的统计