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

最新推荐文章于 2016-06-12 22:19:16 发布
最新推荐文章于 2016-06-12 22:19:16 发布
阅读量479 收藏
点赞数
分类专栏： Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gohnn/article/details/51543977
版权

今天的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" );
	}

}


今天到这里，明天继续～

gohnn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
打印机驱动 LQ-635K
05-26
打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K打印机驱动 LQ-635K...
【LQ系列】BASIC-1～BASIC-5
Gohnn的博客
05-29 378
开始今天的五道题： 【BASIC-1】 基础练习 闰年判断 问题描述 给定一个年份，判断这一年是不是闰年。 当以下情况之一满足时，这一年是闰年： 1. 年份是4的倍数而不是100的倍数； 2. 年份是400的倍数。 其他的年份都不是闰年。 输入格式 输入包含一个整数y，表示当前的年份。 输出格式 输出一行，如果给定的年份是闰年，则输出yes，否则输
【LQ系列】 BASIC-26～BASIC-30
Gohnn的博客
06-08 648
首先祝贺所有高考学子们圆满完成考试，CHEER UP ! 开始正题：赶着今天最后的末班车，做完了今天的5道题： 【BASIC-26】 基础练习 报时助手  问题描述 　　给定当前的时间，请用英文的读法将它读出来。 　　时间用时h和分m表示，在英文的读法中，读一个时间的方法是： 　　如果m为0，则将时读出来，然后加上“o'clock”，如3:00读作
【LQ系列】 BASIC-20～BASIC-25
Gohnn的博客
06-07 1277
蓝桥杯网站修好了，今天才关注到，补上上次没有发的BASIC-20和开始今天的五道题： 【BASIC-20】 基础练习 数的读法  问题描述 　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数
【LQ系列】 BASIC-6～BASIC-10
Gohnn的博客
05-30 510
今天的5道题： 【BASIC-6】基础练习 杨辉三角形  问题描述 杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。 　　 它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。 　　 下面给出了杨辉三角形的前4行： 　　    1 　　   1 1 　　  1 2 1 　　 1 3 3 1 　　
打印机驱动 LQ-630KII
05-26
打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII打印机驱动 LQ-630KII...
Epson-LQ-1600KIIIH
02-15
Epson_LQ-1600KIIIH
DMN3404LQ-7-VB一种N沟道SOT23封装MOS管
12-26
DMN3404LQ-7-VB一种N沟道SOT23封装MOS管
打印机驱动 Epson_LQ-630KII
05-25
打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_LQ-630KII打印机驱动 Epson_...
【LQ系列】 杂谈 —— 聊一聊算法
Gohnn的博客
06-02 1253
闲聊算法
【LQ系列】 ALGO-1～ALGO-2
Gohnn的博客
06-12 577
进入算法训练部分，感到难度进一步提升，现在卡在“K好数”上，先上传前两道题： 【ALGO-1】 算法训练 区间k大数查询 问题描述 给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。 输入格式 第一行包含一个数n，表示序列长度。 第二行包含n个正整数，表示给定的序列。 第三个包含一个正整数m，表示询问个数。 接下来
【LQ系列】 BASIC-16～BASIC-19
Gohnn的博客
06-01 507
今天做到了VIP部分的题，感觉难度上和之前明显有一个小的跨越，目前卡在了第今天的第五题上，所以今天我只做了四道题，明天会补上第五题。其中有些题我参照了其他博友们的代码，感觉大神的代码真的很赞，自己还需努力啊～～好了废话不多说，开始今天的四道题： 【BASIC-16】 基础练习 分解质因数  问题描述 　　求出区间[a,b]中所有整数的质因数分解。 输入格式 　　
【LQ系列】BEGIN-1～BEGIN-4
Gohnn的博客
05-28 414
昨天刚刚参加完第七届蓝桥杯决赛，赛场高手很多，受刺激也很大，由于之前蓝桥杯上刷题太少，导致做题时头脑很混乱，之前在C博上有看到有博友在写 “一天一道Leetcode系列”，“算法系列” 等等，在网站上也曾有人说过：“算法好的人以后运气都不会差。” 所以今天自己下定决心写一套【LQ系列】，希望能借此提高一下算法能力，我会把题目和代码贴在博文里，希望大家多多指正～ 今天是第一天，先从前几道简
框架搭建内容合成的描述
04-19
框架搭建内容合成的描述
【Godot4自学手册】第三十八节给游戏添加音效
最新发布
04-19
【Godot4自学手册】第三十八节给游戏添加音效
人工智能BBSO算法，MATLAB实现，很基本的人工智能算法，里面有很多源程序
04-19
人工智能BBSO算法，MATLAB实现，很基本的人工智能算法，里面有很多源程序 (Artificial intelligence bbso) 文件列表: BBSO\alea.m (99, 2013-11-02) BBSO\alea_normal.m (532, 2013-11-02) BBSO\alea_sphere.m (483, 2013-11-02) BBSO\BBSO.m (5647, 2015-05-03) BBSO\BSO.asv (3521, 2013-11-02) BBSO\calef.m (375, 2014-02-08) BBSO\cauchy.txt (1282, 2013-11-02) BBSO\cauchy.zip (9607, 2013-11-02) BBSO\cauchycdf.m (1225, 2013-11-02) BBSO\cauchyfit.m (5565, 2013-11-02) BBSO\cauchyinv.m (1379, 2013-11-02) BBSO\cauchypdf.m (1221, 2013-11-02) BBSO\cauchyr
人工智能神经网络.ppt
04-19
人工智能神经网络.ppt
Free Download Manager CRX 3.0.59 for Chrome.crx
04-19
Free Download Manager 谷歌浏览器插件
EPSON LQ-630K
08-22
EPSON LQ-630K是一款针式打印机，具有快速打印速度、出色的性能和长久的寿命。它体积小巧，节能高效，并且安装简单。该打印机的噪音控制也相对较好，相比老款的针式打印机，噪音问题得到了改善。另外，EPSON LQ-630K...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值