1.十进制转R进制
 
1.1 十进制转二进制
 
十进制整数转二进制
 
十进制整数转换成二进制采用“除2倒取余”，十进制小数转换成二进制小数采用“乘2取整”。
 
例题： 135D = ______ B
 
**解析：**如下图所示，将135除以2，得余数，直到不能整除，然后再将余数从下至上倒取。得到结果：1000 0111B.
 
 

 图1.十进制整数转二进制
 
十进制小数转二进制
 
十进制小数转换成二进制小数采用 “乘2取整，顺序排列” 法。
 
具体做法是：
 
用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数 部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。
 
然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
 
例题： 0.68D = ______ B（精确到小数点后5位）
 
**解析：**如下图所示，0.68乘以2，取整，然后再将小数乘以2，取整，直到达到题目要求精度。得到结果：0.10101B.
 
 

 图2.十进制小数转二进制
 
1.2 十进制转八进制
 
思路和十进制转二进制一样，参考如下例题：
 
例题： 10.68D = ______ Q（精确到小数点后3位）
 
**解析：**如下图所示，整数部分除以8取余数，直到无法整除。小数部分0.68乘以8，取整，然后再将小数乘以8，取整，直到达到题目要求精度。得到结果：12.534Q.
 
 

 图3.十进制转八进制
 
1.3 十进制转十六进制
 
思路和十进制转二进制一样，参考如下例题：
 
例题： 25.68D = ______ H（精确到小数点后3位）
 
**解析：**如下图所示，整数部分除以16取余数，直到无法整除。小数部分0.68乘以16，取整，然后再将小数乘以16，取整，直到达到题目要求精度。得到结果：19.ae1H.
 
 

 图4.十进制转十六进制
 # 2.R进制转十进制 ## 2.1 二进制转十进制 **方法为：**把二进制数按权展开、相加即得十进制数。（具体用法如下图） 
例题： 1001 0110B = ______ D
 
**解析：**如下图所示。得到结果：150D.
 
 

 图5.二进制转十进制
 
2.2 八进制转十进制
 
八进制转十进制的方法和二进制转十进制一样。
 
例题： 26Q = ______ D
 
**解析：**如下图所示。得到结果：22D.
 
 

 图6.八进制转十进制
 
2.3 十六进制转十进制
 
例题： 23daH = ______ D
 
**解析：**如下图所示。得到结果：9178D.
 
 

 图7.十六进制转十进制
 
3.二进制转八进制
 
二进制转换成八进制的方法是，取三合一法，即从二进制的小数点为分界点，向左（或向右）每三位取成一位。
 
例题： 1010 0100B = ____Q
 
**解析：**计算过程如下图所示。得到结果：244Q.
 
 

 图8.二进制转八进制
 
4.二进制转十六进制
 
二进制转换成八进制的方法是，取四合一法，即从二进制的小数点为分界点，向左（或向右）每四位取成一位。
 
例题： 1010 0100B = ____H
 
**解析：**计算过程如下图所示。得到结果：a4H.
 
 

 图9.二进制转十六进制
 
5.工欲善其事，必先利其器
 
下面的表格是8位二进制所对应的十进制数值，对进制转换以及类似题目的理解非常有用：
 
1
1
1
1
1
1
1
1
B
128
64
32
16
8
4
2
1
D
注：B：二进制
        D：十进制
 
 
例题： 135D = ______ B
 
**解析：**有了上面二进制对应十进制数值的表格，我们就可以将题目给的十进制135拆分为：128+7，再从表格中找到对应的数值，拼凑即可得到答案。
 135D = 128D + 7D = 1000 0111B

 
 
在十六进制转为八进制的过程中包含了将十六进制转化为二进制以及将二进制转化为八进制！
 
 
我自己测试是没什么问题，但是在蓝桥杯官网的测试系统就显示运行错误qwq
 不知道为什么
 附代码：
 
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
	string code1(char p);
	string code2(char a,char b,char c);
	int i,n,j,flag;
	cin>>n;
	string sixteen[n],two[n],eight[n];
	char twoo[n][1000],eightt[n][1000];
	int len1[n],len2[n];
	for(i=0;i<n;i++)
		cin>>sixteen[i];
	for(i=0;i<n;i++)
	{
		len1[i] = sixteen[i].length();
		for(j=0;j<len1[i];j++)
			two[i] = two[i] + code1(sixteen[i][j]);
		len2[i] = two[i].length();
		for(j=0;j<=len2[i];j++)
			twoo[i][j] = two[i][j];
		if(len2[i]%3==1)
		{
			for(j = len2[i]+1;j>=0;j--)
				twoo[i][j] = twoo[i][j-2];
			twoo[i][1] = twoo[i][0] = '0';
		}
		if(len2[i]%3==2)
		{
			for(j = len2[i];j>=0;j--)
				twoo[i][j] = twoo[i][j-1];
			twoo[i][0] = '0';
		}
		for(j=0;j<len2[i];j=j+3)
			eight[i] = eight[i] + code2(twoo[i][j],twoo[i][j+1],twoo[i][j+2]);	
		for(j=0;j<len2[i];j++)
			eightt[i][j] = eight[i][j];

		for(j=0;j<eight[i].length();j++)
			if(eight[i][j]!='0'){
				flag = j;break;
			}
		for(j=flag;j<eight[i].length();j++)
			cout<<eight[i][j];	
		cout<<endl;	
	}			
	return 0;	
}


string code2(char a,char b,char c)
{
	if(a=='0'&&b=='0'&&c=='0')  return("0");
	if(a=='0'&&b=='0'&&c=='1')  return("1");
	if(a=='0'&&b=='1'&&c=='0')  return("2");
	if(a=='0'&&b=='1'&&c=='1')  return("3");
	if(a=='1'&&b=='0'&&c=='0')  return("4");
	if(a=='1'&&b=='0'&&c=='1')  return("5");
	if(a=='1'&&b=='1'&&c=='0')  return("6");
	if(a=='1'&&b=='1'&&c=='1')  return("7");		
}


string code1(char p)
{
	if(p == '0')   return("0000");
	if(p == '1')   return("0001");
	if(p == '2')   return("0010");
	if(p == '3')   return("0011");
	if(p =='4')    return("0100");
	if(p == '5')   return("0101");
	if(p == '6')   return("0110");
	if(p == '7')   return("0111");
	if(p == '8')   return("1000");
	if(p == '9')   return("1001");
	if(p == 'A')   return("1010");
	if(p == 'B')   return("1011");
	if(p == 'C')   return("1100");
	if(p == 'D')   return("1101");
	if(p == 'E')   return("1110");
	if(p == 'F')   return("1111");
}
 
 
 
还有十六进制转化为十进制的，这个就比较简单了
 
 
#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
	long long sum=0;
	char pp[100];
	scanf("%s",&pp);
	int len;	
	len = strlen(pp);
	for(int i=0;i<len;i++)
	{
		if(pp[i]>='0'&&pp[i]<='9')
		sum = sum + (pp[i]-48)*pow(16,len-i-1);
		if(pp[i] == 'A')
		sum = sum + 10*pow(16,len-i-1);
		if(pp[i] == 'B')
		sum = sum + 11*pow(16,len-i-1);
		if(pp[i] == 'C')
		sum = sum + 12*pow(16,len-i-1);
		if(pp[i] == 'D')
		sum = sum + 13*pow(16,len-i-1);
		if(pp[i] == 'E')
		sum = sum + 14*pow(16,len-i-1);
		if(pp[i] == 'F')
		sum = sum + 15*pow(16,len-i-1);
	 } 
	printf("%I64d",sum);
	return 0;
 } 
 
最近一直在划水，我的300元报名费要打水漂了呜呜呜

BASIC-12 十六进制转八进制
 
1. 问题
 
 
2. 代码
 
import java.util.Scanner;

/**
 * 十六进制转八进制
 * 	十六进制15	转换成二进制1111 1+2+4+8
 * 	16:F 10:15 8:17 2'8': 0001:1011	17	1111
 * 	16:9 10:9 8:12 2'8': 0001:0010	12	1001
 * 	16:6 10:6 8:06 2'8': 0000:0110	6	0110
 * 		111 110 010 110
 * @author 蔡先生
 * hexadecimal
 * octal
 * binary
 * hexTobin
 * binTooct
 */
public class Basic12x {
	private static final String[] strs={"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010",
			"1011","1100","1101","1110","1111"};
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		String[] strs = new String[n];
		for (int i = 0; i < n; i++) {
			strs[i] = in.next();
		}
		in.close();
		for (int i = 0; i < n; i++) {
			StringBuilder result = new StringBuilder();		
			result = hexTobin(strs[i]);
			binTooct(result);	
		}
	}
	public static void binTooct(StringBuilder str) {
		StringBuilder result = new StringBuilder();
		for (int i = 0; i < str.length()-2; i+=3) {
			result.append(switchsO(str.substring(i, i+3)));
		}
		if ("0".equals(result.substring(0,1))) {
			System.out.println(result.substring(1));
			return;
		}
		System.out.println(result);
	}
	public static StringBuilder hexTobin(String str) {
		StringBuilder result = new StringBuilder();
		for (int i = 0; i < str.length(); i++) {
			result.append(switchH(str.charAt(i)));
		}
		int length = result.length();
		if (length % 3 != 0 ) {
			int n = length%3;
			switch (n) {
			case 1:
				result.insert(0,"00");
				break;
			case 2:
				result.insert(0,"0");
				break;
			}
		}
		return result;
	}
	public static String switchH(char c) {
		switch (c) {
		case '0':
			return strs[0];
		case '1':
			return strs[1];
		case '2':
			return strs[2];
		case '3':
			return strs[3];
		case '4':
			return strs[4];
		case '5':
			return strs[5];
		case '6':
			return strs[6];
		case '7':
			return strs[7];
		case '8':
			return strs[8];
		case '9':
			return strs[9];
		case 'A':
			return strs[10];
		case 'B':
			return strs[11];
		case 'C':
			return strs[12];
		case 'D':
			return strs[13];
		case 'E':
			return strs[14];
		case 'F':
			return strs[15];
		}
		return "";
	}
	public static String switchsO(String s) {
		switch (s) {
		case "000":
			return "0";
		case "001":
			return "1";
		case "010":
			return "2";
		case "011":
			return "3";
		case "100":
			return "4";
		case "101":
			return "5";
		case "110":
			return "6";
		case "111":
			return "7";
		}
		return "";
	}
}
 
3. 理解
 

这个提示很重要！
之前写的时候写成了通过十进制转化的，但是如题目给的数据范围远远超过了long，所以就只能被out。这还是很难的！所以直接利用二进制还是非常好的！
关键是转化过程中的细节！
 
要注意equals和==的使用，两个是完全不同的东西。
详细关注这个链接：链接

二进制
 
二进制就是计算机常用的进制，即逢二进一。例如：1010
 
八进制
 
八进制即逢八进一。例如：626
 
十进制
 
十进制就是我们在计算中常用的进制，所以就不再举例（即逢十进一）
 
十六进制
 
十六进制与其它进制有所不同，在10到15用英文字母进行表示。
 
 
上面就是对进制的简单介绍，下面就是对进制转换而进行介绍。
 
1.二进制转八进制
 
拿二进制数10010110举例
 
首先需要3个二进制数各划分一个区域，不足时则补零。我们可以看出该二进制数为八位，我们需要补充一位，
 
即010010110
 
从左到右依次是：（计算方法是从右向左依次乘上2的n次幂，n从零开始,^符号表示次幂）
 
0  1  0                                    0  1  0                                        1  1  0
 
0*2^2+1*2^1+0*2^0=2          0*2^2+1*2^1+0*2^0=2               1*2^2+1*2^1+0*2^0=6
 
然后合并得到226就是转换后的八进制数。
 
2.二进制转十进制
 
拿二进制数10010110举例
 
这里就不需要划分区域，而是直接进行计算。（计算方法是从右向左依次乘上2的n次幂，n从零开始，^符号表示次幂）
 
1*2^7+0*2^6+0*2^5+1*2^4+0*2^3+1*2^2+1*2^1+0*2^0=150
 
3.二进制转十六进制
 
拿二进制数100101100举例
 
二进制转十六进制和二进制转八进制类似，不过转十六进制划分区域为4个，不足也是补零
 
000100101100
 
0001                                               0010                                                1100
 
0*2^3+0*2^2+0*2^1+1*2^0=1        0*2^3+0*2^2+1*2^1+0*2^0=2        1*2^3+1*2^2+0*2^1+0*2^0=12(12也就是十六进制中的C)
 
合并为12C
 
4.八进制转二进制
 
八进制转二进制是二进制转换成八进制的逆过程。（不足时也是补零）
 
拿八进制数226举例（需要取余数，采用倒叙过程）
 
2                                                         2                                                                  6
 
2/2=1(余数为0)                                  2/2=1(余数为0)                                            6/2=3(余数为0) 
 
1/2=0(余数为1)                                  1/2=0(余数为1)                                            3/2=1(余数为1)   
 
                                                                                                                              1/2=0(余数为1)    
 
                                                  
 
所以取余数为10，不足三位，则补零，为010.                                                       余数为110
 
最后合并，最终转换的二进制数为10010110
 
5.八进制转十进制
 
拿八进制数226举例（由右向左依次乘以8的n次幂，n从零开始）
 
2*8^2+2*8^1+6*8^0=150
 
6.八进制转十六进制
 
八进制不能直接转换为十六进制。可以采用间接转换法来进行转换。
 
1.先把八进制转换为二进制，然后再转换为十六进制。
 
2.先把八进制转换为十进制，然后再转换为十六进制。
 
拿八进制数226举例，从上面可以看出转换为二进制为10010110，然后我们再把它转换为16进制。
 
划分区域
 
1001                                                   0110
 
1*2^3+0*2^2+0*2^1+1*2^0=9            0*2^3+1*2^2+1*2^1+0*2^0=6
 
合并为96，所以八进制226转换为十六进制为96.
 
第二种也是一样，小编在这里就不再举例，大家可以试试看，也是一样的结果。
 
7.十进制转二进制
 
十进制转二进制就是二进制转十进制的逆过程。同样，我们也拿十进制150来举例。
 
150/2=75(余数为0)
 
75/2=37(余数为1)
 
37/2=18(余数为1)
 
18/2=9(余数为0)
 
9/2=4(余数为1)
 
4/2=2(余数为0)
 
2/2=1(余数为0)
 
1/2=0(余数为1)
 
整合为10010110即是转换的二进制。
 
8.十进制转八进制
 
十进制转八进制和八进制转十进制是互逆的，我们拿150来举例。
 
150/8=18(余数为6)
 
18/8=2(余数为2)
 
2/8=0(余数为2)
 
整合为226，得到八进制数。
 
9.十进制转十六进制
 
十进制转十六进制和十六进制转十进制是互逆的，我们拿150来举例。
 
150/16=9(余数为6)
 
9/16=0(余数为9)
 
整合为96，得到十六进制数。
 
10.十六进制转二进制
 
十六进制转二进制和二进制转十六进制是互逆的，我们拿12C来举例。（不足的位数补零）
 
1                                                             2                                                               C（转化为12）
 
1/2=0(余数为1)                                      2/2=1(余数为0)                                         12/2=6(余数为0)  
 
                                                              1/2=0(余数为1)                                          6/2=3(余数为0)
 
                                                                                                                                3/2=1(余数为1)
 
                                                                                                                                1/2=0(余数为1)
 
0001                                                     0010                                                            1100
 
整合为000100101100
 
11.十六进制转八进制
 
八进制不能直接转换为十六进制。那么十六进制也不能直接转化为八进制，可以采用间接转换法来进行转换。
 
1.先把十六进制转换为二进制，然后再转换为八进制。
 
2.先把十六进制转换为十进制，然后再转换为八进制。
 
这里就不再介绍转化的过程，和八进制转化为十六进制一样，这里就是一个逆过程。
 
12.十六进制转十进制
 
拿十六进制96来举例（由右向左依次乘以16的n次幂，n从零开始）
 
9*16^1+6*16^0=150
 
 
好了，上面就是二进制，八进制，十进制，十六进制之间的转换。我们可以进行分类记忆，并总结规律。
 
注意：1.我们在将进制数除以2的时候一定要选择逆顺序。
 
           2.在乘以次幂的时候也是从右往左的顺序，由零次幂依次递增。
 
           3.在选择区域的时候一定要看清是转换十六进制还是八进制，否则就会出错，记住不足的位数一定要补零哦。
 
这些就是小编要提醒的注意事项，当然了，通过实例，自己多多练习，相信进制的转换对于大家来说就是很简单的啦。
 
感谢朋友们对小编文章的评价哦！小编在后期也补充了小数部分的进制转换。请参考文章https://blog.csdn.net/mez_Blog/article/details/102468841希望大家多多支持哦^_^
 
Endeavor