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

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

    目录

    一、16转8

    二、扩展

    （一）16转10

    （二）10转16

    （三）10转2

    3.1代码

    3.2改进代码

    3.3二次改进代码

    一、16转8

    算法知识点

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

    算法题目来源

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

    算法题目描述

    问题描述

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

    输入格式

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

    输出格式

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

    【注意】 　　输入的十六进制数不会有前导0，比如012A。 　　输出的八进制数也不能有前导0。

    样例输入 　　2 　　39 　　123ABC

    样例输出 　　71 　　4435274

    【提示】

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

    做题思路

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

    模板代码

    1.  
    2.  
    3. import java.util.Scanner;
    4.         public class Main {
    5.         //定义常量字符串数组
    6.         static String[] bin = { "0000", "0001", "0010", "0011", "0100", "0101",
    7.                 "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
    8.                 "1110", "1111" };
    9.         static String[] oct = { "0", "1", "2", "3", "4", "5", "6", "7" };
    10.         public static void main(String[] args) {
    11.             Scanner s = new Scanner(System.in);
    12.             int n = s.nextInt();         //n个十六进制正整数
    13.             String[] str = new String[n];  //接收十六进制正整数的数组
    14.  
    15.             //接收十六进制正整数
    16.             for (int i = 0; i < n; i++) {
    17.                 str[i] = s.next();
    18.             }
    19.  
    20.             //对这些数进行转换，先转换为二进制数，再从二进制转换为八进制
    21.             for(int i=0; i
    22.                 String result = hexToBin(str[i]).toString();   //十六进制转换成二进制
    23.                 String octResult = binToOct(result);         //二进制转换成八进制
    24.  
    25.                 //此处为：判断转换成的八进制是否以0开始
    26.                 if(octResult.startsWith("0")) {
    27.                     octResult = octResult.substring(1);
    28.                     //substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
    29.                     //该子字符串从指定索引处的字符开始，直到此字符串末尾。
    30.                 }
    31.                 System.out.println(octResult);
    32.             }
    33.         }
    34.  
    35.         //十六进制转换成二进制
    36.         private static StringBuffer hexToBin(String str) {
    37.             int length = str.length();
    38.             int start = 0;
    39.             int end = 1;
    40.             StringBuffer result = new StringBuffer();
    41.             for (int i = 0; i < length; i++) {
    42.                 /*
    43.                  * substring(int beginIndex,int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
    44.                  *  该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
    45.                  *   因此，该子字符串的长度为 endIndex-beginIndex。
    46.                  */
    47.                 String subStr = str.substring(start, end); //抽取一个十六进制字符
    48.                 start++;
    49.                 end++;
    50.                 String s = transform(subStr);           //将抽取的十六进制字符转换成二进制字符
    51.                 result.append(s);
    52.             }
    53.             return result;
    54.         }
    55.  
    56.         //二进制转换成八进制
    57.         private static String binToOct(String str) {
    58.             int length = str.length();
    59.             /*
    60.              * 二进制字符串的长度不是3的整数倍的时候，就要在字符串的前面补上相应个数的 ‘0’
    61.              * 来让二进制字符串的长度变成3的整数倍
    62.              */
    63.             if(length % 3 == 1) {
    64.                 str= "00"+str;
    65.             } else if(length % 3 == 2) {
    66.                 str = "0"+str;
    67.             }
    68.  
    69.             int start = 0;
    70.             int end = 3;
    71.             StringBuffer sb = new StringBuffer();
    72.             for(int i=0; i3; i++) {
    73.                 String subStr = str.substring(start, end); //抽取三个二进制字符
    74.                 start += 3;
    75.                 end += 3;
    76.                 String s = transform2(subStr); //将抽取的二进制字符串转换成八进制字符
    77.                 sb.append(s);
    78.             }
    79.             return sb.toString();
    80.         }
    81.  
    82.         //将抽取的十六进制字符转换成二进制字符
    83.         private static String transform(String str) {
    84.             String result = "";
    85.             switch (str) {
    86.                 case "0": result = bin[0]; break;
    87.                 case "1": result = bin[1]; break;
    88.                 case "2": result = bin[2]; break;
    89.                 case "3": result = bin[3]; break;
    90.                 case "4": result = bin[4]; break;
    91.                 case "5": result = bin[5]; break;
    92.                 case "6": result = bin[6]; break;
    93.                 case "7": result = bin[7]; break;
    94.                 case "8": result = bin[8]; break;
    95.                 case "9": result = bin[9]; break;
    96.                 case "A": result = bin[10]; break;
    97.                 case "B": result = bin[11]; break;
    98.                 case "C": result = bin[12]; break;
    99.                 case "D": result = bin[13]; break;
    100.                 case "E": result = bin[14]; break;
    101.                 case "F": result = bin[15]; break;
    102.                 default: break;
    103.             }
    104.             return result;
    105.         }
    106.  
    107.         //将抽取的二进制字符串转换成八进制字符
    108.         private static String transform2(String str) {
    109.             String result = "";
    110.             switch (str) {
    111.                 case "000": result = oct[0]; break;
    112.                 case "001": result = oct[1]; break;
    113.                 case "010": result = oct[2]; break;
    114.                 case "011": result = oct[3]; break;
    115.                 case "100": result = oct[4]; break;
    116.                 case "101": result = oct[5]; break;
    117.                 case "110": result = oct[6]; break;
    118.                 case "111": result = oct[7]; break;
    119.             }
    120.             return result;
    121.         }
    122. }


     

    二、扩展

    （一）16转10

    问题描述

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

    样例输入

    FFFF

    样例输出

    65535

    代码

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

    （二）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进制表示

    样例输入

    30

    样例输出

    1E

    代码

    1. import java.util.Scanner;
    2. public class Main {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         int n = sc.nextInt();
    6.         String result = Integer.toBinaryString(n); //API接口 直接转换为二进制
    7.         System.out.println(binToHex(result));
    8.     }
    9.     //二进制转换成八进制
    10.     private static String binToHex(String str) {
    11.         int length = str.length();
    12.         if(length % 4 == 1) {
    13.             str= "000"+str;
    14.         } else if(length % 4 == 2) {
    15.             str = "00"+str;
    16.         }else if(length % 4 == 3) {
    17.             str = "0"+str;
    18.         }
    19.         int start = 0;
    20.         int end = 4;
    21.         StringBuffer sb = new StringBuffer();
    22.         for(int i=0; i<str.length()/4; i++) {
    23.             String subStr = str.substring(start, end); //抽取四个二进制字符
    24.             start += 4;
    25.             end += 4;
    26.             String s = transform2(subStr); //将抽取的二进制字符串转换成十六进制字符
    27.             sb.append(s);
    28.         }
    29.         return sb.toString();
    30.     }  
    31.  
    32.     //将抽取的二进制字符串转换成八进制字符
    33.  
    34.     private static String transform2(String str) {
    35.         String result = "";
    36.         switch (str) {
    37.             case "0000": result = "0"; break;
    38.             case "0001": result = "1"; break;
    39.             case "0010": result = "2"; break;
    40.             case "0011": result = "3"; break;
    41.             case "0100": result = "4"; break;
    42.             case "0101": result = "5"; break;
    43.             case "0110": result = "6"; break;
    44.             case "0111": result = "7"; break;
    45.             case "1000": result = "8"; break;
    46.             case "1001": result = "9"; break;
    47.             case "1010": result = "A"; break;
    48.             case "1011": result = "B"; break;
    49.             case "1100": result = "C"; break;
    50.             case "1101": result = "D"; break;
    51.             case "1110": result = "E"; break;
    52.             case "1111": result = "F"; break;
    53.             }
    54.             return result;
    55.         }
    56. }

    （三）10转2

    3.1代码

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

    3.2改进代码

    1. import java.util.Scanner;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         long n = sc.nextLong();
    7.         String str = "";
    8.         while (n != 0) {
    9.             str = n % 2 + str;
    10.             n = n / 2;
    11.         }
    12.         System.out.println(str);
    13.     }
    14. }

    3.3二次改进代码

    1. import java.util.Scanner;
    2. public class Main {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         int n = sc.nextInt();
    6.         String result = Integer.toBinaryString(n); //API接口 直接转换为二进制
    7.         System.out.println(result);
    8.     }
    9. }

  • 相关阅读:
    prometheus helm install 如何配置告警模版
    《程序员数学：斐波那契》—— 为什么不能用斐波那契散列，做数据库路由算法？
    给github项目贡献代码
    docker 安装redis(最新版)
    2023-06-09：什么是Redis事务？原理是什么？
    Elasticsearch语句—SQL详解
    程序公司分红及退出机制设计(1)
    跟着江南一点雨学习springmvc（3）
    【已解决】vs2022 编译成功但是疯狂报错E1696找不到源文件
    基本的TCP套接字编程（详解）
  • 原文地址：https://blog.csdn.net/QENGFENG/article/details/127607410