Java每日一练(20230511) 有效数字、重复元素II、类和子类

简介: Java每日一练(20230511) 有效数字、重复元素II、类和子类

1. 有效数字


有效数字(按顺序)可以分成以下几个部分:


  1. 一个 小数 或者 整数
  2. (可选)一个 'e''E' ,后面跟着一个 整数


小数(按顺序)可以分成以下几个部分:


   (可选)一个符号字符('+' 或 '-')


   下述格式之一:


       至少一位数字,后面跟着一个点 '.'


       至少一位数字,后面跟着一个点 '.' ,后面再跟着至少一位数字


       一个点 '.' ,后面跟着至少一位数字


整数(按顺序)可以分成以下几个部分:


   (可选)一个符号字符('+' 或 '-')


   至少一位数字


部分有效数字列举如下:


   ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]


部分无效数字列举如下:


   ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]

给你一个字符串 s ,如果 s 是一个 有效数字 ,请返回 true 。


示例 1:

输入:s = "0"

输出:true


示例 2:

输入:s = "e"

输出:false


示例 3:

输入:s = "."

输出:false


示例 4:

输入:s = ".1"

输出:true


提示:

   1 <= s.length <= 20

   s 仅含英文字母(大写和小写),数字(0-9),加号 '+' ,减号 '-' ,或者点 '.' 。

以下程序实现了这一功能,请你填补空白处内容:

```Java

class Solution {
    char[] chars;
    boolean point = false;
    boolean exponent = false;
    public boolean isNumber(String s) {
        s = s.trim();
        int length = s.length();
        if (length == 0) {
            return false;
        }
        chars = s.toCharArray();
        String[] ss = s.split("e");
        if (ss.length == 0) {
            return false;
        }
        if (ss[0].length() == 0)
            return false;
        if (ss[0].length() < length)
            exponent = true;
        if (ss[0].length() == length - 1) {
            return false;
        }
        String[] pre = ss[0].split("\\.");
        if (pre.length == 0) {
            return false;
        }
        if (pre[0].length() < ss[0].length())
            point = true;
        boolean result = pre(0, pre[0].length());
        result = result && middle(pre[0].length() + 1, ss[0].length());
        if (exponent) {
            result = result && is(ss[0].length() + 1, length);
        }
        return result;
    }
    ____________________________;
    public boolean middle(int i, int length) {
        if (i >= length && point) {
            if (chars[i - 2] >= '0' && chars[i - 2] <= '9') {
                return true;
            }
            return false;
        }
        for (; i < length; i++) {
            if (chars[i] < '0' || chars[i] > '9') {
                return false;
            }
        }
        return true;
    }
    public boolean is(int i, int length) {
        if (i == 1) {
            return false;
        }
        if (chars[i] == '+' || chars[i] == '-') {
            i++;
        }
        if (i == length) {
            return false;
        }
        for (; i < length; i++) {
            if (chars[i] < '0' || chars[i] > '9') {
                return false;
            }
        }
        return true;
    }
}
```


出处:

https://edu.csdn.net/practice/27544131

代码:

import java.util.*;
public class isNumber {
    public static class Solution {
        char[] chars;
        boolean point = false;
        boolean exponent = false;
        public boolean isNumber(String s) {
            s = s.trim();
            int length = s.length();
            if (length == 0) {
                return false;
            }
            chars = s.toCharArray();
            String[] ss = s.split("e");
            if (ss.length == 0) {
                return false;
            }
            if (ss[0].length() == 0)
                return false;
            if (ss[0].length() < length)
                exponent = true;
            if (ss[0].length() == length - 1) {
                return false;
            }
            String[] pre = ss[0].split("\\.");
            if (pre.length == 0) {
                return false;
            }
            if (pre[0].length() < ss[0].length())
                point = true;
            boolean result = pre(0, pre[0].length());
            result = result && middle(pre[0].length() + 1, ss[0].length());
            if (exponent) {
                result = result && is(ss[0].length() + 1, length);
            }
            return result;
        }
        public boolean pre(int i, int length) {
            if (i >= length) {
                return true;
            }
            if (chars[i] == '+' || chars[i] == '-') {
                i++;
            }
            if (i == length && !point) {
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
        public boolean middle(int i, int length) {
            if (i >= length && point) {
                if (chars[i - 2] >= '0' && chars[i - 2] <= '9') {
                    return true;
                }
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
        public boolean is(int i, int length) {
            if (i == 1) {
                return false;
            }
            if (chars[i] == '+' || chars[i] == '-') {
                i++;
            }
            if (i == length) {
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        String str = "0";
        System.out.println(s.isNumber(str));
        str = "e";
        System.out.println(s.isNumber(str));
        str = ".";
        System.out.println(s.isNumber(str));
        str = ".1";
        System.out.println(s.isNumber(str));
        str = "-123.456e789";
        System.out.println(s.isNumber(str));
        str = "99e2.5";
        System.out.println(s.isNumber(str));
    }
}


输出:

true

false

false

true

true

false


2. 存在重复元素 II


给定一个整数数组和一个整数 k,判断数组中是否存在两个不同的索引 i 和 j,使得 nums [i] = nums [j],并且 i 和 j 的差的 绝对值 至多为 k。


示例 1:

输入: nums = [1,2,3,1], k = 3

输出: true


示例 2:

输入: nums = [1,0,1,1], k = 1

输出: true


示例 3:

输入: nums = [1,2,3,1,2,3], k = 2

输出: false


出处:

https://edu.csdn.net/practice/27544132

代码:

import java.util.*;
public class containsNearbyDuplicate {
    public static class Solution {
        public boolean containsNearbyDuplicate(int[] nums, int k) {
            int left = 0;
            int right = -1;
            HashMap<Integer, Integer> hashMap = new HashMap<>();
            while (left < nums.length) {
                if (right + 1 < nums.length && right - left < k) {
                    right++;
                    if (hashMap.containsKey(nums[right])) {
                        return true;
                    } else {
                        hashMap.put(nums[right], 1);
                    }
                } else {
                    hashMap.put(nums[left], hashMap.get(nums[left]) - 1);
                    if (hashMap.get(nums[left]) == 0) {
                        hashMap.remove(nums[left]);
                    }
                    left++;
                }
            }
            return false;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] nums = {1,2,3,1};
        System.out.println(s.containsNearbyDuplicate(nums, 3));
        int[] nums2 = {1,0,1,1};
        System.out.println(s.containsNearbyDuplicate(nums2, 1));
        int[] nums3 = {1,2,3,1,2,3};
        System.out.println(s.containsNearbyDuplicate(nums3, 2));
    }
}

输出:

true

true

false


3. 设计学生类Student和它的一个子类Undergraduate


设计一个学生类Student和它的一个子类Undergraduate,要求如下:


(1)Student类有name和age属性,一个包含两个人参数的构造器,用于给两属性赋值,一个show()方法打印Student的属性信息。


(2)本科生类Undergraduate增加一个degree(学位)属性。有一个包含三参数的构造器,前两个参数用于给集成的属性赋值,第三个参数给degree专业见值,一个show()方法用于打印Undergraduate的属性信息。


(3)在测试类中分别打印Undergraduate和Student对象,调用它们的show()


出处:

https://edu.csdn.net/practice/27544133


代码:


package T1;
public class Test {
    public static void main(String[] args) {
        Student stu = new Student("student", 100);
        stu.show();
        Undergraduate undergraduate = new Undergraduate("Undergraduate", 20, "本科");
        undergraduate.show();
    }
}
class Student {
    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show() {
        System.out.println("名字:" + this.name + "\t年龄:" + this.age);
    }
}
class Undergraduate extends Student {
    private String degree;
    public Undergraduate(String name, int age, String degree) {
        super(name, age);
        this.degree = degree;
    }
    public void show() {
        System.out.println("名字:" + super.getName() + "\t年龄:" + super.getAge() + "\t学位:" + this.degree);
    }
}


输出:

目录
打赏
0
0
0
0
74
分享
相关文章
除了变量,final还能修饰哪些Java元素
在Java中,final关键字不仅可以修饰变量,还可以用于修饰类、方法和参数。修饰类时,该类不能被继承;修饰方法时,方法不能被重写;修饰参数时,参数在方法体内不能被修改。
50 3
JAVA泛型类的使用(二)
接上一篇继续介绍Java泛型的高级特性。3. **编译时类型检查**:尽管运行时发生类型擦除,编译器会在编译阶段进行严格类型检查,并允许通过`extends`关键字对类型参数进行约束,确保类型安全。4. **桥方法**:为保证多态性,编译器会生成桥方法以处理类型擦除带来的问题。5. **运行时获取泛型信息**:虽然泛型信息在运行时被擦除,但可通过反射机制部分恢复这些信息,例如使用`ParameterizedType`来获取泛型参数的实际类型。
JAVA泛型类的使用(一)
Java 泛型类是 JDK 5.0 引入的重要特性,提供编译时类型安全检测,增强代码可读性和可维护性。通过定义泛型类如 `Box&lt;T&gt;`,允许使用类型参数。其核心原理是类型擦除,即编译时将泛型类型替换为边界类型(通常是 Object),确保与旧版本兼容并优化性能。例如,`Box&lt;T&gt;` 编译后变为 `Box&lt;Object&gt;`,从而实现无缝交互和减少内存开销。
|
4月前
|
在 Java 中,一个类可以实现多个接口吗?
这是 Java 面向对象编程的一个重要特性,它提供了极大的灵活性和扩展性。
218 58
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
java 中操作字符串都有哪些类,它们之间有什么区别
Java中操作字符串的类主要有String、StringBuilder和StringBuffer。String是不可变的,每次操作都会生成新对象;StringBuilder和StringBuffer都是可变的,但StringBuilder是非线程安全的,而StringBuffer是线程安全的,因此性能略低。
114 8
|
4月前
|
Eclipse 创建 Java 类
Eclipse 创建 Java 类
48 0
奇迹时刻!探索 Java 多线程的奇幻之旅:Thread 类和 Runnable 接口的惊人对决
【8月更文挑战第13天】Java的多线程特性能显著提升程序性能与响应性。本文通过示例代码详细解析了两种核心实现方式:Thread类与Runnable接口。Thread类适用于简单场景,直接定义线程行为;Runnable接口则更适合复杂的项目结构,尤其在需要继承其他类时,能保持代码的清晰与模块化。理解两者差异有助于开发者在实际应用中做出合理选择,构建高效稳定的多线程程序。
81 7
|
5月前
|
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
71 3
|
5月前
|
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
76 2

热门文章

最新文章