十六进制转八进制 +扩展：进制数转换蓝桥杯基础练习（难搞的东西）

ゝ一纸荒年。 2023-09-26 16:03 19阅读 0赞

[14天阅读挑战赛][14]  
*努力是为了不平庸~  
算法学习有些时候是枯燥的，这一次，让我们先人一步，趣学算法！欢迎记录下你的那些努力时刻（算法学习知识点/算法题解/遇到的算法bug/等等），在分享的同时加深对于算法的理解，同时吸收他人的奇思妙想，一起见证技术er的成长~*

**目录**

一、16转8

二、扩展

（一）16转10

（二）10转16

（三）10转2

3.1代码

3.2改进代码

3.3二次改进代码

--------------------

## 一、16转8 ##

### 算法知识点 ###

> 不同进制数的转换、位运算

### 算法题目来源 ###

> 蓝桥杯练习系统，基础练习：十六进制转八进制

### 算法题目描述 ###

> #### 问题描述 ####
> 
> 给定n个十六进制正整数，输出它们对应的[八进制数][Link 1]。
> 
> #### 输入格式 ####
> 
> 输入的第一行为一个正整数n （1<=n<=10）。 　　接下来n行，每行一个由0---9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
> 
> #### 输出格式 ####
> 
> 输出n行，每行为输入对应的[八进制正整数][Link 2]。
> 
> 【注意】 　　输入的[十六进制数][Link 3]不会有前导0，比如012A。 　　输出的八进制数也不能有[前导0][0]。
> 
> 样例输入 　　2 　　39 　　123ABC
> 
> 样例输出 　　71 　　4435274
> 
> #### 【提示】 ####
> 
> 先将十六进制数转换成某进制数，再由某进制数转换成八进制。

### 做题思路 ###

> 提示：可简单描述解题思路，解题步骤，找好切入点，详细讲解这道题所需要使用的算法和考点

### 模板代码 ###

>     import java.util.Scanner;
>             public class Main {
>             //定义常量字符串数组
>             static String[] bin = { "0000", "0001", "0010", "0011", "0100", "0101",
>                     "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
>                     "1110", "1111" };
>             static String[] oct = { "0", "1", "2", "3", "4", "5", "6", "7" };
>             public static void main(String[] args) {
>                 Scanner s = new Scanner(System.in);
>                 int n = s.nextInt();         //n个十六进制正整数
>                 String[] str = new String[n];  //接收十六进制正整数的数组
>     
>                 //接收十六进制正整数
>                 for (int i = 0; i < n; i++) {
>                     str[i] = s.next();
>                 }
>     
>                 //对这些数进行转换，先转换为二进制数，再从二进制转换为八进制
>                 for(int i=0; i<n; i++) {
>                     String result = hexToBin(str[i]).toString();   //十六进制转换成二进制
>                     String octResult = binToOct(result);         //二进制转换成八进制
>     
>                     //此处为：判断转换成的八进制是否以0开始
>                     if(octResult.startsWith("0")) {
>                         octResult = octResult.substring(1);
>                         //substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
>                         //该子字符串从指定索引处的字符开始，直到此字符串末尾。
>                     }
>                     System.out.println(octResult);
>                 }
>             }
>     
>             //十六进制转换成二进制
>             private static StringBuffer hexToBin(String str) {
>                 int length = str.length();
>                 int start = 0;
>                 int end = 1;
>                 StringBuffer result = new StringBuffer();
>                 for (int i = 0; i < length; i++) {
>                     /*
>                      * substring(int beginIndex,int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
>                      *  该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
>                      *   因此，该子字符串的长度为 endIndex-beginIndex。
>                      */
>                     String subStr = str.substring(start, end); //抽取一个十六进制字符
>                     start++;
>                     end++;
>                     String s = transform(subStr);           //将抽取的十六进制字符转换成二进制字符
>                     result.append(s);
>                 }
>                 return result;
>             }
>     
>             //二进制转换成八进制
>             private static String binToOct(String str) {
>                 int length = str.length();
>                 /*
>                  * 二进制字符串的长度不是3的整数倍的时候，就要在字符串的前面补上相应个数的 ‘0’
>                  * 来让二进制字符串的长度变成3的整数倍
>                  */
>                 if(length % 3 == 1) {
>                     str= "00"+str;
>                 } else if(length % 3 == 2) {
>                     str = "0"+str;
>                 }
>     
>                 int start = 0;
>                 int end = 3;
>                 StringBuffer sb = new StringBuffer();
>                 for(int i=0; i<str.length()/3; i++) {
>                     String subStr = str.substring(start, end); //抽取三个二进制字符
>                     start += 3;
>                     end += 3;
>                     String s = transform2(subStr); //将抽取的二进制字符串转换成八进制字符
>                     sb.append(s);
>                 }
>                 return sb.toString();
>             }
>     
>             //将抽取的十六进制字符转换成二进制字符
>             private static String transform(String str) {
>                 String result = "";
>                 switch (str) {
>                     case "0": result = bin[0]; break;
>                     case "1": result = bin[1]; break;
>                     case "2": result = bin[2]; break;
>                     case "3": result = bin[3]; break;
>                     case "4": result = bin[4]; break;
>                     case "5": result = bin[5]; break;
>                     case "6": result = bin[6]; break;
>                     case "7": result = bin[7]; break;
>                     case "8": result = bin[8]; break;
>                     case "9": result = bin[9]; break;
>                     case "A": result = bin[10]; break;
>                     case "B": result = bin[11]; break;
>                     case "C": result = bin[12]; break;
>                     case "D": result = bin[13]; break;
>                     case "E": result = bin[14]; break;
>                     case "F": result = bin[15]; break;
>                     default: break;
>                 }
>                 return result;
>             }
>     
>             //将抽取的二进制字符串转换成八进制字符
>             private static String transform2(String str) {
>                 String result = "";
>                 switch (str) {
>                     case "000": result = oct[0]; break;
>                     case "001": result = oct[1]; break;
>                     case "010": result = oct[2]; break;
>                     case "011": result = oct[3]; break;
>                     case "100": result = oct[4]; break;
>                     case "101": result = oct[5]; break;
>                     case "110": result = oct[6]; break;
>                     case "111": result = oct[7]; break;
>                 }
>                 return result;
>             }
>     }

## 二、扩展 ##

### （一）16转10 ###

#### 问题描述 ####

从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。 　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

#### 样例输入 ####

FFFF

#### 样例输出 ####

65535

#### 代码 ####

import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            Scanner s = new Scanner(System.in);
            String num = s.next();           //十六进制正整数
            int len=num.length();
            long sum=0;
            String[] str=num.split("");
            for(int i=0; i<len; i++) {
                int result= transform(str[i]);     //十六进制转换成十进制
                sum=(sum+result)*16;
            }
            System.out.println(sum/16);
        }
        //将抽取的十六进制字符转换成十进制数
        private static int transform(String str) {
            Integer result=null ;
            switch (str) {
                case "0": result = 0; break;
                case "1": result = 1; break;
                case "2": result = 2; break;
                case "3": result = 3; break;
                case "4": result = 4; break;
                case "5": result = 5; break;
                case "6": result = 6; break;
                case "7": result = 7; break;
                case "8": result = 8; break;
                case "9": result = 9; break;
                case "A": result = 10; break;
                case "B": result = 11; break;
                case "C": result = 12; break;
                case "D": result = 13; break;
                case "E": result = 14; break;
                case "F": result = 15; break;
                default: break;
            }
            return result;
        }
    }

####  ####

### （二）10转16 ###

#### 资源限制 ####

时间限制：1.0s 内存限制：512.0MB

#### 问题描述 ####

十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。 　　给出一个非负整数，将它表示成十六进制的形式。

#### 输入格式 ####

输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647

#### 输出格式 ####

输出这个整数的16进制表示

#### 样例输入 ####

#### 样例输出 ####

#### 代码 ####

import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            String result = Integer.toBinaryString(n); //API接口 直接转换为二进制
            System.out.println(binToHex(result));
        }
        //二进制转换成八进制
        private static String binToHex(String str) {
            int length = str.length();
            if(length % 4 == 1) {
                str= "000"+str;
            } else if(length % 4 == 2) {
                str = "00"+str;
            }else if(length % 4 == 3) {
                str = "0"+str;
            }
            int start = 0;
            int end = 4;
            StringBuffer sb = new StringBuffer();
            for(int i=0; i<str.length()/4; i++) {
                String subStr = str.substring(start, end); //抽取四个二进制字符
                start += 4;
                end += 4;
                String s = transform2(subStr); //将抽取的二进制字符串转换成十六进制字符
                sb.append(s);
            }
            return sb.toString();
        }  
    
        //将抽取的二进制字符串转换成八进制字符
    
        private static String transform2(String str) {
            String result = "";
            switch (str) {
                case "0000": result = "0"; break;
                case "0001": result = "1"; break;
                case "0010": result = "2"; break;
                case "0011": result = "3"; break;
                case "0100": result = "4"; break;
                case "0101": result = "5"; break;
                case "0110": result = "6"; break;
                case "0111": result = "7"; break;
                case "1000": result = "8"; break;
                case "1001": result = "9"; break;
                case "1010": result = "A"; break;
                case "1011": result = "B"; break;
                case "1100": result = "C"; break;
                case "1101": result = "D"; break;
                case "1110": result = "E"; break;
                case "1111": result = "F"; break;
                }
                return result;
            }
    }

####  ####

### （三）10转2 ###

#### 3.1代码 ####

import java.util.Scanner;
    public class Main {
            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                long num=sc.nextLong();
                long t=0;
                long bin=0;
                long r;
                while (num!=0) {
                    r=num%2;//依次求出余数
                    num=num/2;//用商除以2
                    bin += r * Math.pow(10,t++); //将二进制数的位数变换一下
                }
                System.out.println(bin);
            }
    }

#### 3.2改进代码 ####

import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            long n = sc.nextLong();
            String str = "";
            while (n != 0) {
                str = n % 2 + str;
                n = n / 2;
            }
            System.out.println(str);
        }
    }

####  ####

#### 3.3二次改进代码 ####

####  ####

###  ###

[14]: https://marketing.csdn.net/p/bb9f9e25975dba9f9b87f5272afded16
[Link 1]: https://www.zhihu.com/search?q=%E5%85%AB%E8%BF%9B%E5%88%B6%E6%95%B0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2388624704%7D
[Link 2]: https://www.zhihu.com/search?q=%E5%85%AB%E8%BF%9B%E5%88%B6%E6%AD%A3%E6%95%B4%E6%95%B0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2388624704%7D
[Link 3]: https://www.zhihu.com/search?q=%E5%8D%81%E5%85%AD%E8%BF%9B%E5%88%B6%E6%95%B0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2388624704%7D
[0]: https://www.zhihu.com/search?q=%E5%89%8D%E5%AF%BC0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2388624704%7D