一些Java的OJ练习：只说不练，假把式！（验证回文串、字符串中的第一个唯一字符、最后一个单词的长度、统计字符串中的单词数、轮转数组、自定义异常类型：简单的控制台版用户登陆程序）

已于 2023-05-30 09:26:03 修改
阅读量189 收藏
点赞数
分类专栏： 初阶Java 易错知识点 文章标签： java 算法 字符串 数据结构
于 2023-05-14 14:27:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74343467/article/details/130665849
版权

Java初阶已经学完了，但是没有实践的学习只算“纸上谈兵”，不是真本事。

很多知识点和易错点都只有在真实的练习中才能体现出来，只有实践才可以成就真正的“程序员”！

博主作为Java小白，先从最简单的一些练习做起，毕竟只是刚刚了解了大概的Java语法嘛。同样处于学习过程的大家可以一起来做做看，我附上了自己最开始写的一些有问题的代码和相应的出错原因，当然也给出了正确的解答。希望对你有帮助！

1、给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

/*例如：

输入: nums = [1,2,3,4,5,6,7], k = 3

输出: [5,6,7,1,2,3,4]

解释: 向右轮转 1 步: [7,1,2,3,4,5,6] ；向右轮转 2 步: [6,7,1,2,3,4,5]； 向右轮转 3 步: [5,6,7,1,2,3,4]*/

这是我最开始写的代码：

public class Main {
    public static void main(String[] args) {
        int[] nums={3,0,1,4,6,5,7};
        Scanner scanner=new Scanner(System.in) ;
        int k=scanner.nextInt();
        Solution1 solution=new Solution1();
        solution.rotate(nums,k);
        for (int n=0;n<nums.length;n++){
            System.out.print(nums[n]+" ");
        }
    }
}
class Solution1 {
        public void rotate(int[] nums, int k) {
            //[1,2,3,4,5,6,7]
            // 7 6 5 4 3 2 1
            // 7 1 2 3 4 5 6
            //6 5 4 3 2 1 7
            //6 7 1 2 3 4 5
            //……
        for (int i=1;i<k+1;i++){
                reverse(nums, 0, nums.length - 1);
                reverse(nums, 1, nums.length-k-1);
             }

        }  
        public void reverse(int[] nums, int left, int right) {
            while (left < right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left += 1;
                right -= 1;
            }
        }
    }

我觉得我的思路是没有什么大问题的，但是测试通过率是：37/38；测试系统给出的一个实例：

[477181,661861,837383,492412,935349,84343,723642,678340,123214,484282,473991,823195,247179,206529,724472,412154,590105,808986,800645,235405,952307,620444,491813,406073,973100,847153,143198,395544,6169...]

显示超出了时间限制。

原因如下：

这段代码出现超时的问题是因为我用 for 循环反转了整个数组两次，但是实际上只需要反转一次即可。

解决方法：

尝试将 for 循环改为如下形式：

k %= nums.length; // 处理 k 大于数组长度的情况
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);

其中，k %= nums.length 可以确保 k 的值小于数组长度，reverse(nums, 0, nums.length - 1) 用于反转整个数组，reverse(nums, 0, k - 1) 用于反转前半部分数组，reverse(nums, k, nums.length - 1) 用于反转后半部分数组。这样，只需要反转三次数组即可完成旋转。

2、统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: "Hello, my name is John"

输出: 5

解释: 这里的单词是指连续的不是空格的字符，所以 "Hello," 算作 1 个单词。

答题链接：https://leetcode.cn/problems/number-of-segments-in-a-string/

我先写的是这样的：

    class Solution2 {
        public int countSegments(String s) {
            if(s==null||s.length()==0) {
                return 0;
            }
            int count=0;
            String[] str=s.split(" ");
            //注意，这里str已经是数组了，不可以用str.length();
            for(int i=0;i<str.length;i++){
                if(!str[i].equals(" ")){
                    count++;
                }
            }
            return count;
        }
    }

 无法通过所有实例：比如“，，，           a   casdf  ”

这是因为我的测试字符串中存在多个空格连在一起的情况，这时候 split(" ") 会将其识别为多个空字符串，导致统计单词个数时计算错误。可以考虑将 split 方法改为使用正则表达式 split("\\s+")，这样可以将多个连续空格识别为一个分隔符。修改后的代码如下：

String[] str=s1.split("\\s+");

我又试了一次，还是有问题：

无法通过：“   ，     a    wonderful s     ,,,    ” 

原来，上述代码仍然无法处理字符串两端有空格的情况，如果需要处理这种情况，我们要在进行 split 操作前使用 trim 方法将字符串两端的空格删除。

class Solution {
    public int countSegments(String s) {
        if(s==null||s.length()==0) {
            return 0;
        }
        int count=0;
        String s1=s.trim();
        String[] str=s1.split("\\s+");
        for(int i=0;i<str.length;i++){
            if(!str[i].equals(" ")){
                count++;
            }
        }
        return count;
    }
}

啊救命！！！还是出问题了，显示无法通过：“               ”

原来，如果字符串只包含空格，则使用 trim() 方法将字符串两端的空格删除后会变为空字符串 ""。

所以我们应该把trim（）的运用提前：

class Solution {
    public int countSegments(String s) {
        String s1=s.trim();
        if(s1==null||s1.length()==0) {
            return 0;
        }
        int count=0;
        String[] str=s1.split("\\s+");
        for(int i=0;i<str.length;i++){
            if(!str[i].equals(" ")){
                count++;
            }
        }
        return count;
    }
}

最后再试了一次，没有问题了！ 

可是运行时间也太长了吧……

可能是因为我的代码在处理长字符串时，使用了多次字符串分割和循环判断，导致效率较低。特别是如果字符串中有大量连续的空格，就会产生很多无效的字符串分割和循环判断，进而影响运行时间。

另外，Java 的 String 类是不可变类，当我对字符串进行分割时，其实是生成了新的字符串数组对象，而不是在原有字符串上直接修改，这也会导致额外的内存开销。

为了提高效率，可以考虑使用指针或索引来扫描字符串，从而减少不必要的字符串操作和对象创建。例如，可以使用两个指针 start 和 end 分别指向单词的起始和结束位置，然后移动这两个指针来识别单词，并计数。

下面是一个使用指针的例子：

class Solution {
    public int countSegments(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int count = 0;
        int start = 0;
        int end = 0;
        while (start < s.length()) {
            // 移动指针直到找到单词的起始位置
            while (start < s.length() && s.charAt(start) == ' ') {
                start++;
            }
            // 如果已经到达字符串末尾，直接退出循环
            if (start == s.length()) {
                break;
            }
            // 移动指针直到找到单词的结束位置
            end = start;
            while (end < s.length() && s.charAt(end) != ' ') {
                end++;
            }
            // 计数器加一
            count++;
            // 移动指针到下一个单词的起始位置
            start = end;
        }
        return count;
    }
}

 好多了：

 有没有其他的更好的解决方案？

public int countSegments(String s) {
    if (s == null || s.length() == 0) {
        return 0;
    }
    int count = 0;
    boolean inWord = false;
    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) != ' ') {  // 遇到非空格字符
            if (!inWord) {  // 如果不在单词内部
                inWord = true;  // 开始了一个新单词
                count++;  // 单词数加1
            }
        } else {  // 遇到空格字符
            inWord = false;  // 结束当前单词
        }
    }
    return count;
}

3、实现一个简单的控制台版用户登陆程序, 程序启动提示用户输入用户名密码. 如果用户名密码出错, 使用自定义异常的方式来处理 

import java.util.Scanner;

public class Test {
    private String userName = "Dooorraaa";
    private String password = "888888888";
    public static void loginInfo(String userName, String password)
            throws UserNameException,PasswordException{
        Test test=new Test();
        if (!userName.equals(test.userName)) {
            throw new UserNameException("用户名错误！");
        }
        if (!password.equals(test.password)) {
            throw new PasswordException("密码错误！");
        }
        System.out.println("登陆成功");
    }
    public static void main(String[] args) {
        System.out.println("******欢迎登陆！！！*******");
        Scanner scanner=new Scanner(System.in);
        System.out.println("******请输入用户名：》》》");
        String name = scanner.nextLine();
        System.out.println("******请输入密码：》》》");
        String password =scanner.nextLine();

        try {
            loginInfo(name, password);
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }

}
class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends Exception {
    public PasswordException(String message) {
        super(message);
    }
}

这里需要注意：

 Test test=new Test();
        if (!userName.equals(test.userName)) {
            throw new UserNameException("用户名错误！");
        }
        if (!password.equals(test.password)) {
            throw new PasswordException("密码错误！");
        }
        System.out.println("登陆成功");

需要实例化一个对象，因为在静态方法里面不可以出现：this。

4、给定一个字符串 s ，找到它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 ，其中s 只包含小写字母。

我一开始写的有点问题，你能找出来吗？

    public int firstUniqChar(String s) {
        char[] charrr=s.toCharArray();
        int [] array=new int[26];
        for(int i=0;i<charrr.length;i++){
                int ret=(int)(charrr[i]-'a');
                array[ret]++;
        }
        for(int j=0;j<array.length;j++){
            if(array[j]==1){
                return j;
            }
        }
        return  -1;
    }

最后一个循环出问题了！！！

我们要返回的是“第一个没有重复的字母”，而不是“其中一个没有重复的字母”，所以遍历的应该是原来的那个字符数组，而不是我们的计数器字符数组！！！ 

class Solution {
    public int firstUniqChar(String s) {
        char[] charrr=s.toCharArray();
        int [] array=new int[26];
        for(int i=0;i<charrr.length;i++){
                int ret=(int)(charrr[i]-'a');
                array[ret]++;
        }
        for(int j=0;j<charrr.length;j++){
            if(array[charrr[j]-'a']==1){
                return j;
            }
        }
        return  -1;
    }
}

//或者直接用字符串
public int firstUniqChar(String s) {
        int[] array = new int[26];
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isLowerCase(c)) {
                int index = c - 'a';
                array[index]++;
            }
        }
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isLowerCase(c) && array[c - 'a'] == 1) {
                return i;
            }
        }
        return -1;
    }

5、计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。

（注：字符串末尾不以空格为结尾）

输入描述： 输入一行，代表要计算的字符串，非空，长度小于5000。

输出描述： 输出一个整数，表示输入字符串最后一个单词的长度。

class Main2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { 
        // 注意 while 处理多个 case
            String wordLine=in.nextLine();
            int ret= 
 wordLine.substring(wordLine.lastIndexOf("")+1,wordLine.length()).length();
            System.out.println(ret);
        }
    }
}

6、如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个回文串 。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是回文串，返回 true；否则，返回 false 。

我一开始用了一个很笨的办法：

class Solution6 {
    public boolean isPalindrome(String s) {
        String str=s.toLowerCase();
        char[] array=new char[str.length()];
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)>='a'&&str.charAt(i)<='z'&&str.charAt(i)>='0'&&str.charAt(i)<='9'){
                array[array.length-i-1]=str.charAt(i);
            }
        }
        char[] array2=new char[str.length()];
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)>='a'&&str.charAt(i)<='z'&&str.charAt(i)>='0'&&str.charAt(i)<='9'){
                array2[i]=str.charAt(i);
            }
        }
        for(int j=0;j<array.length;j++){
            if(array[j]!=array2[j]){
                return false;
            }
        }
        return true;
    }
}

这个方法不仅有三个循环，而且在第一个循环中，倒序遍历字符串时，对于非字母数字字符（如标点符号），本来应该跳过，但是我直接把对应的位置赋值为空格：

array[array.length-i-1]=str.charAt(i);

所以运行无法通过。

就算改正了：

        public boolean isPalindrome(String s) {
            String str=s.toLowerCase();
            char[] array=new char[str.length()];
            for(int i=0;i<str.length();){
                if(str.charAt(i)>='a'&&str.charAt(i)<='z'&&str.charAt(i)>='0'&&str.charAt(i)<='9'){
                    array[array.length-i-1]=str.charAt(i);
                    i++;
                }
            }
            char[] array2=new char[str.length()];
            for(int i=0;i<str.length();){
                if(str.charAt(i)>='a'&&str.charAt(i)<='z'&&str.charAt(i)>='0'&&str.charAt(i)<='9'){
                    array2[i]=str.charAt(i);
                    i++;
                }
            }
            for(int j=0;j<array.length;j++){
                if(array[j]!=array2[j]){
                    return false;
                }
            }
            return true;
        }

也还是……

所以还是得改进。除此之外， 我们也可以选择使用 Character.isLetterOrDigit 方法来判断是否为字母数字字符。

另外，在第二个循环中，我们只需要遍历到第一个数组的有效长度 index 即可。 

class Solution {
    public boolean isPalindrome(String s) {
        String str=s.toLowerCase();
        char[] array=new char[str.length()];
        int index = 0;
        for(int i=0;i<str.length();i++){
            if(Character.isLetterOrDigit(str.charAt(i))){
                array[index++]=str.charAt(i);
            }
        }
        char[] array2=new char[index];
        for(int i=0;i<index;i++){
            array2[i]=array[index-i-1];
        }
        for(int j=0;j<index;j++){
            if(array[j]!=array2[j]){
                return false;
            }
        }
        return true;
    }
}

还有没有可以改进的？

两个循环可以合并成一个，同时进行回文判断。一个指针从头开始遍历字符串，另一个指针从尾部开始，循环条件是左边的指针小于右边的指针。每次比较两个指针对应位置上的字符是否相同即可。如果有不相同的字符，就说明不是回文串，返回 false。

class Solution7 {
    public static boolean isValidChar(char ch){
        if((ch >= 'a' && ch <= 'z') ||
                (ch >= '0' && ch <= '9')){
            return true;
        }
        return false;
    }
    public boolean isPalindrome(String s) {
        // 将大小写统一起来
        s = s.toLowerCase();
        int left = 0, right = s.length()-1;
        while(left < right){
           // 1. 从左侧找到一个有效的字符
            while(left < right && !isValidChar(s.charAt(left))){
                left++;
            }
            // 2. 从右侧找一个有效的字符
            while(left < right && !isValidChar(s.charAt(right))){
                right--;
            }
            if(s.charAt(left) != s.charAt(right)){
                return false;
            }else{
                left++;
                right--;
            }
        }
        return true;
    }
}

di-Dora
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OJ_将数组中的字符串按指定长度重新分割
05-16
标题“OJ_将数组中的字符串按指定长度重新分割”涉及的是一个在线编程挑战（OJ，Online Judge）的问题，其核心是处理字符串数组，并按照特定的长度要求进行分割。这个问题主要涵盖以下知识点： 1. **字符串操作**：...
OJ_在字符串中找出连续最长的数字串
05-16
dp[0]设置为1，如果第一个字符是数字。 - 遍历字符串，对于每个字符，如果它是数字，那么dp[i]可能是dp[i-1]+1，否则dp[i]保持不变。 - 最长数字串的长度即为dp数组中的最大值。 无论是滑动窗口还是动态规划，都...
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
少说，多做。
04-20 11万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
OJ-leetcode找不同（简单统计）
关注网络安全、云原生安全
12-20 1205
题目 给定两个字符串 s 和 t，它们只包含小写字母。 字符串t由字符串s随机重排，然后在随机位置添加一个字母。 请找出在 t 中被添加的字母。 示例 1： 输入：s = "abcd", t = "abcde" 输出："e" 解释：'e' 是那个被添加的字母。 示例 2： 输入：s = "", t = "y" 输出："y" 示例 3： 输入：s = "a", t = "aa" 输出："a" 示例 4： 输入：s = "ae", t = "aea" 输出："a...
Comet OJ - Contest #8
lahlah的博客
08-10 321
Comet OJ - Contest #8 第一次打，感觉好赤鸡 然后就凉了 T1 大意就是说给出n个字符串，然后求出字典序最小的那个 ……这也太签到了吧 T2 给出一个www数组，对每个xxx求 ∑i=1n(wi−wx)2\sum_{i=1}^n{(w_i-w_x)^2}∑i=1n​(wi​−wx​)2 把式子拆开一下就是道水题了呀 T3 题意就是给出n个二元组(ai, bi)(a_i...
bzoj训练记录
OZY的博客
01-16 1029
懒得写这么多博客了。。 开个坑记录一下 也许写着写着就断更了 那就断更的时候再说吧 默认没写oj的就是bzoj，如果是别的再另开吧 4377: [POI2015]Kurs szybkiego czytania 并不是很会。。 容易发现，每一个数都会出现且恰好出现一次。。 然而我不是很知道这个有什么用2333 这个的用处在于，以iii开头的序列是唯一的 因此，对于每一个开头xxx，我们可以分别考虑 ...
【数据结构第2.5讲（栈和队列）】
Undefined__yu的博客
08-07 348
栈和队列知识点+接口实现+LeetcodeOJ题目讲解一条龙
数据结构大全(一)
hzp666的博客
04-22 692
目录 顺序存储线性表实现 单链表不带头标准c语言实现 单链表不带头压缩c语言实现 约瑟夫环-(数组、循环链表、数学) 线性表表示集合 线性表实现一元多项式操作 链表环问题 移除链表元素 回文链表 链表表示整数，相加 LRU LFU 合并链表 反转链表 反转链表2 对链表排序 旋转链表 数组实现栈 链表实现栈 数组实现队列 链表实现队列 双栈的实现 栈/队列 互相模拟实现 栈的排序 栈——括号匹配 栈——表达式求值 借汉诺塔理...
ZJOI2019一轮停课刷题记录
weixin_30920597的博客
02-27 713
Preface 菜鸡HL终于狗来了他的省选停课，这次的时间很长，暂定停到一试结束，不过有机会二试的话还是可以搞到4月了 这段时间的学习就变得量大而且杂了，一般以刷薄弱的知识点和补一些新的奇怪技巧为主。 偶尔也会打一些比赛找找手感（比如HHHOJ的比赛，Luogu比赛，以及comet OJ上之前的CCPC题） CF和CC看情况，主要是我真的不太喜欢读英文题的恐怖感觉233 希望这段时间的努...
编程比赛 介绍 入门 及 学习路线
weixin_45940369的博客
06-06 1879
学编程切记绝对不能偷懒！！！看课和刷题是必要的，越勤越多越好！！！编程思维是学和练出来的，没有其他任何捷径！！！光说不练假把式,光练不说傻把式,又练又说真把式。借助工具来学习，减少无效时间的浪费，比如chatgpt（百度搜索 “chatgpt镜像网站” ，选一个就行），哪里不懂都问它。
2019年一月刷题列表
weixin_30436101的博客
01-05 282
Preface 新的一年来了，像我这样的菜鸡马上就要褪去初中蒟蒻的身份成为一名高中蒟蒻了。 \(WC\)没得去，只能在机房苟着\(ZJOI\)，还是不要放弃希望吧。 老叶说省选如果可以水到全省前40（不存在的）可能可以去SC 不管了反正还没有退役，争取苟活吧。 List 【pG&&CYH-01】元旦联欢会 最近不知道刷什么题所以就撸一撸比赛。主要没什么时间打，随便找了...
java实现求两个字符串最长公共子串的方法
09-03
在编程领域，求解两个字符串的最长公共子串是一个经典问题，主要应用于文本处理、比较和搜索算法。这里我们将深入探讨如何使用Java实现这一方法，同时结合华为在线判题平台（OJ）的要求来编写代码。 首先，我们需要...
OJ_判断字符串类型
05-16
在编程领域，尤其是在线判题系统（Online Judge，简称OJ）中，判断字符串类型是一项常见的任务。这个题目“OJ_判断字符串类型”可能是要求编写一个程序，用于分析输入的字符串并确定其特定的类型，如数字、字母、...
OJ_字符串加解密
05-16
1. **位操作**：在C语言中，我们可以利用位运算符（如按位与、按位或、按位异或和位移）对字符串的每个字符进行操作，实现自定义的加密。例如，可以通过将每个字符的ASCII码向右或向左移动一定位数，达到加密的效果...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 310
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1091
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 144
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 589
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
华为在线判题C++代码解析：字符串处理与算法实践
这段代码实现了一个函数`Num`，它接收一个字符串`a`和一个字符`b`，然后遍历字符串`a`，计算字符`b`出现的次数。在`main`函数中，程序读取用户输入的字符串`s`和目标字符`d`，调用`Num`函数并输出结果。这是对字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值