以下的题目来自牛客网
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，
设计一个算法，求输入A和B的最小公倍数。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int numo = sc.nextInt();
int numt = sc.nextInt();
int number=numo*numt;
int cishu=0;
int tmp = 0;
int minin=(numo<numt)?numo:numt;
for (int i = minin+1; i <= number ; i++) {
if (numo>0 && numt>0) {
if (i % numo == 0 && i % numt == 0) {
tmp = i;
cishu++;
}
}
}
System.out.println(tmp);
}
将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符,可以有空格
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str = sc.nextLine();
StringBuilder res = new StringBuilder(str);
String s = res.reverse().toString();
System.out.println(s);
}
从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0
本题有多组输入数据，输入到文件末尾，请使用while(cin>>)读入
数据范围小于1e6，
输入任意个整数，每行输入一个。
输出负数个数以及所有非负数的平均值
输入
-13
-4
-7
输出
3
0.0
Redraiment是走梅花桩的高手。Redraiment可以选择任意一个起点，从前到后，但只能从低处往高处的桩子走。他希望走的步数最多，你能替Redraiment研究他最多走的步数吗？(未完成)
说明
6个点的高度各为 2 5 1 5 4 5
如从第1格开始走,最多为3步, 2 4 5
从第2格开始走,最多只有1步,5
而从第3格开始走最多有3步,1 4 5
从第5格开始走最多有2步,4 5
所以这个结果是3。
//输入多行，先输入数组的个数，再输入相应个数的整数
输入
6
2 5 1 5 4 5
3
3 2 1
输出
3
1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
int linenumber = Integer.parseInt(input);
//输入的梅花桩高度
String[] strarray = read.readLine().split(" ");
//准备转为int的的高度
int[] transStrarray=new int[linenumber];
//每组的最远步数
int[] maxStrarray=new int[linenumber];
for (int i = 0; i <linenumber ; i++) {
transStrarray[i] = Integer.parseInt(strarray[i]);
}
//目前的想法是每一轮的比较结果存在一个数组中
//比如输入了 2 5 1 5 4 5
//那么2为起点时，那么开始逐个试试则步数结果为2 0 0 0 3 1
int num;
for (int i = 0; i < linenumber; i++) {
//每轮的步长，最终找出最大的给maxStrarray
int[] counts=new int[linenumber];
for (int j = i; j < linenumber; j++) {
if (transStrarray[j] > transStrarray[i]){
// 2 5 1 5 4 5
// 2 3 4 5 6 7
counts[j]=1;
num=transStrarray[j];
for (int k = j+1; k < linenumber; k++) {
if (transStrarray[k] > num){
counts[j]++;
num++;
}
}
}
}
Arrays.sort(counts);
maxStrarray[i]=counts[counts.length-1];
}
Arrays.sort(maxStrarray);
System.out.println(maxStrarray[linenumber-1]+1);
}
}
}
public static void main(String[] args) throws IOException{
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
//第一行的数
int num = Integer.parseInt(input);
//第二行的数
String[] strs = read.readLine().split(" ");
//准备存放木桩的数组
int[] nums = new int[num];
int max = 0;
for(int i=0;i<strs.length;i++){
nums[i] = Integer.parseInt(strs[i]);
}
//存放比较的结果，如果有六个数，则有六个最大步数的结果产生
int[] result = new int[num];
for(int i =0; i<nums.length;i++){
result[i]=1;
for(int j = 0;j<i;j++){
if(nums[j]<nums[i]){
result[i]=Math.max(result[i],result[j]+1);
System.out.println("ssss"+result[j]);
}
}
}
//从这个几个步数最多的结果中找出最大的
max = 1;
for(int i=0;i<result.length;i++){
if(result[i]>max){
max=result[i];
}
}
System.out.println(max);
}
}
输入整型数组和排序标识，对其元素按照升序或降序进行排序（一组测试用例可能会有多组数据本题有多组输入，请使用while(cin>>)处理(no)
输入描述:
第一行输入数组元素个数
第二行输入待排序的数组，每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序，1代表降序排序
输出描述:
输出排好序的数字
输入
8
1 2 4 9 3 55 64 25
0
5
1 2 3 4 5
1
输出
1 2 3 4 9 25 55 64
5 4 3 2 1
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int linenum = sc.nextInt();
Scanner sc1=new Scanner(System.in);
int updown;
int[] updownarray=new int[linenum];
for (int i = 0; i <linenum ; i++) {
updown = sc1.nextInt();
updownarray[i]=updown;
}
int i = sc1.nextInt();
if (i==1){
Arrays.sort(updownarray);
for (int j = updownarray.length-1; j >=0; j--) {
System.out.print(updownarray[j]+" ");
}
}else if (i==0){
Arrays.sort(updownarray);
for (int j = 0; j <updownarray.length ; j++) {
System.out.print(updownarray[j]+" ");
}
}
}
功能:等差数列 2，5，8，11，14。。。。
输入:正整数N >0
输出:求等差数列前N项和
本题为多组输入，请使用while(cin>>)等形式读取数据
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while((str=br.readLine())!=null){
int n = Integer.parseInt(str);
System.out.println((3*n*n+n)/2);
}
}
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数
/*
功能: 求出n以内的自守数的个数
输入参数：
int n
返回值：
n以内自守数的数量。
*/
public static int CalcAutomorphicNumbers( int n)
{
/*在这里实现功能*/
return 0;
}
本题有多组输入数据，请使用while(cin>>)等方式处理
public static void main(String[] args) throws IOException{
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
//第一行的数
int num = Integer.parseInt(input);
int theend = CalcAutomorphicNumbers(num);
System.out.println(theend);
}
}
public static int CalcAutomorphicNumbers( int n) {
int count=0;
for (int i = 0; i <= n; i++) {
int shu=i*i;
int ilen=(i+"").length();
String shulen=(shu+"");
String substring = shulen.substring(shulen.length() - ilen, shulen.length());
int i1 = Integer.parseInt(substring);
if (i1==i){
count++;
}
}
return count;
}
首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。
本题有多组输入用例。
输入描述:
首先输入一个正整数n，
然后输入n个整数。
输出描述:
输出负数的个数，和所有正整数的平均值。
输入
5
1 2 3 4 5
输出
0 3.0
public static void main(String[] args) throws IOException{
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
//第一行的数
int num = Integer.parseInt(input);
//第二行的数
String[] strarray = read.readLine().split(" ");
int[] number=new int[num];
int count=0;
int tmp=0;
for (int i = 0; i < num; i++) {
number[i]=Integer.parseInt(strarray[i]);
tmp+=number[i];
if (number[i]<0){
count++;
}
}
float total=tmp/num;
for (int i = 0; i < 2; i++) {
}
System.out.println(count+" "+total);
}
}
将一个字符中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。
注意：本题有多组样例输入。
输入描述:
输入一个字符串
输出描述:
字符中所有出现的数字前后加上符号“*”，其他字符保持不变
输入
Jkdi234klowe90a3
5151
输出
Jkdi*234*klowe*90*a*3*
*5151*
public static void main(String[] args) throws IOException {
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
System.out.println(MarkNum(input));
}
}
public static String MarkNum(String pInStr) {
char[] charr = pInStr.toCharArray();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < charr.length; i++) {
if (charr[i]>='0' && charr[i]<='9') {
sb.append("*" + charr[i] + "*");
} else
sb.append(charr[i]);
}
return sb.toString().replace("**", "");
}
请实现一个计票统计系统。你会收到很多投票，其中有合法的也有不合法的，请统计每个候选人得票的数量以及不合法的票数。
输入描述:
输入候选人的人数n，第二行输入n个候选人的名字（均为大写字母的字符串），第三行输入投票人的人数，第四行输入投票。
输出描述:
按照输入的顺序，每行输出候选人的名字和得票数量，最后一行输出不合法的票数。
输入
4
A B C D
8
A D E CF A GG A B
输出
A : 3
B : 1
C : 0
D : 1
Invalid : 3
public class Test1227 {
public static void main(String[] args) throws IOException{
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
//被投票的人数
int personnum = Integer.parseInt(input);
//被投票的人
String[] s = read.readLine().split(" ");
//投出去的总票数
int votenum = Integer.parseInt(read.readLine());
//投票情况
String[] vote = read.readLine().split(" ");
int count = 0;
int[] pvote=new int[personnum];
for (int i = 0; i <personnum ; i++) {
for (int j = 0; j < votenum; j++) {
if (s[i].equals(vote[j])){
count++;
pvote[i]++;
}
}
}
for (int i = 0; i < personnum; i++) {
System.out.println(s[i]+" : "+pvote[i]);
}
System.out.println("Invalid"+" : "+(votenum-count));
}
}
}
输入一个字符串，返回其最长的数字子串，以及其长度。若有多个最长的数字子串，则将它们全部输出（按原字符串的相对位置）
本题含有多组样例输入。copy
输入描述:
输入一个字符串。
输出描述:
输出字符串中最长的数字字符串和它的长度，中间用逗号间隔。如果有相同长度的串，则要一块儿输出（中间不要输出空格）。
输入
abcd12345ed125ss123058789
a8a72a6a5yy98y65ee1r2
输出
123058789,9
729865,2
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s;
while((s=br.readLine())!=null){
char[] ch = s.toCharArray();
int max= Integer.MIN_VALUE;
char[] temp = new char[ch.length];
int y = 0;
for(int i=0;i<ch.length;i++){
if(ch[i]>='0'&&ch[i]<='9'){
int count = 1;
for(int j=i+1;j<ch.length;j++,i++){
if(ch[j]>='0'&&ch[j]<='9'){
count++;
}
else{
break;
}
}
if(count>max){
int x=0;
max = count;
for(int k=i+1-max;k<=i;k++){
temp[x++] = ch[k];
y = x;
}
}
else if(count==max){
for(int k=i+1-max;k<=i;k++){
temp[y++] = ch[k];
}
}
}
}
if(y==0){
System.out.println(null+","+0);
}
else{
for(int z=0;z<y-1;z++){
System.out.print(temp[z]);
}
System.out.println(temp[y-1]+","+max);
}
}
}
请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
输入描述:
每组样例输入两个正整数n和m，用空格隔开。(1≤n,m≤8)
输出描述:
每组样例输出一行结果
示例1
输入
2 2
1 2
输出
6
3
计算24点是一种扑克牌益智游戏，随机抽出4张扑克牌，通过加(+)，减(-)，乘(*), 除(/)四种运算法则计算得到整数24，本问题中，扑克牌通过如下字符或者字符串表示，其中，小写joker表示小王，大写JOKER表示大王：
本程序要求实现：输入4张牌，输出一个算式，算式的结果为24点。
详细说明：
1.运算只考虑加减乘除运算，没有阶乘等特殊运算符号，友情提醒，整数除法要当心；
2.牌面2~10对应的权值为2~10, J、Q、K、A权值分别为为11、12、13、1；
3.输入4张牌为字符串形式，以一个空格隔开，首尾无空格；如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；
4.输出的算式格式为4张牌通过+-*/四个运算符相连，中间无空格，4张牌出现顺序任意，只要结果正确；
5.输出算式的运算顺序从左至右，不包含括号，如1+2+3*4的结果为24
6.如果存在多种算式都能计算得出24，只需输出一种即可，如果无法得出24，则输出“NONE”表示无解。
输入描述:
输入4张牌为字符串形式，以一个空格隔开，首尾无空格；
输出描述:
如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；
示例1
输入
复制
A A A A
输出
复制
NONE
给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号，火车站只有一个方向进出，同时停靠在火车站的列车中，只有后进站的出站了，先进站的才能出站。
要求输出所有火车出站的方案，以字典序排序输出。
输入描述:
有多组测试用例，每一组第一行输入一个正整数N（0
输出描述:
输出以字典序从小到大排序的火车出站序列号，每个编号以空格隔开，每个输出序列换行，具体见sample
3
1 2 3
输出
1 2 3
1 3 2
2 1 3
2 3 1
3 2 1
说明
第一种方案：1进、1出、2进、2出、3进、3出
第二种方案：1进、1出、2进、3进、3出、2出
第三种方案：1进、2进、2出、1出、3进、3出
第四种方案：1进、2进、2出、3进、3出、1出
第五种方案：1进、2进、3进、3出、2出、1出
请注意，[3,1,2]这个序列是不可能实现的。
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入描述:
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出描述:
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
输入
复制
3
10
81
0
输出
1
5
40
/**
* @Author:wuqi
* @DATE: 2021/1/14 0014
* @TIME: 14:20
*/
public class Test0114 {
public static void main(String[] args) throws IOException {
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = read.readLine())!=null){
int num = Integer.parseInt(input);
int drink=0;
int pingzinum=num;
//主要解决的问题是什么时候就换不了饮料了
//每换一次饮料那么手里所拥有的瓶子数等于num/3+num%3
while (num > 0){
//每给出三个瓶子，拿回一瓶饮料，可以这么理解：拿回几瓶饮料，相当于拿回几个空瓶子
if (pingzinum>=3){
int tmp=0;
for (int i = 1; i <= pingzinum; i++) {
if (i%3==0){
num-=3;
drink+=1;
tmp+=1;
}
}
//喝完饮料后手里的空瓶子数
pingzinum=num+tmp;
}
num=pingzinum;
//瓶子数等于两个根据题意可以换一瓶
if (pingzinum==2){
num-=2;
drink+=1;
}
if(pingzinum==1){
num-=1;
}
}
System.out.println(drink);
}
}
}
计算最少出列多少位同学，使得剩下的同学排成合唱队形
说明：
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足存在i（1<=i<=K）使得T1<T2<......<Ti-1<Ti>Ti+1>......>TK。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
输入描述:
整数N
输出描述:
最少需要几位同学出列
示例1
输入
8
186 186 150 200 160 130 197 200
输出
4
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
输入描述:
输入一个字符串
输出描述:
返回有效密码串的最大长度
示例1
输入
ABBA
输出
4
/**
* @Author:wuqi
* @DATE: 2021/1/14 0014
* @TIME: 14:20
*/
public class Test0114 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str = sc.nextLine();
String[] strarray=new String[str.length()];
for (int i = 0; i <str.length() ; i++) {
strarray[i] = str.substring(i, i + 1);
}
int[] maxlength=new int[str.length()];
for (int i = 0; i <str.length() ; i++) {
maxlength[i]=1;
for (int j = i; j < str.length(); j++) {
if (strarray[j].equals(strarray[i])){
String substring = str.substring(i, j+1);
StringBuilder res = new StringBuilder(substring);
String s = res.reverse().toString();
if (s.equals(substring)){
maxlength[i]=s.length();
}
}
}
}
Arrays.sort(maxlength);
System.out.println(maxlength[maxlength.length-1]);
}
}
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args)throws Exception{
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String str;
while((str=reader.readLine())!=null){
int max=0;
char[] arr=str.toCharArray();
for(int i=1;i<arr.length;i++){
int left=i-1;
int right=i;
while(left>=0&&right<arr.length&&arr[left]==arr[right] ){
if(right-left+1>max){
max=right-left+1;
}
left--;
right++;
}
left=i-1;
right=i+1;
while(left>=0&&right<arr.length&&arr[left]==arr[right] ){
if(right-left+1>max){
max=right-left+1;
}
left--;
right++;
}
}
System.out.println(max);
}
}
}
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。链表的值不能重复。
构造过程，例如
1 <- 2
3 <- 2
5 <- 1
4 <- 5
7 <- 2
最后的链表的顺序为 2 7 3 1 5 4
删除 结点 2
则结果为 7 3 1 5 4
链表长度不大于1000，每个节点的值不大于10000。
本题含有多组样例。
输入描述:
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值
输出描述:
输出删除结点后的序列，每个数后都要加空格
输入
5
2
3 2
4 3
5 2
1 4
3
输出
2 5 4 1
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
输入描述:
输入正整数N（N不大于100）
输出描述:
输出一个N行的蛇形矩阵。
示例1
输入
4
输出
1 3 6 10
2 5 9
4 8
7
/**
* @Author:wuqi
* @DATE: 2021/1/11 0011
* @TIME: 18:44
*/
public class Test {
//蛇形矩阵
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int tmps = 1;
//现在的思路是根据规律，把第一列的数找出来
//第一行的规律是 2 3 4 5,那么根据已经找出的第一行的第一个数字是1，那么第一行的第二个数字就是1+2，以此类推
//当循环第二次的时候第规律又是3 4 5
for (int i = 1; i <= num; i++) {
int meihang=0;
int tmp=0;
for (int j = i; j <= num; j++) {
//第一列的数字
if (j == i) {
System.out.print(tmps + " ");
} else {
tmp+=j;
meihang=tmps+tmp;
System.out.print(meihang + " ");
}
}
//第一列的数规律是1 2 3 4 ...
tmps += i;
System.out.print("\n");
}
}
}
10
1 3 6 10 15 21 28 36 45 55
2 5 9 14 20 27 35 44 54
4 8 13 19 26 34 43 53
7 12 18 25 33 42 52
11 17 24 32 41 51
16 23 31 40 50
22 30 39 49
29 38 48
37 47
46
把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。
数据范围：0<=m<=10，1<=n<=10。
本题含有多组样例输入。
输入描述:
输入两个int整数
输出描述:
输出结果，int型
示例1
输入
7 3
输出
8
//把m个苹果放入n个盘子里有几种放法1 5 1、5 1 1、1 1 5属于同一种放法
//Q1怎么保证放置的方法不重复，怎么放
//比如7个苹果放在三个盘子，那么总的三种情况：两个盘子不放，一个盘子不放，三个盘子都放
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Scanner sc1=new Scanner(System.in);
int applenum = sc.nextInt();
int platenum = sc1.nextInt();
System.out.println(fun(applenum,platenum));
}
static int fun(int m, int n) {
//苹果数量为零或者盘子数量为1则都有一种放置的办法
if( m==0 || n==1)
return 1;
if(n>m)
//若盘子的数量大于苹果的数量，则个n-m的盘子不影响放置结果
return fun(m,m);
else
//有空盘子的情况f(m,n)=f(m,n-1)
//没有空盘子的情况，每个盘子拿走一个苹果不影响结果f(m,n)=f(m-n,n)
return fun(m,n-1)+fun(m-n,n);
}