关闭

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

170人阅读 评论(0) 收藏 举报
分类:

今天的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

  提示
  先将十六进制数转换成某进制数,再由某进制数转换成八进制。


        在给这题的代码之前我唠几句,这道题困扰我好久,我试了将近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[n][] ;
		char[][] ch_hexadecimal = new char[n][] ;
		char[][] ch_octal = new char[n][] ;
		
		String[] str_hexadecimal = new String[n];	// 十六进制串
		String[] str_binary =  new String[n] ;	// 二进制串
		String[] str_octal = new String[n] ; 	// 八进制串
		
		// 输入十六进制字符串
		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[n] ;
		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" );
	}

}


今天到这里,明天继续~

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:5284次
    • 积分:193
    • 等级:
    • 排名:千里之外
    • 原创:11篇
    • 转载:8篇
    • 译文:2篇
    • 评论:0条
    文章存档