1. DNA序列（Java）
【问题描述】
一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
【输入形式】输入一个string型基因序列，和int型子串的长度
【输出形式】找出GC比例最高的子串,如果有多个输出第一个的子串
【样例输入】AACTGTGCACGACCTGA 5
【样例输出】GCACG
维护长度位k的区间，直接遍历。
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); String s=in.next(); int k=in.nextInt(),n=s.length(); int cnt =0,m=0; String ans=s.substring(0,k); for(int i=0;i<n;i++){ if(s.charAt(i)=='C'||s.charAt(i)=='G') cnt++; if (i>=k&&(s.charAt(i - k) == 'C' || s.charAt(i - k) == 'G')) cnt--; if(cnt>m)//更新 { if(i>=k) ans=s.substring(i-k+1,i+1); m=cnt; } } System.out.println(ans); } }
2. 求近似数（JAVA）
【问题描述】
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
【输入形式】
输入一个正浮点数值
【输出形式】
输出该数值的近似整数值
【样例输入】
5.5
【样例输出】
6
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); double a = in.nextDouble(); int b = (int)a; // 输出结果 System.out.println( (double) (a-b)<0.5?b:b+1); } }
3. 密码检查(JAVA)
【问题描述】
开发一个密码检查软件，密码要求:
长度超过8位
包括大小写字母.数字.其它符号,以上四种至少三种
不能有相同长度大于或等于2的子串重复
【输入形式】
一组或多组长度超过2的子符串。每组占一行
【输出形式】
如果符合要求输出：OK，否则输出NG
【样例输入】
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
【样例输出】OK
NG
NG
OK
按题目要求直接判断，是否有大于等于2的子串，即从前往后遍历，对每个长度为2的子串直接从该子串位置后开始找等于2的子串。
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); String s; while(in.hasNextLine()) { s=in.nextLine(); int n=s.length(),cnt=0; boolean a=false,b=false,c=false,d=false; for(int i=0;i<n;i++) { char C=s.charAt(i); if(C<='9'&&C>='0') { if(!a) { cnt++; a=true; } } else if(C<='z'&&C>='a') { if(!b) { cnt++; b=true; } } else if(C<='Z'&&C>='A') { if(!c) { cnt++; c=true; } } else{ if(!d) { cnt++; d=true; } } } boolean f=true; for(int i=0;i+1<n;i++)//判断是否有重复子串 { String tmp=s.substring(i,i+2); if(i+2<n&&s.indexOf(tmp,i+2)!=-1) { f=false; break; } } System.out.println(cnt>=3&&n>=8&&f?"OK":"NG"); } } }
4. 选美比赛（Java）
【问题描述】
在选美大奖赛的半决赛现场，有n名选手(2<n<100)参加比赛。比赛结束时，要在现场按照选手的出场顺序宣布最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。如： </div> <div> 选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2 请编程帮助大奖赛组委会完成半决赛的评分排名工作。
【输入形式】选手数量：7 选手得分：5;3;4;7;3;5;6
【输出形式】选手的排名：3 5 4 1 5 3 2
【样例输入】7 5 3 4 7 3 5 6
【样例输出】3 5 4 1 5 3 2
数据量较小，可以直接暴力匹配
import java.util.Scanner; import java.util.Arrays; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int[] scores = new int[n]; for (int i = 0; i < n; i++) { scores[i] = in.nextInt(); } int[] ranks = new int[n]; int[] sortedScores = scores.clone(); Arrays.sort(sortedScores); int rk = 0; for (int i = n-1; i >= 0; i--) { if (i == n-1 || sortedScores[i] != sortedScores[i + 1]) { rk++; } ranks[i] = rk; } for (int i = 0; i < n; i++) { for(int j=0;j<n;j++) { if(scores[i]==sortedScores[j]) { System.out.print(ranks[j] + " "); break; } } } } }
自定义排序实现
import java.util.Scanner; import java.util.Arrays; import java.util.Comparator; import java.util.List; public class Main { public static class Player { public int no=0; public int sc=0; public int rank=0; } public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); Player[] plys = new Player[n]; for (int i = 0; i < n; i++) { plys[i]=new Player(); plys[i].sc = in.nextInt(); plys[i].no = i+1; } Arrays.sort(plys, new Comparator<Player>() {//按分数排序 public int compare(Player o1, Player o2) { return o2.sc-o1.sc; } }); int rk=0; for(int i = 0; i < n; i++) { plys[i].rank=++rk; while(i<n-1 && plys[i].sc == plys[i+1].sc) { plys[i+1].rank=plys[i].rank; i++; } } Arrays.sort(plys,new Comparator<Player>(){//按序号排序 public int compare(Player o1, Player o2) { return o1.no - o2.no; } }); for(Player ply : plys) { System.out.printf("%d ",ply.rank); } } }
5. 情报加密（JAVA）
【问题描述】
在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。
【输入形式】
可能有多组测试数据。每组测试数据的第一行是字符串的数目n，其余n行每行一个字符串, 每个字符串长度小于80个字符。
【输出形式】
对于每组数据，输出每行字符串的加密字符串。
【样例输入】
1
Hello! How are you!
【样例输出】Ifmmp! Ipx bsf zpv!
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(); in.nextLine(); while(n--!=0) { String s=in.nextLine(); String ans=""; int m=s.length(); for(int i=0;i<m;i++) { char c=s.charAt(i); if((c<'z'&&c>='a')||(c<'Z'&&c>='A')) { c=(char)((int)c+1); } else if(c=='z'||c=='Z'){ c=(char)((int)c-25); } ans=ans+c; } System.out.println(ans); } } }
6. 骰子问题旋转（java）
【问题描述】
骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。
【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复
【输出形式】输出经过一系列操作后的序列 注：按左右前后上下顺序输出
【样例输入】LB
【样例输出】5 6 1 2 3 4
暴力模拟。初始数组下标 0左，1右，2前，3后，4上，5下。
骰子向右翻转时，上变左，左变下，下变右，右变上；
骰子向左翻转时，上变右，右变下，下变左，左变上；
骰子向前翻转时，上变前，前变下，下变后，后变上；
骰子向后翻转时，上变后，后变下，下变前，前变上；
骰子逆时针旋转90度时，前变右，右变后，后变左，左变前；
骰子顺时针旋转90度时，前变左，左变后，后变右，右变前；
import java.util.Scanner; public class Main { public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void main(String[] args) { Scanner in = new Scanner(System.in); int[] a=new int[]{1,2,3,4,5,6}; String s=in.nextLine(); for(int i=0;i<s.length();i++) { char c=s.charAt(i); if(c=='R') { swap(a,4,5 ); swap(a,0,4); swap(a,1,5); } else if(c=='L') { swap(a,0,1); swap(a,0,4); swap(a,1,5); } else if(c=='F') { swap(a,2,3); swap(a,2,4); swap(a,3,5); } else if(c=='B') { swap(a,4,5); swap(a,2,4); swap(a,3,5); } else if(c=='A') { swap(a,2,3); swap(a,0,2); swap(a,1,3); } else if(c=='C') { swap(a,0,1); swap(a,0,2); swap(a,1,3); } } System.out.println(a[0]+" "+a[1]+" "+a[2]+" "+a[3]+" "+a[4]+" "+a[5]); } }
7. 供应商问题（JAVA）
【问题描述】
有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，每个供应商的供应能力有上限，每个商店都有自己的商品需求量（need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。
【输入形式】
输入说明：第一行包含两个整数N，M
接下来N行包含三个整数，第一个数表示供应商编号，第二数表示供应能力上限，表示该供应商的供应量不能超过这个上限，第三个数表示运送单位商品到商店的运费。
接下来M行包含两个整数，第一个数表示商店编号，第二个数表示某种商品的需求量。
【输出形式】输出说明：若可以满足所有商店需求，则输出格式如下：每行第一个数表示供应商编号，第二个数为商店编号，第三个数为供应量。
如：1 2 20
表示第1个供应商给第2个商店供应20个单位量的商品
按商店编号顺序，输出所有供应路径（最后一行无换行符）。
若不满足，输出-1
【样例输入】4 4
0 20 8
1 15 3
2 55 6
3 40 10
0 28
1 36
2 49
3 12
【样例输出】1 0 15
2 0 13
2 1 36
2 2 6
0 2 20
3 2 23
3 3 12
要使费用最小，直接贪心。
import java.util.Scanner; import java.util.Arrays; public class Main{ public static class Mam{ public int fee; public int id; public int maxn; } static int min(int a, int b){ return a>b?b:a; } public static void main(String[] arg) { Scanner in=new Scanner(System.in); int n=in.nextInt(),m=in.nextInt(),nd1=0,nd2=0; Mam[] mam=new Mam[n]; for(int i=0;i<n;i++) { mam[i]=new Mam(); mam[i].id=in.nextInt(); mam[i].maxn=in.nextInt(); mam[i].fee=in.nextInt(); nd1+=mam[i].maxn; } Arrays.sort(mam,(o1, o2) -> Integer.compare(o1.fee, o2.fee)); int[] a=new int[m],b=new int[m]; for(int i=0;i<m;i++) { a[i]=in.nextInt(); b[i]=in.nextInt(); nd2+=b[i]; } if(nd1<nd2){ System.out.println("-1"); return ; } for(int i=0,j=0;i<m&&j<n;){ System.out.printf("%d %d %d\n",mam[j].id,a[i],min(mam[j].maxn,b[i])); int t=min(mam[j].maxn,b[i]); mam[j].maxn-=t; b[i]-=t; if(b[i]==0) i++; if(mam[j].maxn==0) j++; } } }
8. 反转字符串（Java）
【问题描述】写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。
【输入形式】输入N个字符
【输出形式】输出该字符串反转后的字符串【样例输入】
abcd
【样例输出】dcba
反着输出即可
import java.util.Scanner; import java.util.Arrays; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); String s=in.nextLine(); for(int i=s.length()-1;i>=0;i--) { System.out.print(s.charAt(i)); } } }
9. 找朋友（JAVA）
【问题描述】
两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。
首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，和你喜欢读同一本书的人，就是你的潜在朋友。你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。
【输入形式】
每个案例第一行两个整数N,M。接下来有N行，第i(i = 1,2,…,N)行每一行有一个数，表示读者i-1最喜欢的图书的编号P(1<=P<=M)
【输出形式】
每个案例包括N行，每行一个数，第i行的数表示读者i有几个潜在朋友。如果i和任何人都没有共同喜欢的书，则输出“BeiJu”（即悲剧，^ ^）
【样例输入】4 5
2
3
2
1
【样例输出】1
BeiJu
1
BeiJu
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(),m=in.nextInt(); int[] a=new int[n],cnt=new int[m]; for(int i=0;i<m;i++) cnt[i]=0; for(int i=0;i<n;i++) { a[i]=in.nextInt(); cnt[a[i]]++; } for(int i=0;i<n;i++) { if(cnt[a[i]]==1) System.out.println("BeiJu"); else System.out.println((cnt[a[i]]-1)); } } }
10. 进制转化（java）
【问题描述】写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入)
【输入形式】输入一个十六进制的数值字符串。
【输出形式】输出该数值的十进制字符串。
【样例输入】0xA
【样例输出】10
直接调用函数转化
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String s = in.nextLine(); s=s.substring(2); int ans = Integer.parseInt(s, 16); System.out.println(ans); } }
挨个转化
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String s = in.nextLine(); s=s.substring(2); int ans=0; for(int i=0;i<s.length();i++){ char c=s.charAt(i); int t=0; if(c>='0'&&c<='9') t=c-'0'; else t=c-'A'+10; ans=ans*16+t; } System.out.println(ans); } }
11. ip地址判定（Java）
【问题描述】
现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数（因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，一个地址串中没有空格出现（因为要表示成一个32数字）。>现在需要你用程序来判断IP是否合法。
【输入形式】输入一个ip地址
【输出形式】返回判断的结果YES or NO
【样例输入】
10.138.15.1
【样例输出】
YES
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); boolean f=true; int n=s.length(),cnt=0; int t=0; for(int i=0;i<n;i++) { char c=s.charAt(i); if(c!='.'&&(c<'0'||c>'9')) { f=false; break; } if(c=='.') { cnt++; if(t<256) t=0; else { f=false; break; } } else{ t=t*10+c-'0'; } } if(t>=256||cnt!=3) f=false; if(f) System.out.println("YES"); else System.out.println("NO"); } }
12. 计算日期（JAVA）
【问题描述】
给出年分m和一年中的第n天，算出第n天是几月几号。
【输入形式】
输入包括两个整数y，n
【输出形式】
可能有多组测试数据，对于每组数据，按yyyy-mm-dd的格式将输入中对应的日期打印出来。
【样例输入】2000 3
2000 31
2000 40
2000 60
【样例输出】2000-01-03
2000-01-31
2000-02-09
2000-02-29
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while (in.hasNextInt()) { int y = in.nextInt(); int n = in.nextInt(); int[] Md = {31, (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) ? 29 : 28,31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int mon = 1; int day = n; while (day > Md[mon - 1]) { day -= Md[mon - 1]; mon++; } System.out.printf("%d-%02d-%02d\n", y, mon, day); } } }
13. 去重与排序（Java）
【问题描述】
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。Input Param n 输入随机数的个数 inputArray n 个随机整数组成的数组 Return Value OutputArray 输出处理后的随机整数
【输入形式】输入多行，先输入随机整数的个数n，再输入相应个数的整数
【输出形式】输出一行，处理后的结果
【样例输入】 11
10 20 40 32 67 40 20 89 300 400 15
【样例输出】10 15 20 32 40 67 89 300 400
TreeSet去重加排序
import java.util.Scanner; import java.util.Arrays; import java.util.Comparator; import java.util.TreeSet; public class Main{ public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(); TreeSet<Integer> s=new TreeSet<Integer>(); for(int i=0;i<n;i++) { int x=in.nextInt(); s.add(x); } for(int i:s) { System.out.print(i+" "); } } }
14. 跳跃最大长度（java）
【问题描述】
给一个非负整数数组。假设你最初的位置为0，数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置
【输入形式】第一行数组长度
第二行输入一个非负整数数组
【输出形式】布尔类型的值
【样例输入】
5
1 2 3 1 4
【样例输出】
true
dfs遍历
import java.util.Scanner; public class Main{ static int[] a=new int[200000]; public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(); for(int i=1;i<=n;i++) { a[i] = in.nextInt(); } System.out.println(dfs(1,n)?"true":"false"); } public static boolean dfs(int i,int n) { if(i==n) return true; for(int j=1;j<=a[i];j++) { if(dfs(i+j,n)) return true; } return false; } }
15. 输出较小数（Java）
【问题描述】输入n个整数，输出其中最小的k个。
【输入形式】输入说明 1输入两个整数（n k） 2输入一个整数数组
【输出形式】输出一个整数数组
【样例输入】
5 2
1 3 5 7 2
【样例输出】
1 2
数据较小，先排序再直接输出即可
import java.util.Scanner; import java.util.Arrays; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n=in.nextInt(); int k=in.nextInt(); int[] a=new int[n]; for(int i=0;i<n;i++) a[i]=in.nextInt(); Arrays.sort(a); for(int i=0;i<k;i++) { System.out.printf("%d ",a[i]); } } }
16. 计算int型二进制1的个数（JAVA）
【问题描述】
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
【输入形式】
输入一个整数int类型
【输出形式】这个数转换成2进制后，输出1的个数
【样例输入】
5
【样例输出】
2
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n=in.nextInt(),ans=0; while(n!=0) { if(n%2==1) ans++; n>>=1; } System.out.println(ans); } }
17. 水瓶换水（java）
【问题描述】
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
【输入形式】输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
【输出形式】对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
【样例输入】 3 10 81 0
【样例输出】 1 5 40
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner in =new Scanner(System.in); int x=in.nextInt(); while(x!=0) { int ans=0; while(x>=3) { ans+=x/3; x=x%3+x/3; } if(x==2) ans++; System.out.print(ans+" "); x=in.nextInt(); } } }
18. 导弹防御系统（Java）
【问题描述】
某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。
【输入形式】每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。
【输出形式】每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。
【样例输入】
8
300 207 155 300 299 170 158 65
【样例输出】 6
dp，dp[i]=max(dp[i],dp[k0]+1,...,dp[kj]+1,...) 其中a[kj]>=a[i]。
import java.util.Scanner; public class Main { public static int max(int a, int b) { return a > b ? a : b; } public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(); int[] a=new int[n+1],dp=new int [n+1]; for(int i=1;i<=n;i++) { a[i]=in.nextInt(); dp[i]=1; } int ans=0; for(int i=2;i<=n;i++) { for(int j=i-1;j>0;j--) { if(a[j]>=a[i]){ dp[i]=max(dp[j]+1,dp[i]); } } ans=max(ans,dp[i]); } System.out.println(ans); } }
19. 子网判断（Java）
【问题描述】
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。子网掩码与 IP 地址结构相同，是32 位二进制数，其中网络号部分全为 “1” 和主机号部分全为 “0” 。利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP 地址分别与它们的子网掩码相 “与” 后的结果相同，则说明这两台主机在同一子网中。示例：IP 地址192.168.0.1子网掩码255.255.255.0转化为二进制进行运算：IP地址11010000.10101000.00000000.00000001子网掩码11111111.11111111.11111111.00000000 AND运算11010000.10101000.00000000.00000000转化为十进制后为：192.168.0.0 IP 地址 192.168.0.254子网掩码 255.255.255.0转化为二进制进行运算：IP地址11010000.10101000.00000000.11111110子网掩码11111111.11111111.11111111.00000000 AND运算11010000.10101000.00000000.00000000 转化为十进制后为：192.168.0.0 通过以上对两台计算机IP 地址与子网掩码的 AND 运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。
【输入形式】输入子网掩码、两个地址
【输出形式】得到计算结果，如不在同一子网，则输出0
【样例输入】
255.255.255.0
192.168.224.254
192.168.10.4
【样例输出】
0
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner in=new Scanner(System.in); String s1=in.nextLine(),s2=in.nextLine(),s3=in.nextLine(); boolean f=true; int[] a=new int[4],b=new int[4],c=new int[4],p=new int[4],q=new int[4]; for(int i=0,j=0;i<s1.length();i++) { char cc=s1.charAt(i); if(cc=='.') { j++; } else{ a[j]=a[j]*10+cc-'0'; } } for(int i=0,j=0;i<s2.length();i++) { char cc=s2.charAt(i); if(cc=='.') { j++; } else{ b[j]=b[j]*10+cc-'0'; } } for(int i=0,j=0;i<s3.length();i++) { char cc=s3.charAt(i); if(cc=='.') { j++; } else{ c[j]=c[j]*10+cc-'0'; } } for(int i=0;i<4;i++) { if((a[i]&b[i])!=(a[i]&c[i])) { f=false; break; } p[i]=a[i]&b[i]; } if(f) System.out.println("1"); else System.out.println("0"); } }
20. 抽纸片（java）
【问题描述】
你的朋友提议玩一个游戏：将写有数字的的n纸片放入口袋中，你可以从口袋中抽取三次纸片，每次记下纸片上的数字后都将其放回到口袋中，如果这三个数字的和是m，就是你赢，否则就是你朋友赢。请你编写一个程序，判断当纸片上所写的数字是k1，k2，…,kn时是否存在抽取三次之和为m的方案。
【输入形式】输入的第一行为一个正整数 n 表示口袋中纸片数目（int类型）第二行为一个正整数表示三个数字的和 第三行为n个整数表示每个纸片上的数字（int类型）
【输出形式】如果存在符合要求的方案，输出Y，否则，输出N。
【样例输入】
3
10
2 3 5
【样例输出】
Y
import java.util.Scanner; import java.util.Arrays; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int k = in.nextInt(); int[] a = new int[n]; for(int i=0;i<n;i++)a[i]=in.nextInt(); if(n<3)System.out.println("N"); else{ int sum=0; boolean f=false; for(int i=0;i<n;i++) { sum=a[i]; for(int j=i+1;j<n;j++) { sum+=a[j]; for(int kk=j+1;kk<n;kk++) { sum+=a[kk]; if(sum==k) { f=true; break; } else sum-=a[kk]; } if(sum==k)break; else sum-=a[j]; } if(sum==k)break; else sum-=a[i]; } if(f)System.out.println("Y"); else System.out.println("N"); } } }
21. 学生成绩（java）
【问题描述】
老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.
【输入形式】输入包括多组测试数据。每组输入第一行是两个正整数N和M（0 < N <= 30000,0 < M < 5000）,分别代表学生的数目和操作的数目。 学生ID编号从1编到N。第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩,接下来又M行，每一行有一个字符C（只取‘Q’或‘U’），和两个正整数A,B,当C为'Q'的时候, 表示这是一条询问操作，他询问ID从A到B（包括A,B）的学生当中，成绩最高的是多少,当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。
【输出形式】对于每一次询问操作，在一行里面输出最高成绩.
【样例输入】
5 7
1 2 3 4 5
Q 1 5
U 3 6
Q 3 4
Q 4 5
U 4 5
U 2 9
Q 1 5
【样例输出】5 6 5 9
import java.util.Scanner; import java.util.Arrays; import static java.lang.Math.max; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int m = in.nextInt(); int[] a = new int[n+1]; for(int i = 1; i <= n; i++){ a[i] = in.nextInt(); } while(m-- > 0) { char op =in.next().charAt(0); int A=in.nextInt(), B=in.nextInt(); if(op=='Q') { int ma=0; for(int i=A;i<=B;i++) { ma=max(ma,a[i]); } System.out.printf("%d ",ma); } else if(op=='U'){ a[A]=B; } } } }
22. 吸血鬼数字（Java）
【问题描述】
吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，这对数字各包含乘积的一半位数的数字，数字选取后可任意排序，例如： 1260=21×60 1827=21×87 2187=27×81。写出一个程序，找出4位数的所有吸血鬼数字。
【输入形式】无
【输出形式】输出所有的吸血鬼数字，数字之间已空格分隔。
【样例输入】无
【样例输出】1260 1395 1435 1530 1827 2187 6880
数据量不大，直接暴力
标签：2024,java,Scanner,输出,int,hnuJava,基础训练,new,public From： https://blog.csdn.net/2301_79926854/article/details/143751041import java.sql.SQLOutput; import java.util.Scanner; import java.util.Arrays; import java.util.Vector; import static java.lang.Math.max; public class Main { public static void main(String[] args) { int[] p=new int[5]; p[0]=1; for(int i=1;i<=4;i++ ) p[i]=10*p[i-1]; for(int i=1000;i<10000;i++){ int[] q=new int[5]; int a=0,b=0,t=0; for(int j=0;j<4;j++) { q[j] = (i/p[j])%10; } for(int j=0;j<4;j++) { for (int k = j + 1; k < 4; k++) { a = q[j] * 10 + q[k]; for (t = 0; t < 4; t++) { if (t != j && t != k) { break; } } b = q[t] * 10 + q[6 - t - j - k]; if (a * b == i) { break; } a = q[j] + q[k] * 10; if (a * b == i) { break; } b = q[t] + q[6 - t - j - k] * 10; if (a * b == i) { break; } a= q[j] * 10 + q[k]; if (a * b == i) { break; } } if (a * b == i) break; } if(a*b == i) System.out.printf("%d ",i); } } }