1.DNA序列
【问题描述】
一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
【输入形式】输入一个string型基因序列，和int型子串的长度
【输出形式】找出GC比例最高的子串,如果有多个输出第一个的子串
【样例输入】AACTGTGCACGACCTGA 5
【样例输出】GCACG
import java.util.Scanner;
//DNA序列
// 一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）
// 是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。
// 在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
//给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
public class DNA {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.next(); //输入基因序列
int n=sc.nextInt(); //输入长度
int left=0;
int res=0; //结果计数
int ind=0; //记录开始的下标
for(int right=n-1;right<s.length();right++){
int tem=0;
for(int i=left;i<=right;i++){
if(s.charAt(i)=='C' || s.charAt(i)=='G'){
tem+=1; //记录当前窗口的CG个数，chatAt获取i下标对应的字符
}
}
if(tem>res){
ind=left; //下标更新
res=tem;
}
left+=1; //窗口移动
}
System.out.println(s.substring(ind,ind+n)); //substring截取字符串
}
}2.求近似数
【问题描述】
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
【输入形式】
输入一个正浮点数值
【输出形式】
输出该数值的近似整数值
【样例输入】
5.5
【样例输出】
6
import java.util.Scanner;
//求近似数
//写出一个程序，接受一个正浮点数值，
// 输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
public class approximate {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double n=sc.nextDouble(); //输入浮点数
double tem=n-(int) n; //拿到小数部分 //强制类型转换,获取整数部分
if(tem>=0.5){
System.out.println((int) n +1); //判断范围
}else{
System.out.println((int) n);
}
}
}3.密码检查
【问题描述】
开发一个密码检查软件，密码要求:
-
长度超过8位
-
包括大小写字母.数字.其它符号,以上四种至少三种
-
不能有相同长度大于或等于2的子串重复
【输入形式】
一组或多组长度超过2的子符串。每组占一行
【输出形式】
如果符合要求输出：OK，否则输出NG
【样例输入】
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
【样例输出】
OK
NG
NG
OK
import java.util.Scanner;
//密码检查
//开发一个密码检查软件，密码要求:
//
//长度超过8位
//
//包括大小写字母.数字.其它符号,以上四种至少三种
//
//不能有相同长度大于或等于2的子串重复
public class checkPassword {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String s=sc.next();
boolean flag=false; //标记是否有子串重复
if(s.length()<=8){ //长度判断
System.out.println("NG");
continue;
}
int[] arr={0,0,0,0};
for(int i=0;i<s.length();i++){
if(s.charAt(i)>='a' && s.charAt(i)<='z'){
arr[0]=1; //小写字母
}else if(s.charAt(i)>='A' && s.charAt(i)<='Z'){
arr[1]=1; //大写字母
}else if(s.charAt(i)>='0' && s.charAt(i)<='9'){
arr[2]=1; //数字
}else{
arr[3]=1; //其他符号
}
if(i<s.length()-3) {
String s1 = s.substring(i, i + 2);
String s2=s.substring(i+2);
if(s2.indexOf(s1)>=0){
flag=true; //含有重复子串
break;
}
}
}
if((arr[0]+arr[1]+arr[2]+arr[3])<3){ //判断种类数目是否不超过三种
System.out.println("NG");
continue;
}
if(flag){
System.out.println("NG");
continue;
}
System.out.println("OK");
}
}
}4.选美比赛
【问题描述】
在选美大奖赛的半决赛现场，有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.*;
//选美比赛
//在选美大奖赛的半决赛现场，有n名选手(2<n<100)参加比赛。比赛结束时，
// 要在现场按照选手的出场顺序宣布最后名次，获得相同分数的选手具有相同的名次，
// 名次连续编号，不用考虑同名次的选手人数。如： </div> <div>
// 选手数量： 7 选手得分： 5，3，4，7，3，5，6宣布名次： 3，5，4，1，5，3，2
// 请编程帮助大奖赛组委会完成半决赛的评分排名工作。
public class chooseGame {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] arr=new int[n];
int[] copy=new int[n]; //去重数组
for(int i=0;i<n;i++){
arr[i]=sc.nextInt();
copy[i]=arr[i];
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(arr[i]==copy[j]){
copy[j]=0; //置为0 ,去除重复元素
}
}
}
for(int i=0;i<n;i++){
int tem=1;
for(int j=0;j<n;j++){
if(arr[i]<copy[j]){ //判断有几个比他大
tem++;
}
}
System.out.print(tem+" ");
}
}
}5.情报加密
【问题描述】
在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。
【输入形式】
可能有多组测试数据。每组测试数据的第一行是字符串的数目n，其余n行每行一个字符串,每个字符串长度小于80个字符。
【输出形式】
对于每组数据，输出每行字符串的加密字符串。
【样例输入】
1
Hello! How are you!
【样例输出】
Ifmmp! Ipx bsf zpv!
import java.util.Scanner;
//情报加密
//在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，
// 简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。
// 我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y,
// A-Y的字母用其后继字母替代，把z和Z用a和A替代，则可得到一个简单的加密字符串。
public class encryption {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
sc.nextLine(); //换行接收
//nextLine()的使用
//(1)读取Enter键出现之前的所有字符，包括带空格的字符。
//(2)只能以Enter键作为结束符。
for(int i=0;i<n;i++){
char[] arr=sc.nextLine().toCharArray(); //将字符串转换成字符数组,注意空格也要一起所以要用nextline
for(int j=0;j<arr.length;j++){
if(arr[j]=='z'){
arr[j]='a';
}else if(arr[j]=='Z'){
arr[j]='A'; //特殊情况判断
}else if((arr[j]>='a' && arr[j]<='z')||(arr[j]>='A' && arr[j]<='Z')){
arr[j]+=1; //确保是字母，然后后移 //字符与数字相加，会先将字符转换成ASCII然后相加
}
}
System.out.println(arr);
}
}
}6.骰子问题旋转
【问题描述】
骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。
【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复
【输出形式】输出经过一系列操作后的序列 注：按左右前后上下顺序输出
【样例输入】LB
【样例输出】5 6 1 2 3 4
import java.util.Scanner;
//骰子问题旋转
//骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，
//用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，
//用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，
//用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。
public class diceProblem {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
char[] arr = sc.nextLine().toCharArray(); //字符数组
int[] now = {1, 2, 3, 4, 5, 6}; // 当前状态数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 'C') {
int t1=now[0]; //列出所有情况
now[0]=now[2];
now[2]=now[1];
now[1]=now[3];
now[3]=t1;
}else if(arr[i]=='A'){
int t1=now[0];
now[0]=now[3];
now[3]=now[1];
now[1]=now[2];
now[2]=t1;
}else if(arr[i]=='F'){
int t1=now[2];
now[2]=now[4];
now[4]=now[3];
now[3]=now[5];
now[5]=t1;
}else if(arr[i]=='B'){
int t1=now[2];
now[2]=now[5];
now[5]=now[3];
now[3]=now[4];
now[4]=t1;
}else if(arr[i]=='L'){
int t1=now[4];
now[4]=now[1];
now[1]=now[5];
now[5]=now[0];
now[0]=t1;
}else if(arr[i]=='R'){
int t1=now[4];
now[4]=now[0];
now[0]=now[5];
now[5]=now[1];
now[1]=t1;
}
}
for(int i=0;i<6;i++){
System.out.print(now[i]+" "); //输出状态
}
}
}7.供应商问题
【问题描述】
有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;
//供应商问题
//有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，
// 每个供应商的供应能力有上限，每个商店都有自己的商品需求量
// （need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。
public class supplyProblem {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[][] supply=new int[n][3]; //记录供应方
int[][] need=new int[m][2];//记录商家
int s1=0;
int s2=0;
for(int i=0;i<n;i++){
supply[i][0]=sc.nextInt();
supply[i][1]=sc.nextInt();
supply[i][2]=sc.nextInt();
s1+=supply[i][1];
}
for(int i=0;i<m;i++){
need[i][0]=sc.nextInt();
need[i][1]=sc.nextInt();
s2+=need[i][1];
}
if(s1<s2){ //供应量太少了
System.out.println(-1);
return;
}
for(int i=0;i<n;i++) {
for (int j = i + 1; j < n; j++) {
if (supply[i][2] > supply[j][2]) {
int[] temp = supply[i];
supply[i] = supply[j];
supply[j] = temp;
}
}//利用冒泡排序进行运费的排序
}
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(need[i][1]<=0){
break; //需求量够了
}
if(supply[j][1]>=need[i][1]){
System.out.println(""+supply[j][0]+" "+i+" "+need[i][1]);
supply[j][1]-=need[i][1]; //供应方多了，直接满足
need[i][1]=0;//需求量清零
}else if(supply[j][1]>0){
System.out.println(""+supply[j][0]+" "+i+" "+supply[j][1]);
need[i][1]-=supply[j][1];//要继续寻找供应方
supply[j][1]=0;//供应方提供量清零
}
}
}
}
}8.反转字符串
【问题描述】
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。
【输入形式】输入N个字符
【输出形式】输出该字符串反转后的字符串
【样例输入】
abcd
【样例输出】
dcba
import java.util.Scanner;
//反转字符串
//写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。
public class strReverse {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
char[] s=sc.next().toCharArray();//字符数组 ，将左右两边进行交换从而达到反转字符串目的
int left=0; //左指针
for(int right=s.length-1;right>left;right--){
char temp=s[right]; //左右交换
s[right]=s[left];
s[left]=temp;
left+=1; //左指针移动
}
System.out.println(s);
}
}9. 找朋友
【问题描述】
两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。
首先你对借阅记录进行了一番整理，把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;
//找朋友
//两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，
// 你发现自己与他人相互了解的机会并不太多。幸运的是，
// 你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。
//
//首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，
// 把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，
// 和你喜欢读同一本书的人，就是你的潜在朋友。
// 你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。
public class findFriend {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[] read=new int[n];
for(int i=0;i<n;i++){
read[i]=sc.nextInt(); //记录读者读的书
}
for(int i=0;i<n;i++){
int res=0;//记录人数
for(int j=0;j<n;j++){
if(read[i]==read[j]){//比较是否有读相同书的
res+=1;
}
}
if(res-1>0){ //排除自身，所以-1
System.out.println(res-1);
}else{
System.out.println("BeiJu");
}
}
}
}10. 进制转化
【问题描述】
写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入)
【输入形式】输入一个十六进制的数值字符串。
【输出形式】输出该数值的十进制字符串。
【样例输入】0xA
【样例输出】10
import java.util.Scanner;
//进制转换
//写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入
public class hexadecimalConversion {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
char[] arr=sc.next().toCharArray();//字符数组
int res=0;
for(int i=2;i<arr.length;i++){
if(arr[i]>='0' && arr[i]<='9'){ //一种情况<10，那么直接进行加和
res*=16;
res=res+(arr[i]-'0');
}else{
res*=16; //是字母的情况
res=res+((arr[i]-'A')+10); //拿到对应的十进制数
}
}
System.out.println(res);
}
}11. ip地址判定
【问题描述】
现在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;
// ip地址判定
//现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，
// 点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数
// （因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，
// 一个地址串中没有空格出现（因为要表示成一个32数字）。>
// 现在需要你用程序来判断IP是否合法。
public class checkIP {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.next();
String[] arr=s.split("\\."); //拆分字符串,注意进行转义
if(arr.length!=4){
System.out.println("NO");
return; //无法分成四个部分，直接返回no
}
for(int i=0;i<4;i++){
int tem=Integer.parseInt(arr[i]); //拿到对应的数字
if(tem>255){
System.out.println("NO");//四位数字，最大就是1111即255
return;
}
}
System.out.println("YES"); //验证完毕，符合题意
}
}12. 计算日期
【问题描述】
给出年分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;
//计算日期
//给出年分m和一年中的第n天，算出第n天是几月几号。
public class calculateDate {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int year = sc.nextInt();
int day = sc.nextInt();
int month = 1; //初始化月份
int leap = 0; //闰年标记
int temp = 31; //初始化天数
if ((year % 4 == 0 && year % 400 != 0) || (year % 100 == 0)) {
leap = 1; //判断是否是闰年
}
while ((day - temp) > 0) {
month += 1; //满足一个月的天数，月份+1
day -= temp;
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
temp = 31; //记录当前月份的天数
} else if (month == 2) {
temp = 28 + leap;
} else {
temp = 30;
}
}
if (month < 10) {
if (day < 10) {
System.out.println(year + "-0" + month + "-0" + day);//注意格式输出的分类讨论
} else {
System.out.println(year + "-0" + month + "-"+day);
}
} else {
System.out.println(year + "-" + month + "-" + day);
}
}
}
}13. 去重与排序
【问题描述】
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了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
import java.util.Scanner;
//去重与排序
//明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，
// 他先用计算机生成了N个1到1000之间的随机整数（N≤1000），
// 对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。
// 然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。
// 请你协助明明完成“去重”与“排序”的工作。Input Param n
// 输入随机数的个数 inputArray n 个随机整数组成的数组
// Return Value OutputArray 输出处理后的随机整数
public class uniqueSort {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] nums=new int[n];
for(int i=0;i<n;i++){
nums[i]=sc.nextInt();
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(nums[i]==nums[j]){ //去重，令相等的数字为-1
nums[i]=-1;
}
else if(nums[i]>nums[j]){ //冒泡排序
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}
}
for(int i=0;i<n;i++){
if(nums[i]==-1){ //遇到-1不打印
continue;
}else{
System.out.print(nums[i]+" ");
}
}
}
}14. 跳跃最大长度
【问题描述】
给一个非负整数数组。假设你最初的位置为0，数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置
【输入形式】第一行数组长度
第二行输入一个非负整数数组
【输出形式】布尔类型的值
【样例输入】
5
1 2 3 1 4
【样例输出】
true
import java.util.Scanner;
//跳跃最大长度
//给一个非负整数数组。假设你最初的位置为0，
// 数组中每一个元素的值代表你能跳跃最大的长度，判断是否能达到数组的最后一个位置
public class maxJump {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] arr=new int[n];
boolean flag=true;
int m=0;
for(int i=0;i<n;i++){
arr[i]=sc.nextInt();
}
for(int i=0;i<n;i++){
int temp=arr[i]+i; //能跳到的最远位置
m=Math.max(temp,m); //更新最远位置的值
if(m>=n-1){
break;
}
if(m==i && i!=n-1){ //此时最远位置对应的值为0,且还没有到终点，没办法继续跳
flag=false;
}
}
if(flag){
System.out.println("true");
}else{
System.out.println("false");
}
}
}15. 输出较小数
【问题描述】
输入n个整数，输出其中最小的k个。
【输入形式】输入说明 1输入两个整数（n k） 2输入一个整数数组
【输出形式】输出一个整数数组
【样例输入】
5 2
1 3 5 7 2
【样例输出】
1 2
import java.util.Scanner;
//输出较小数
//输入n个整数，输出其中最小的k个。
public class minNum {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int k=sc.nextInt();
int nums[]=new int[n];
for(int i=0;i<n;i++){
nums[i]=sc.nextInt();
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(nums[i]>nums[j]){
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp; //冒泡排序
}
}
}
for(int i=0;i<k;i++){
System.out.print(nums[i]+" "); //输出前k个数
}
}
}16.计算int型二进制1的个数
【问题描述】
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
【输入形式】
输入一个整数int类型
【输出形式】
这个数转换成2进制后，输出1的个数
【样例输入】
5
【样例输出】
2
import java.util.Scanner;
//计算int型二进制1的个数
//输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
public class countNum1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int count=0; //记录1的个数
while(n>0){
int y=n%2;
n=n/2;
if(y==1){
count+=1;
}
}
System.out.println(count);
}
}17. 水瓶换水
【问题描述】
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是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;
import java.util.concurrent.TransferQueue;
//水瓶换水
//有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。
// 小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，
// 方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，
// 用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水
// ，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。
// 如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
public class changeWater {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
while(true){
int n=sc.nextInt();
if(n==0){
break;
}
int res=0;
while(n>=3){
res+=1;
n-=2; //由于换的水所以多了一个瓶子
}
if(n==2){
res+=1; //特殊情况判断，如果还有2个，那么可以借一个换水
n=0;
}
System.out.print(res+" ");
}
}
}18. 导弹防御系统
【问题描述】
某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。
【输入形式】每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。
【输出形式】每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。
【样例输入】
8
300 207 155 300 299 170 158 65
【样例输出】 6
import java.util.Scanner;
//导弹防御系统
//某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。
// 但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，
// 但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，
// 并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，
// 必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。
public class defenseSystem {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int k=sc.nextInt();
int res=1; //记录最长值
int[] height=new int[k];
for(int i=0;i<k;i++){
height[i]=sc.nextInt();
}
int[] dp=new int[k];
dp[0]=1; //dp[i]表示以i结尾的数组对应的最长非连续递减数列最长的值
for(int i=1;i<k;i++){
dp[i]=1; //初始化
for(int j=0;j<i;j++){
if(height[j]>=height[i]){
dp[i]=Math.max(dp[j]+1,dp[i]); //往前遍历，找到比当前值大的，状态转移方程
}
}
res=Math.max(res,dp[i]); //更新最大值
}
System.out.println(res);
}
}19. 子网判断
【问题描述】
子网掩码是用来判断任意两台计算机的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;
//子网判断
//子网掩码是用来判断任意两台计算机的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，所以这二台计算机可视为是同一子网络。
public class judgeID {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String[] s=sc.next().split("\\."); //分割字符串
String[] a1=sc.next().split("\\.");
String[] a2=sc.next().split("\\.");
boolean f=true; //标记
if(s.length!=4 || a1.length!=4 || a2.length!=4){
System.out.println(0); //不合题意的情况，直接打印0
}
for(int i=0;i<4;i++){
int t1=Integer.parseInt(s[i]); //拿到对应的十进制数字
int t2=Integer.parseInt(a1[i]);
int t3=Integer.parseInt(a2[i]);
if((t1&t2) != (t1&t3)){ //逻辑与运算
f=false;
System.out.println(0);
break; //如果一个对应的不等，直接退出
}
}
if(f){
System.out.println(1);
}
}
}20. 抽纸片
【问题描述】
你的朋友提议玩一个游戏：将写有数字的的n纸片放入口袋中，你可以从口袋中抽取三次纸片，每次记下纸片上的数字后都将其放回到口袋中，如果这三个数字的和是m，就是你赢，否则就是你朋友赢。请你编写一个程序，判断当纸片上所写的数字是k1，k2，…,kn时是否存在抽取三次之和为m的方案。
【输入形式】输入的第一行为一个正整数 n 表示口袋中纸片数目（int类型）第二行为一个正整数表示三个数字的和 第三行为n个整数表示每个纸片上的数字（int类型）
【输出形式】如果存在符合要求的方案，输出Y，否则，输出N。
【样例输入】
3
10
2 3 5
【样例输出】
Y
import java.util.Scanner;
//抽纸片
//你的朋友提议玩一个游戏：将写有数字的的n纸片放入口袋中，
// 你可以从口袋中抽取三次纸片，每次记下纸片上的数字后都将其放回到口袋中，
// 如果这三个数字的和是m，就是你赢，否则就是你朋友赢。请你编写一个程序，
// 判断当纸片上所写的数字是k1，k2，…,kn时是否存在抽取三次之和为m的方案。
public class paperGame {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int nums[]=new int[n];
boolean f=false; //标记
for(int i=0;i<n;i++){
nums[i]=sc.nextInt();
} //由于数据比较少，所以采用暴力求解，可以采用二分法进行求解优化算法
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int k=0;k<n;k++){
if((nums[i]+nums[j]+nums[k])==m){
f=true; //遍历数组
break;
}
}
}
}
if(f){
System.out.println("Y");
}else{
System.out.println("N");
}
}
}21. 学生成绩
【问题描述】
老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.
【输入形式】输入包括多组测试数据。每组输入第一行是两个正整数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.Objects;
import java.util.Scanner;
//学生成绩
//老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.
public class studentScore {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[] score=new int[n];
for(int i=0;i<n;i++){
score[i]=sc.nextInt();
}
for(int i=0;i<m;i++){
String t=sc.next();
if(Objects.equals(t, "Q")){ //比较字符串用equals
int max=0;
int x1=sc.nextInt();
int x2=sc.nextInt();
for(int j=x1-1;j<=x2-1;j++){
if(score[j]>max){ //遍历数组，找到最大成绩
max=score[j];
}
}
System.out.print(max+" "); //输出最大成绩
}else if(Objects.equals(t, "U")){
int x1=sc.nextInt();
int x2=sc.nextInt();
score[x1-1]=x2; //更新成绩
}
}
}
}22. 吸血鬼数字
【问题描述】
吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，这对数字各包含乘积的一半位数的数字，数字选取后可任意排序，例如： 1260=21×60 1827=21×87 2187=27×81。写出一个程序，找出4位数的所有吸血鬼数字。
【输入形式】无
【输出形式】输出所有的吸血鬼数字，数字之间已空格分隔。
【样例输入】无
【样例输出】1260 1395 1435 1530 1827 2187 6880
import java.util.Scanner;
//吸血鬼数字
//吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，
// 这对数字各包含乘积的一半位数的数字，数字选取后可任意排序，
// 例如： 1260=21×60 1827=21×87 2187=27×81。写出一个程序，找出4位数的所有吸血鬼数字。
public class vampireNum {
public static void main(String[] args) {
for(int i=1000;i<10000;i++){
int[] num=new int[4];
int tem=i;
for(int j=3;j>-1;j--){
num[j]=tem%10; //拿到各个数字
tem=tem/10;
}
int x1=num[0]*10+num[1];
int y1=num[0]*10+num[2];
int x2=num[0]*10+num[3];
int y2=num[1]*10+num[0];
int x3=num[1]*10+num[2];
int y3=num[1]*10+num[3];
int x4=num[2]*10+num[0];
int y4=num[2]*10+num[1];
int x5=num[2]*10+num[3];//列出所有可能的组合结果
int y5=num[3]*10+num[0];
int x6=num[3]*10+num[1];
int y6=num[3]*10+num[2];
if(x1*y6==i || x1*x5==i || y1*y3==i || y1*x6==i || x2*x3==i || x2*y4==i || y2*y6==i ||y2*x5==i){
System.out.print(i+" ");
} //列出所有可以相乘的组合
else if(x3*y5==i || x4*y3==i || x4*x6==i || y4*y5==i){
System.out.print(i+" "); //输出打印
}
}
}
}
扫一扫
6375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
