华为刷题

最新推荐文章于 2024-07-17 17:26:09 发布

weixin_42162355

最新推荐文章于 2024-07-17 17:26:09 发布

阅读量746

点赞数

本文链接：https://blog.csdn.net/weixin_42162355/article/details/81774132

版权

1.字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开

import java.util.*;
public class Main{
public static void main (String[] args){
int count=0;
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
char[] c=str.toCharArray();
int len=str.length();
for(int i=len-1;i>=0;i--){
if(c[i]!=' ')count++;
if(c[i]==' ')break;
}
System.out.println(count);
}
}

2.计算字符个数

写出一个程序，输入一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int count=0;
String str1=sc.next();
String str2=sc.next();
char[] a=str1.toLowerCase().toCharArray();
char[] b=str2.toLowerCase().toCharArray();
for(int i=0;i<str1.length();i++){
if(a[i]==b[0])
count++;
}
System.out.println(count);
}
}

3.字符串的去重和排序

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

import java.util.*;
public class Main {
   public static void main(String[] args){
       Scanner sc=new Scanner(System.in);
   List<Integer> arr=new ArrayList<Integer>();
   int n=sc.nextInt();
   for(int i=0;i<n;i++){
   int m=sc.nextInt();
   if(arr.contains(m)){continue;}
   arr.add(m);
   }
   Collections.sort(arr);
   for(int j = 0;j<arr.size();j++){
   System.out.println(arr.get(j));
   }
return;
   }
   }

4.字符串分隔

连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

5.进制转换，16进制转换为10进制

A、十进制转换其他

　　十进制转成二进制
　　Integer.toBinaryString(int i)

　　十进制转成八进制
　　Integer.toOctalString(int i)

　　十进制转成十六进制：
　　Integer.toHexString(int i)

B、其他转换十进制

　　二进制转十进制
　　Integer.valueOf("1010",2).toString()

　　八进制转成十进制
　　Integer.valueOf("125",8).toString()

　　十六进制转成十进制
　　Integer.valueOf("ABCDEF",16).toString()

ublic class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String str=sc.next().substring(2);
String str1=Integer.valueOf(str,16).toString();
System.out.println(str1);
}
}
}

6.密码验证合格程序

密码要求：1.长度大于8位 2.包括大小写字母.数字.其它符号,以上四种至少三种 3.不能有相同长度超2的子串重复

import java.util.*;
public class Main{
public static void main(String[] main){
Scanner sc=new Scanner(System.in);

while(sc.hasNext()){
String s=new String(sc.nextLine());
if(s.length()<9||s==null)
System.out.println("NG");
else{
int num1=0,num2=0,num3=0,num4=0;
char[] c=s.toCharArray();

for(int i=0;i<s.length();i++){
if(c[i]>='a'&&c[i]<='z')
num1=1;
else if(c[i]>='A'&&c[i]<='Z')
num2=1;
else if(c[i]>='0'&&c[i]<='9')
num3=1;
else
num4=1;

}
if(num1+num2+num3+num4<3)
System.out.println("NG");
else
System.out.println(issame(s));
}
}
}
public static String issame(String s){
for(int i=0;i<s.length()-3;i++){
String str1=s.substring(i,i+3);
String str2=s.substring(i+3,s.length());
if(str2.contains(str1)){
return "NG";
}
}
return "OK";
}
}

7.质数因子

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
int num=Integer.parseInt(str);
int i=2;
while(num>=2){
if(num%i==0) {
System.out.print(i+" ");
num/=i;
}
else{
i++;
}
}
}
}

8.四舍五入取近似值

方法一

mport java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.next();
float f=Float.parseFloat(str);
System.out.println(Math.round(f));
}
}

方法二：

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.next();
float f=Float.parseFloat(str);
float a=f-(int)f;
if(a>=0.5)System.out.println((int)f+1);
else System.out.println((int)f);
}
}

9.合并表记录

数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。

输入要求：先输入键值对的个数
然后输入成对的index和value值，以空格隔开

输出描述：输出合并后的键值对（多行）

import java.util.*;
public class Main{
public static void main(String[] args){

Scanner sc = new Scanner(System.in);
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
while (sc.hasNext()) {
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int s=sc.nextInt();
int value=sc.nextInt();
if (map.containsKey(s)) {
map.put(s, map.get(s) + value);
} else
map.put(s, value);
}

}
  Set set=map.keySet();
         for(Object obj:set){
           System.out.println(obj+" "+map.get(obj));
        }
}
}

10.提取不重复的整数

输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

输入描述：输入一个int型整数

输出描述：按照从右往左的顺序，返回一个不含重复数字的新整数

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
HashSet<Character> set=new LinkedHashSet<Character>();
StringBuffer sb=new StringBuffer();
int len=str.length();
for(int i=len-1;i>=0;i--){
set.add(str.charAt(i));
}
for(Character c:set){
sb.append(c);
}
System.out.println(Integer.parseInt(sb.toString()));
}
}

11.字符个数统计

统计输入的字符串中，不重复的字符个数

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
ArrayList arr=new ArrayList();
int len=str.length();
int count=0;
for(int i=0;i<len;i++){
if(!arr.contains(str.charAt(i))){
arr.add(str.charAt(i));
}
}
System.out.println(arr.size());
}
}

12.数字颠倒、字符串翻转

描述：

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
StringBuffer sb=new StringBuffer(str);
sb.reverse();
System.out.println(sb.toString());
}
}

13.句子逆序

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

14.

给定n个字符串，请对n个字符串按照字典序排列。

import java.util.*;
public class Main{
public static void main(String[] main){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String[] s=new String[n];
while(sc.hasNext()){
for(int i=0;i<n;i++){
s[i]=sc.next();
}
}
Arrays.sort(s);
for(int i=0;i<n;i++){
System.out.println(s[i]);
}
}
}

15.求int型正整数在内存中存储1的个数

统计一个正整数转化为二进制时1的个数

方法一：

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int count=0;
String m=Integer.toBinaryString(n);
for(int i=0;i<m.length();i++){
if (m.charAt(i)=='1')
count++;
}
System.out.println(count);
}
}

方法二

import java.util.*;

public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int count = 0;
while(n>0){
if((n&1)>0){
count++;
}
n=n>>1;
}
System.out.println(count);
}
}

16.购物单（动态规划，0-1背包问题）

王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：

v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）

请你帮助王强设计一个满足要求的购物单。

import java.util.*;
public class Main{//动态规划 0-1背包问题
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int sum=sc.nextInt();
int n=sc.nextInt();//希望购买的物品个数
int[] v=new int[n+1];
int[] p=new int[n+1];
int[] q=new int[n+1];
while(sc.hasNext()){
for(int i=1;i<=n;i++){
v[i]=sc.nextInt();//价格
p[i]=sc.nextInt()*v[i];//价值
q[i]=sc.nextInt();//主件附件
}
}
System.out.println(total(sum,n,v,p,q));
}

public static int total(int sum,int n,int[] v,int[] p,int[] q){
int[][] dq=new int[n+1][sum+1];
for(int i=1;i<=n;i++){
for(int j=1;j<=sum;j++){
if(q[i]==0){
if(v[i]<=j)
dq[i][j]=Math.max(dq[i-1][j],dq[i-1][j-v[i]]+p[i]);
}
else{
if(v[i]+v[q[i]]<=j)
dq[i][j]=Math.max(dq[i-1][j],dq[i-1][j-v[i]-v[q[i]]]+p[i]+p[q[i]]);
}
}
}
return dq[n][sum];
}
}

17.坐标移动

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

输入：

合法坐标为A(或者D或者W或者S) + 数字（两位以内）

坐标之间以;分隔。

非法坐标点需要进行丢弃。如AA10; A1A; $%$; YAD; 等。

下面是一个简单的例子如

A10;S20;W10;D30;X;A1A;B10A11;;A10;

处理过程：

起点（0,0）

+ A10 = （-10,0）

+ S20 = (-10,-20)

+ W10 = (-10,-10)

+ D30 = (20,-10)

+ x = 无效

+ A1A = 无效

+ B10A11 = 无效

+ 一个空不影响

+ A10 = (10,-10)

结果（10， -10）

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String str=sc.nextLine();
String[] s=str.split(";");
int x=0;
int y=0;
for(int i=0;i<s.length;i++){

if(s[i].charAt(0)=='A'&&s[i].substring(1).matches("[0-9]+"))
x-=Integer.parseInt(s[i].substring(1));
if(s[i].charAt(0)=='D'&&s[i].substring(1).matches("[0-9]+"))
x+=Integer.parseInt(s[i].substring(1));
if(s[i].charAt(0)=='S'&&s[i].substring(1).matches("[0-9]+"))
y-=Integer.parseInt(s[i].substring(1));
if(s[i].charAt(0)=='W'&&s[i].substring(1).matches("[0-9]+"))
y+=Integer.parseInt(s[i].substring(1));
}
System.out.println(x+","+y);
}
}
}

18.识别有效的IP地址和掩码并进行分类统计

19.简单错误记录

开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。

处理：

1、记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加；

2、超过16个字符的文件名称，只记录文件的最后有效16个字符；

3、输入的文件可能带路径，记录文件名称不能带路径。

输入：E:\V1R2\product\fpgadrive.c   1325

输出：fpgadrive.c 1325 1

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);

Map<String,Integer> map=new LinkedHashMap<String,Integer>();
while(sc.hasNext()){
String str=sc.next();
int n=sc.nextInt();
String[] arr=str.split("\\\\");//不要路径名，只存文件名
String s=arr[arr.length-1];
if(s.length()>16){
s=s.substring(s.length()-16);//只打印最后16个有效字符
}
String k=s+" "+n;
if(!map.containsKey(k)){
map.put(k,1);
}
else{
map.put(k,map.get(k)+1);
}

}
int count=0;
for(String string:map.keySet()){

count++;
if(count>(map.size()-8)){//输出最后8个错误记录
System.out.println(string+" "+map.get(string));
}
}
}
}

20.简单密码

输入密码明文输出密码密文

密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈. 接下来渊子要在密码之上再加一套密码，虽然简单但也安全。

假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。

他是这么变换的，大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，

声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。

输入 YUANzhi1987 输出YUANzhi1987

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String str=sc.nextLine();
char[] c=str.toCharArray();
for(int i=0;i<c.length;i++){
if(c[i]=='a'||c[i]=='b'||c[i]=='c'){
c[i]='2';
}
else if(c[i]=='d'||c[i]=='e'||c[i]=='f')
c[i]='3';
else if(c[i]=='g'||c[i]=='h'||c[i]=='i')
c[i]='4';
else if(c[i]=='j'||c[i]=='k'||c[i]=='l')
c[i]='5';
else if(c[i]=='m'||c[i]=='n'||c[i]=='o')
c[i]='6';
else if(c[i]=='p'||c[i]=='q'||c[i]=='r'||c[i]=='s')
c[i]='7';
else if(c[i]=='t'||c[i]=='u'||c[i]=='v')
c[i]='8';
else if(c[i]=='w'||c[i]=='x'||c[i]=='y'||c[i]=='z')
c[i]='9';
else if(c[i]>=65&&c[i]<=89){
c[i]=(char)(c[i]+33);
}
else if(c[i]=='Z')
c[i]='a';
}
for (char cc: c) {
System.out.print(cc);
}
}
}
}

21.汽水瓶

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
int n=sc.nextInt();
int a=0;
int b=0;
int re=0;
while(n>=3){
a=n/3;
b=n%3;
n=a+b;
re+=a;
}
if(n==2)
re++;
System.out.println(re);}
}
}

22.删除字符串中出现次数最少的字符

实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序

输入 abcdd 输出dd

import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){

String string=sc.nextLine();
char[] A=string.toCharArray();
Map<Character,Integer> m=new LinkedHashMap<Character,Integer>();
for(char c:A){
if(!m.containsKey(c)){
m.put(c,1);
}else{
m.put(c,m.get(c)+1);
}
}
Collection<Integer> al=m.values();
int index=Collections.min(al);
StringBuffer sb=new StringBuffer("");
for(char c:A){
if(m.get(c)!=index)
sb.append(c);
}
System.out.print(sb.toString());
}

}
}

23.合唱队

描述

计算最少出列多少位同学，使得剩下的同学排成合唱队形

说明：

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK，则他们的身高满足存在i（1<=i<=K）使得T1<T2<......<Ti-1<Ti>Ti+1>......>TK。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入：8
186 186 150 200 160 130 197 200

输出4

思路：

首先计算每个数在最大递增子串中的位置

186 186 150 200 160 130 197 200 quene

1 1 1 2 2 1 3 4 递增计数

然后计算每个数在反向最大递减子串中的位置--->计算反向后每个数在最大递增子串中的位置

200 197 130 160 200 150 186 186 反向quene

1 1 1 2 3 2 3 3 递减计数

然后将每个数的递增计数和递减计数相加

186 186 150 200 160 130 197 200 quene

1 1 1 2 2 1 3 4 递增计数