基础练习题库BASIC11-20
| 试题编号 | 试题名称 | 关键字 |
|---|---|---|
| BASIC-11 | 十六进制转十进制 | 进制转换 字符处理 判断 |
| BASIC-12 | 十六进制转八进制 | 进制转换 字符 循环 |
| BASIC-13 | 数列排序 | 数组 排序 |
| BASIC-14 | 时间转换 | 取余 数字字符混合输出 |
| BASIC-15 | 字符串对比 | 字符串 大小写 |
| BASIC-16 | 分解质因数 | 质数分解 循环 |
| BASIC-17 | 矩阵乘法 | 二维数组 循环 矩阵 |
| BASIC-18 | 矩形面积交 | 判断 线段交 |
| BASIC-19 | 完美的代价 | 贪心算法 |
| BASIC-20 | 数的读法 | 判断 函数 |
基础题真的很基础，有些题目一眼看过去就觉得很简单，感觉都没有做的必要。
但是，但是也许越简单越容易埋坑。
十六进制转十进制
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
数据规模与约定
无
| 样例输入 | 样例输入 |
|---|---|
| FFFF | 65535 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] agrs) {
Scanner sc = new Scanner(System.in);
String num = sc.nextLine();
sc.close();
System.out.println(Long.parseLong(num, 16));
}
}
十六进制转八进制
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
数据规模与约定
无
| 输入格式 | 输出格式 |
|---|---|
| 输入的第一行为一个正整数n （1<=n<=10）。 接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。 |
输出n行，每行为输入对应的八进制正整数。 |
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
Java源代码 ---- Error
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String[] str = new String[n];
for(int i=0;i<n;i++)
str[i] = sc.nextLine();
sc.close();
for(int i=0;i<str.length;i++)
System.out.println(Integer.toOctalString(Integer.valueOf(str[i],16)));
}
}
这里不能偷鸡取巧了！老老实实写算法。
数列排序
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
数据规模与约定
无
| 输入格式 | 输出格式 |
|---|---|
| 第一行为一个整数n。 第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 |
输出一行，按从小到大的顺序输出排序后的数列。 |
官方测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 5 8 3 6 4 9 |
3 4 6 8 9 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] num = new int[n];
for (int i = 0; i < n; i++) {
num[i] = sc.nextInt();
}
num = insertSort(num);
for (int i = 0; i < n; i++) {
System.out.print(num[i] + " ");
}
}
public static int[] insertSort(int[] data) {
int temp;
for (int i = 1; i < data.length; i++) {
temp = data[i];// 待插入数据
int j;
for (j = i - 1; j >= 0; j--) {
// 判断是否大于temp，大于则后移一位
if (data[j] > temp) {
data[j + 1] = data[j];
} else {
break;
}
}
data[j + 1] = temp;
}
return data;
}
}
时间转换
问题描述
给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。<H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
数据规模与约定
0<=t<=86399
| 输入格式 | 输出格式 |
|---|---|
| 输入只有一行，是一个整数t。 | 输出只有一行，是以“ |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 0 | 0:0:0 |
| 2 | 5436 | 1:30:36 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int time = sc.nextInt();
System.out.printf("%d:%d:%d", time/3600, time%3600/60,time%60);
}
}
字符串对比
问题描述
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1：两个字符串长度不等。比如 Beijing 和 Hebei
2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
数据规模与约定
1 <= n <= 1000。
| 输入格式 | 输出格式 |
|---|---|
| 包括两行，每行都是一个字符串 | 仅有一个数字，表明这两个字符串的关系编号 |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | BEIjing beiJing |
3 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
String str1 = sc.nextLine();
String str2 = sc.nextLine();
if(str1.equals(str2)){
System.out.println("2");
}else if(str1.equalsIgnoreCase(str2)){
System.out.println("3");
}else if(str1.length()==str2.length()){
System.out.println("4");
}else {
System.out.println("1");
}
}
}
分解质因数
问题描述
求出区间[a,b]中所有整数的质因数分解。
数据规模与约定
2<=a<=b<=10000
| 输入格式 | 输出格式 |
|---|---|
| 输入两个整数a，b。 | 每行输出一个数的分解，形如k=a1a2a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例) |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 3 10 | 3=3 4=22 5=5 6=23 7=7 8=222 9=33 10=25 |
提示：先筛出所有素数，然后再分解。
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
sc.close();
for (int i = a; i <= b; i++) {
if (isPrime(i))
System.out.println(i + "=" + i);
else {
if(i>=2)
System.out.println(resolve(i));
}
}
}
public static boolean isPrime(int num) {
if (num < 2)
return false;
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0)
return false;
}
return true;
}
public static String resolve(int n) {
String strResult = n + "=";
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
strResult += i + "*";
n = n / i;
i--;
}
}
return strResult.substring(0, strResult.length() - 1);
}
}
矩阵乘法
问题描述
给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
例如：
A =
1 2
3 4
A的2次幂
7 10
15 22
数据规模与约定
无
| 输入格式 | 输出格式 |
|---|---|
| 第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数 接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值 |
输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开 |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 2 2 1 2 3 4 |
7 10 15 22 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[][] arry = new int[n][n];
int[][] result = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
arry[i][j] = sc.nextInt();
if (i == j)
result[i][j] = 1;
else
result[i][j] = 0;
}
}
sc.close();
if (m >= 1) {
result = arry.clone();
//输入及输出：E A A*A A*A*A
for (int i = 0; i < m - 1; i++) {
result = matrix(result, arry);
//System.out.println("运算1次");
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(result[i][j] + " ");
}
System.out.println();
}
}
public static int[][] matrix(int[][] arr1, int[][] arr2) {
int length = arr1[0].length;
int[][] result = new int[length][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++) {
for (int k = 0; k < length; k++) {
result[i][j] += arr1[i][k] * arr2[k][j];
}
}
}
return result;
}
}
矩形面积交
问题描述
平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
数据规模与约定
无
| 输入格式 | 输出格式 |
|---|---|
| 输入仅包含两行，每行描述一个矩形。 在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。 |
输出仅包含一个实数，为交的面积，保留到小数后两位。 |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 1 1 3 3 2 2 4 4 |
1.00 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double A_x = sc.nextDouble();
double A_y = sc.nextDouble();
double B_x = sc.nextDouble();
double B_y = sc.nextDouble();
double C_x = sc.nextDouble();
double C_y = sc.nextDouble();
double D_x = sc.nextDouble();
double D_y = sc.nextDouble();
sc.close();
//找到4个点中最接近的两个点。
double x1 = Math.max(Math.min(A_x, B_x), Math.min(C_x, D_x));//从小到大x轴的第2个坐标
double y1 = Math.max(Math.min(A_y, B_y), Math.min(C_y, D_y));//从小到大y轴的第2个坐标
double x2 = Math.min(Math.max(A_x, B_x), Math.max(C_x, D_x));//从小到大x轴的第3个坐标
double y2 = Math.min(Math.max(A_y, B_y), Math.max(C_y, D_y));//从小到大y轴的第3个坐标
//若相交，点1 为左下角，点2为右上角
if(x2-x1>0 && y2-y1>0){
System.out.printf("%.2f",(x2-x1)*(y2-y1));
}else
System.out.printf("%.2f",0.0);
}
}
完美的代价
问题描述
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)
数据规模与约定
N <= 8000
| 输入格式 | 输出格式 |
|---|---|
| 第一行是一个整数N，表示接下来的字符串的长度 第二行是一个字符串，长度为N.只包含小写字母 |
如果可能，输出最少的交换次数。 否则输出Impossible |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 1 1 3 3 2 2 4 4 |
1.00 |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String str = sc.nextLine();
sc.close();
if(Isimprosable(str))
System.out.print(changedTimes(str));
else {
System.out.print("Impossible");
}
}
public static boolean Isimprosable(String str) {
int[] count = new int[26];
int jishu = 0;
for (int i = 0; i < str.length(); i++) {
count[str.charAt(i) - 'a']++;
}
for (int i = 0; i < count.length; i++) {
if (count[i] % 2 != 0)
jishu++;
}
if (jishu > 1)
return false;
else
return true;
}
public static int changedTimes(String str) {
//两个字母以下的字符串必须相同，所以不用换位置
if (str.length() <= 2)
return 0;
int MoveTimes = 0;
// 找首字母配对的最后一次字母
int lastOneIdx = str.lastIndexOf(str.charAt(0));
if (lastOneIdx == 0) {
// 如果首字母最后一次出现还是在首字母，说明该字母是无匹配，需要移动至字符串中间
MoveTimes = str.length() / 2;
// 除去首字母继续递归调整
String new_str = str.substring(1, str.length());// 下标0的首字母不要
return MoveTimes + changedTimes(new_str);
} else {
MoveTimes = (str.length() - 1) - lastOneIdx;// 最后一个字母的下标减去匹配字母的下标得到移动次数
// 除去首字母和匹配字母继续递归
StringBuilder strBuffer = new StringBuilder(str);
strBuffer.deleteCharAt(lastOneIdx);
strBuffer.deleteCharAt(0);
return MoveTimes + changedTimes(strBuffer.toString());
}
}
}
数的读法
问题描述
Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。
比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。
所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：
十二亿三千四百五十六万七千零九
用汉语拼音表示为
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
这样他只需要照着念就可以了。
你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。
数据规模与约定
不超过2,000,000,000
| 输入格式 | 输出格式 |
|---|---|
| 有一个数字串，数值大小不超过2,000,000,000。 | 是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。 |
测试用例
| 序号 | 输入 | 输出 |
|---|---|---|
| 1 | 1234567009 | shi er yi san qian si bai wu shi liu wan qi qian ling jiu |
Java源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.close();
String[] dict_num = {"ling ", "yi ", "er ", "san ", "si ", "wu ", "liu ", "qi ", "ba ", "jiu "};
String[] dict_wei = {"", "shi ", "bai ", "qian ", "wan ", "shi ", "bai ", "qian ", "yi ", "shi ", "bai "};
String numStr = n + "";//{1,2,3,4,5,6,7,0,0,9}
String read = new String();
boolean b = true;
int i, j;
for (i = 0; i < numStr.length(); i++) {
for (j = 0; j <= 9; j++)
if (numStr.charAt(i) == j + '0')
break;
if ((numStr.length() + 2) % 4 == 0 && i == 0 && j == 1) {
read += dict_wei[numStr.length()- 1 - i ];
} else if (i != numStr.length() - 1 && j == 0) {
if (b) {
read += dict_num[j];
b = false;
}
} else if (i == numStr.length() - 1 && j == 0) {
if (!b)
read = read.substring(0, read.length() - 5);// 如果最后一个也为0，则去掉之前添加的
// ling
} else {
read += dict_num[j] + dict_wei[numStr.length() - i - 1];
b = true;
}
}
System.out.println(read);
}
}