HJ1 字符串最后一个单词的长度
简单 通过率：34.26% 时间限制：1秒 空间限制：32M
知识点[字符串]
描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：
输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：
输出一个整数，表示输入字符串最后一个单词的长度。
示例1
输入：hello nowcoder
输出：8
说明：最后一个单词为nowcoder，长度为8
代码
//方法一
import java.util.Scanner;
//倒序遍历
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
int length = str.length();
int count = 0;
for (int i = length - 1; i >= 0; i--) {
if (str.charAt(i)==' ') {
// 或者 if (str.substring(i, i + 1).equals(" ")) {
break;
}
count++;
}
System.out.println(count);
}
}
//方法二
import java.util.Scanner;
import java.lang.*;
//字符串反转后正序遍历
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int count = 0;
String str = sc.nextLine();
StringBuilder sb = new StringBuilder(str);
StringBuilder s = sb.reverse();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == ' ') {
break;
}
count++;
}
System.out.print(count);
}
}
HJ2 计算某字符出现次数
简单 通过率：31.87% 时间限制：1秒 空间限制：32M
知识点[字符串、哈希]
描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围：1≤n≤1000
输入描述：
第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：ABCabc
A
输出：2
代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
String input1= s.nextLine();
String input2 = s.nextLine();
//将input1中的input2字符串全部替换为 “”
String split3 = input1.toUpperCase().replaceAll(input2.toUpperCase(),"");
//做减法得出出现次数
System.out.println(input1.length() - split3.length());
}
}
HJ3 明明的随机数
较难 通过率：23.25% 时间限制：1秒 空间限制：32M
知识点[数组]
描述
明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
数据范围： 1≤n≤1000 ，输入的数字大小满足1≤val≤500
输入描述：
第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。
输出描述：
输出多行，表示输入数据处理后的结果
示例1
输入：
3
2
2
1
输出：
1
2
说明：输入解释：
第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
2
2
1
所以样例的输出为：
1
2
代码
import java.util.Scanner;
//思路一：因为限定了数据范围是1000个数据以内，所以直接创建指定长度数组
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
//获取输入次数
int num = sc.nextInt();
//创建指定长度数组用于接收数据
int[] arr = new int[1001];
for(int i = 0; i < num; i++){
//通过上面的输入次数循环输入
int n = sc.nextInt();
//每次输入的值作为下标来存储
arr[n] = 1;
}
//因为是用输入值作为下标进行存储的，所以查询的时候要查询整个数组
for(int i = 0; i < arr.length; i++){
//只要数组值为1的下标就是我们存储的值，获取下标输出即可
if(arr[i] == 1){
System.out.println(i);
}
}
}
}
}
import java.util.Scanner;
import java.util.TreeSet;
//思路二：采用了TreeSet的特点，有序不可重复性
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//获取个数
int num = sc.nextInt();
//创建TreeSet进行去重排序
TreeSet Tset = new TreeSet();
//输入
for(int i =0 ; i < num ;i++){
Tset.add(sc.nextInt());
}
//输出
Iterator iterator = Tset.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
HJ4 字符串分隔
简单 通过率：29.86% 时间限制：1秒 空间限制：32M
知识点[字符串]
描述
•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(每个字符串长度小于等于100)
输出描述：
依次输出所有分割后的长度为8的新字符串
示例1
输入：abc
输出：abc00000
代码
注意
（1）str.substring(i)意为截取从字符索引第i位到末尾的字符串。
（2）str.substring(i,j)意为截取索引第i位到第（j-1）位字符串。包含i，不包含j。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
while(str.length() >= 8){
System.out.println(str.substring(0,8));
str = str.substring(8);
}
if(str.length() < 8 && str.length() > 0){
str = str + "0000000";
System.out.println(str.substring(0,8));
}
}
}
}
HJ5 进制转换2
简单 通过率：35.09% 时间限制：1秒 空间限制：32M
知识点[字符串]
描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
数据范围：保证结果在 1≤n≤231−1
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
示例1
输入：0xAA
输出：170
代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
/**Integer.valueOf(String s, int radix): 返回一个 Integer 对象，
*该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
*也可以使用
*Integer.parseInt 方法的作用, 就是从字符串转换成一个10进制的整数
*Integer.parseInt(String s,int radix)
*s代表需要转换的字符串
*radix表示进制 , 如果是字符串代表的数字本来就是10进制, 那么可以省略radix参数
*/
int a = Integer.valueOf(str.substring(2),16);
System.out.print(a);
}
}
HJ6 质数因子
简单 通过率：27.51% 时间限制：1秒 空间限制：32M
知识点[排序]
描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
数据范围： 1≤n≤2×109+14
输入描述：
输入一个整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
示例1
输入：180
输出：2 2 3 3 5
代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for(int i = 2; i <= num; i++){
while(num % i == 0){
System.out.print(i + " ");
num /= i;
}
}
}
}
//这个代码只能通过一部分的测试用例，因为会有超大的素数作为特殊用例来导致你时间超时
因为特殊的超大素数导致的时间超时问题，我们想到了在判断
数 num 是不是质数时，没必要从 2 一直尝试到 num一样，此题中的大循环也大可不必写一个到 num 的循环，写到即可 √num （对num开根号），如果此时数字还没有除数，则可判定其本身是一个质数，没有再除下去的必要了，直接打印其本身即可：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for(int i = 2; i <= Math.sqrt(num); i++){
while(num % i == 0){
System.out.print(i + " ");
num /= i;
}
}
System.out.println(num == 1 ? "": num+" ");
}
}
//这个代码只能通过一部分的测试用例，因为会有超大的素数作为特殊用例来导致你时间超时
HJ7 取近似值
入门 通过率：51.56% 时间限制：1秒 空间限制：32M
知识点[基础数学]
描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
数据范围：保证输入的数字在 32 位浮点数范围内
输入描述：
输入一个正浮点数值
输出描述：
输出该数值的近似整数值
示例1
输入：5.5
输出：6
说明：0.5>=0.5，所以5.5需要向上取整为6
示例2
输入：2.499
输出：2
说明：0.499<0.5，2.499向下取整为2
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double number = in.nextDouble();
//因为java浮点数转整数时是一刀切，直接取整数部分，所以只要小数部分加上0.5就可以进位，形成四舍五入的效果
System.out.println((int)(number + 0.5));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double number = in.nextDouble();
//Math中有round方法，作用是四舍五入
//Math还有ceil表示向上取整. floor表示向下取整, round表示四舍五入.入参都是Double形
System.out.println((int)Math.round(number));
}
}
HJ8 合并表记录
简单 通过率：36.16% 时间限制：1秒 空间限制：32M
知识点[哈希]
描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
0 <= index <= 11111111
1 <= value <= 100000
输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）
示例1
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4
示例2
输入：
3
0 1
0 2
8 9
输出：
0 3
8 9
代码
import java.util.Scanner;
import java.util.TreeMap;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
TreeMap<Integer,Integer> map = new TreeMap<>();
while(sc.hasNext()){
int n = sc.nextInt();
for(int i = 0; i < n; i++){
int key = sc.nextInt();
int value = sc.nextInt();
//hashmap.getOrDefault(Object key, V defaultValue)
map.put(key,map.getOrDefault(key,0)+value);
}
for(Integer i : map.keySet()){
System.out.println(i + " " + map.get(i));
}
}
}
}
//方法二：
import java.util.*;
public class Main {
public static void main(String agv[]) {
Scanner scanner = new Scanner(System.in);
int tableSize = scanner.nextInt();
Map<Integer, Integer> table = new HashMap<>(tableSize);
for (int i = 0; i < tableSize; i++) {
int key = scanner.nextInt();
int value = scanner.nextInt();
if (table.containsKey(key)) {
table.put(key, table.get(key) + value);
} else {
table.put(key, value);
}
}
for (Integer key : table.keySet()) {
System.out.println( key + " " + table.get(key));
}
}
}
注意：
1、hashmap.getOrDefault(Object key, V defaultValue)
返回 key 相映射的的 value，如果给定的 key 在映射关系中找不到，则返回指定的默认值。
2、hashmap.keySet()
返回映射中所有 key 组成的 Set 视图。
3、hashmap.containsKey(Object key) //这里是方法二的
如果 hashMap 中存在指定的 key 对应的映射关系返回 true，否则返回 false。
4、对于这类使用key-Value进行存储时要看清题目是否有要求排序，对于不同的map排序方式不同。
| Hashtable.keySet() | 降序 |
|---|---|
| TreeMap.keySet( | 升序 |
| HashMap.keySet() | 乱序 |
| LinkedHashMap.keySet() | 原序 |
HJ9 提取不重复的整数
入门 通过率：46.34% 时间限制：1秒 空间限制：32M
知识点[数组\哈希]
描述
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。
数据范围： 1≤n≤10^8
输入描述：
输入一个int型整数
输出描述：
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例1
输入：9876673
输出：37689
代码
import java.util.Scanner;
import java.util.HashSet;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
StringBuilder sbd = new StringBuilder(sc.nextLine()).reverse();
//使用hashset去重
HashSet hs = new HashSet();
for(int i = 0; i < sbd.length(); i++){
//通过使用 contains() 方法来判断元素是否存在于集合当中:
//如果不在集合中就添加进去并输出
if(!hs.contains(sbd.charAt(i))){
hs.add(sbd.charAt(i));
System.out.print(sbd.charAt(i));
}
}
}
}
//方法二
import java.util.Scanner;
import java.util.HashSet;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
StringBuilder sbd = new StringBuilder(sc.nextLine()).reverse();
HashSet hs = new HashSet();
for(int i = 0; i < sbd.length(); i++){
//直接用add方法，如果添加成功返回ture，添加失败返回false
if(hs.add(sbd.charAt(i)){
System.out.print(sbd.charAt(i));
}
}
}
}
HJ10 字符个数统计
简单 通过率：49.60% 时间限制：1秒 空间限制：32M
知识点[字符串\哈希]
描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
数据范围：1≤n≤500
输入描述：
输入一行没有空格的字符串。
输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
示例1
输入：abc
输出：3
示例2
输入：aaa
输出：1
代码
import java.util.Scanner;
import java.util.HashSet;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
StringBuilder strb = new StringBuilder(sc.nextLine());
HashSet hs = new HashSet();
for(int i = 0; i < strb.length(); i++){
hs.add(strb.charAt(i));
}
System.out.print(hs.size());
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
