【LQ系列】 BASIC-11～BASIC-15

今天的5道题又来了！～～

【BASIC-11】 基础练习 十六进制转十进制 

问题描述
　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。

　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535

Code：

import java.util.Scanner ;

public class Main {

// 反转字符串，这样在计算的时候下标就等于阶
public static String reverse( String str ) {
int length = str.length() ;
if( length <= 1 )
return str ;
// 二分反转
String left =str.substring(0, length / 2 ) ;
String right = str.substring(length/2, length) ;
return reverse( right ) + reverse( left ) ;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
String str = sc.next() ;	// 输入十六进制字符串
char[] ch = reverse(str).toCharArray() ;
//		System.out.println( Arrays.toString(ch));
long num = 0 ;	// 使用long型，否则会溢出
for( int i = 0; i < ch.length; i ++ ) {
if( Character.isLetter(ch[i]) )
num += (ch[i] - 'A' + 10) * Math.pow( 16, i ) ;
else if( Character.isDigit(ch[i]) )
num += (ch[i] - '0') * Math.pow( 16, i ) ;
else
System.out.println("error") ;
}
System.out.println(num) ;
}

}

【BASIC-12】 基础练习 十六进制转八进制 

问题描述

　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式

　　输入的第一行为一个正整数n （1<=n<=10）。

　　接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式

　　输出n行，每行为输入对应的八进制正整数。

　　【注意】

　　输入的十六进制数不会有前导0，比如012A。

　　输出的八进制数也不能有前导0。

样例输入

　　2

　　39

　　123ABC

样例输出

　　71

　　4435274

　　[b]【
4000
提示[/b]】

　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

        在给这题的代码之前我唠几句，这道题困扰我好久，我试了将近5种方法，有些结果错，其他的运行不是结果溢出，就是时间超时，其中有的是可行的，但是由于输入的数据实在有点变态（最后一行字符串长133333），导致我编的程序总是不能在规定时间内给出结果，最后我在另外一篇C博上找到了一段代码博友写的c++代码，内存使用和运行时间都很高效，我在这就直接借用了，我写的java超时代码我也附在这里，如果有哪位大神用java写出了不超时的代码希望能与我分享，谢谢~

Code：

（这段代码转载自：http://blog.csdn.net/qingdujun/article/details/17404005，谢谢卿笃军博主，我在您博文的下面给您留言了，如果您不希望转载这段代码请与我联系，我会在第一时间撤下）

#include <iostream>
#include <string>
using namespace std;

int main()
{
int n = 0, i = 0, j = 0, temp = 0, nNum = 0;
char ch;
string strHex[10];
string strBin[10];
string strOct[10];

cin>>n;
for (i = 0; i < n; ++i)
{
cin>>strHex[i];
}

//十六进制转二进制
for (i = 0; i < n; ++i)
{
j = 0;
while (strHex[i][j])
{
switch(strHex[i][j])
{
case '0': strBin[i] += "0000"; break;
case '1': strBin[i] += "0001"; break;
case '2': strBin[i] += "0010"; break;
case '3': strBin[i] += "0011"; break;
case '4': strBin[i] += "0100"; break;
case '5': strBin[i] += "0101"; break;
case '6': strBin[i] += "0110"; break;
case '7': strBin[i] += "0111"; break;
case '8': strBin[i] += "1000"; break;
case '9': strBin[i] += "1001"; break;
case 'A': strBin[i] += "1010"; break;
case 'B': strBin[i] += "1011"; break;
case 'C': strBin[i] += "1100"; break;
case 'D': strBin[i] += "1101"; break;
case 'E': strBin[i] += "1110"; break;
case 'F': strBin[i] += "1111"; break;
default:break;
}
++j;
}
}

//二进制转化为八进制
for (i = 0; i < n; ++i)
{
j = strBin[i].size()-1;//获得长度
while (strBin[i][j] && j>=0)
{
temp = 3;
nNum = 0;
while (temp-- && j>=0)
{
if ('1' == strBin[i][j])
{
switch(temp)
{
case 0: nNum += 4; break;
case 1: nNum += 2; break;
case 2: nNum += 1; break;
default:break;
}
}
--j;
}
strOct[i] += (nNum+'0');
}
}

//字符串逆序
for (i = 0; i < n; ++i)
{
temp = strOct[i].size()-1;
for (j = 0; j <= temp/2; ++j)
{
ch = strOct[i][j];
strOct[i][j] = strOct[i][temp-j];
strOct[i][temp-j] = ch;
}
}
//打印
for (i = 0; i < n; ++i)
{
j = 0;
while (strOct[i][j++] == '0');//跳过前面的0

for(--j; j < strOct[i].size(); ++j)
{
cout<<strOct[i][j]-'0';
}
/*if (i != n-1)*/
cout<<endl;
}

return 0;
}

以下三种方法是网上其他朋友提供的或是我写的，可行但超时或溢出：

法一（超时）：

import java.math.BigInteger;
import java.util.Scanner ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
int n = sc.nextInt() ;
for( int i = 0; i < n; i ++ ) {
String str_16 = sc.next() ;
System.out.println(  new BigInteger( str_16, 16 ).toString(8) );	// 可行，但运行超时
}
}
}

法二（超时）：这段代码是我用java重写卿笃军博主的C++代码，但也是超时的

import java.util.Arrays;
import java.util.Scanner ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
int n = sc.nextInt() ;
char[][] ch_binary = new char
[] ;
char[][] ch_hexadecimal = new char
[] ;
char[][] ch_octal = new char
[] ;

String[] str_hexadecimal = new String
;	// 十六进制串
String[] str_binary =  new String
;	// 二进制串
String[] str_octal = new String
; 	// 八进制串

// 输入十六进制字符串
for( int i = 0; i < n; i ++ ) {
str_hexadecimal[i] = sc.next() ;
ch_hexadecimal[i] = str_hexadecimal[i].toCharArray() ;	// 转变成char[][]，因为比charAt省时间
}
//		long t1 = (long) System.currentTimeMillis() ;

// 十六进制转二进制
for( int i = 0; i < n; i ++ ) {
int j = 0 ;
while( j < ch_hexadecimal[i].length ) {
switch( ch_hexadecimal[i][j] ) {
case '0': str_binary[i] += "0000"; break;
case '1': str_binary[i] += "0001"; break;
case '2': str_binary[i] += "0010"; break;
case '3': str_binary[i] += "0011"; break;
case '4': str_binary[i] += "0100"; break;
case '5': str_binary[i] += "0101"; break;
case '6': str_binary[i] += "0110"; break;
case '7': str_binary[i] += "0111"; break;
case '8': str_binary[i] += "1000"; break;
case '9': str_binary[i] += "1001"; break;
case 'A': str_binary[i] += "1010"; break;
case 'B': str_binary[i] += "1011"; break;
case 'C': str_binary[i] += "1100"; break;
case 'D': str_binary[i] += "1101"; break;
case 'E': str_binary[i] += "1110"; break;
case 'F': str_binary[i] += "1111"; break;
default:break;
}
j ++ ;
}
}
for( int i = 0; i < n; i ++ ) {
ch_binary[i] = str_binary[i].toCharArray() ;		// 转变成char[][]，因为比charAt省时间
/** 查看ch_binary[][] **/
//			System.out.println(Arrays.toString(ch_binary[i]) );
}
// 二进制转八进制
for( int i = 0; i < n; i ++ ) {
int j = ch_binary[i].length - 1 ;
while(  j >= 4 ) {   //[0~3] 是 n, u, l, l
int temp = 3 ;		// 保证循环三次算八进制
int nNum = 0 ;
while( (temp --)>0 && j >= 4 ) {
if( ch_binary[i][j] == '1' ) {
switch(temp) {
case 0: nNum += 4; break;
case 1: nNum += 2; break;
case 2: nNum += 1; break;
default:break;
}
}
j -- ;
}
str_octal[i] += nNum;
}
}

for( int i = 0; i < n; i ++ ) {
ch_octal[i] = str_octal[i].substring(4, str_octal[i].length()).toCharArray() ;	// 转变成char[][]，因为比charAt省时间
}
// 字符串逆序（因为当前的ch_octal是反的）
for ( int i = 0; i < n; i ++)
{
int temp = ch_octal[i].length - 1;
for ( int j = 0; j <= temp/2; j ++ )
{
char ch = ch_octal[i][j];
ch_octal[i][j]= ch_octal[i][temp-j];
ch_octal[i][temp-j] = ch;
}
}
//打印
for ( int i = 0; i < n; ++i)
{
for( int  j = 0; j < ch_octal[i].length; ++j)
{
System.out.print( ch_octal[i][j]-'0');
}
System.out.println();
}
//		long t2 = (long) System.currentTimeMillis() ;
//		System.out.println(t2-t1 + "ms" );
}
}

法三（溢出）：这个代码是我从网上找的，只对于前几个输入实例成功，他把字符串转成long型，这显然是不行的，因为当输入串稍微长一点就会溢出了，像这种题必须停留在字符串的处理或者是三两位的计算上，不可能转整个字符串

import java.util.Scanner ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
int n = sc.nextInt() ;
for( int i = 0; i < n; i ++ ) {
String str_16 = sc.next() ;
Hexa_Octal obj = new Hexa_Octal( str_16 ) ;
obj.convert();
}
}
}
class 	Hexa_Octal {
private long  num ;
public Hexa_Octal() {}
public Hexa_Octal( String str ) {
this.num =  Long.parseLong( str, 16 );
}
public void convert() {
String octal = Long.toOctalString(num) ;
System.out.print(octal) ;
}
}

【BASIC-13】 基础练习 数列排序

问题描述
　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
　　第一行为一个整数n。

　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
　　输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5

8 3 6 4 9
样例输出
3 4 6 8 9

Code：

import java.util.Arrays;
import java.util.Scanner ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
int n = sc.nextInt() ;
int[] a = new int
;
for( int i = 0; i < a.length; i ++ )
a[i] = sc.nextInt() ;
Arrays.sort(a);
for( int i = 0; i < a.length; i ++ )
System.out.print( a[i] + " ");
}

}

【BASIC-14】 基础练习 时间转换

问题描述
　　给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。<H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入格式
　　输入只有一行，是一个整数t（0<=t<=86399）。
输出格式
　　输出只有一行，是以“<H>:<M>:<S>”的格式所表示的时间，不包括引号。
样例输入
0
样例输出
0:0:0
样例输入
5436
样例输出
1:30:36

Code：

import java.util.Scanner; ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
int t = sc.nextInt() ;
int h = t / 3600 ;
int m = t % 3600 / 60 ;
int s = t % 60 ;
System.out.println( h + ":" + m + ":" + s );

}

}

【BASIC-15】  基础练习 字符串对比

问题描述
　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：

　　1：两个字符串长度不等。比如 Beijing 和 Hebei

　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing

　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing

　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing

　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式
　　包括两行，每行都是一个字符串
输出格式
　　仅有一个数字，表明这两个字符串的关系编号
样例输入
BEIjing

beiJing

样例输出
3

Code：

import java.util.Scanner ;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner( System.in ) ;
String s1 = sc.next() ;
String s2 = sc.next() ;
if( s1.length() != s2.length() )
System.out.println( "1" );
else if( s1.equals(s2) )
System.out.println( "2" );
else if( s1.compareToIgnoreCase(s2) == 0 )
System.out.println( "3" );
else
System.out.println( "4" );
}

}

今天到这里，明天继续～