将二进制数转换成八进制数-yiteyi-C++库

问题是将给定的二进制数（表示为字符串）转换为其等效的八进制数。输入可能非常大，甚至可能不适合无符号long int。

null

例如：

Input : 110001110Output : 616Input  : 1111001010010100001.010110110011011Output : 1712241.26633

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

其思想是将二进制输入看作字符串，然后按照以下步骤：

获取小数点（’.’）左右的子字符串长度，如下所示： 左_len 和 对_len .
如果 左_len 不是3的倍数。在开头加上0的最小数，使左子串的长度为3的倍数。
如果 对_len 不是3的倍数最后加上0的最小数，使右子串的长度为3的倍数。
现在，从左边逐个提取长度为3的子字符串，并将其相应的八进制代码添加到结果中。
如果遇到小数点（’.’），则将其添加到结果中。

C++

                         // C++ implementation to convert a binary number                       
                         // to octal number                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
                                   
                         // function to create map between binary                       
                         // number and its equivalent octal                       
                         void                                     createMap(unordered_map<string,                                     char                                     > *um)                       
                         {                       
                                                 (*um)[                                     "000"                                     ] =                                     '0'                                     ;                       
                                                 (*um)[                                     "001"                                     ] =                                     '1'                                     ;                       
                                                 (*um)[                                     "010"                                     ] =                                     '2'                                     ;                       
                                                 (*um)[                                     "011"                                     ] =                                     '3'                                     ;                       
                                                 (*um)[                                     "100"                                     ] =                                     '4'                                     ;                       
                                                 (*um)[                                     "101"                                     ] =                                     '5'                                     ;                       
                                                 (*um)[                                     "110"                                     ] =                                     '6'                                     ;                       
                                                 (*um)[                                     "111"                                     ] =                                     '7'                                     ;                       
                         }                       
                                   
                         // Function to find octal equivalent of binary                       
                         string convertBinToOct(string bin)                       
                         {                       
                                                 int                                     l = bin.size();                       
                                                 int                                     t = bin.find_first_of(                                     '.'                                     );                       
                                   
                                                 // length of string before '.'                       
                                                 int                                     len_left = t != -1 ? t : l;                       
                                   
                                                 // add min 0's in the beginning to make                       
                                                 // left substring length divisible by 3                       
                                                 for                                     (                                     int                                     i = 1; i <= (3 - len_left % 3) % 3; i++)                       
                                                 bin =                                     '0'                                     + bin;                       
                                   
                                                 // if decimal point exists                       
                                                 if                                     (t != -1)                       
                                                 {                       
                                                 // length of string after '.'                       
                                                 int                                     len_right = l - len_left - 1;                       
                                   
                                                 // add min 0's in the end to make right                       
                                                 // substring length divisible by 3                       
                                                 for                                     (                                     int                                     i = 1; i <= (3 - len_right % 3) % 3; i++)                       
                                                 bin = bin +                                     '0'                                     ;                       
                                                 }                       
                                   
                                                 // create map between binary and its                       
                                                 // equivalent octal code                       
                                                 unordered_map<string,                                     char                                     > bin_oct_map;                       
                                                 createMap(&bin_oct_map);                       
                                   
                                                 int                                     i = 0;                       
                                                 string octal =                                     ""                                     ;                       
                                   
                                                 while                                     (1)                       
                                                 {                       
                                                 // one by one extract from left, substring                       
                                                 // of size 3 and add its octal code                       
                                                 octal += bin_oct_map[bin.substr(i, 3)];                       
                                                 i += 3;                       
                                                 if                                     (i == bin.size())                       
                                                 break                                     ;                       
                                   
                                                 // if '.' is encountered add it to result                       
                                                 if                                     (bin.at(i) ==                                     '.'                                     )                       
                                                 {                       
                                                 octal +=                                     '.'                                     ;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
                                   
                                                 // required octal number                       
                                                 return                                     octal;                       
                         }                       
                                   
                         // Driver program to test above                       
                         int                                     main()                       
                         {                       
                                                 string bin =                                     "1111001010010100001.010110110011011"                                     ;                       
                                                 cout <<                                     "Octal number = "                       
                                                 << convertBinToOct(bin);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java implementation to convert a                       
                         // binary number to octal number                       
                         import                                     java.io.*;                       
                         import                                     java.util.*;                       
           
                         class                                     GFG{                       
           
                         // Function to create map between binary                       
                         // number and its equivalent hexadecimal                       
                         static                                     void                                     createMap(Map<String, Character> um)                       
                         {                       
                                                 um.put(                                     "000"                                     ,                                     '0'                                     );                       
                                                 um.put(                                     "001"                                     ,                                     '1'                                     );                       
                                                 um.put(                                     "010"                                     ,                                     '2'                                     );                       
                                                 um.put(                                     "011"                                     ,                                     '3'                                     );                       
                                                 um.put(                                     "100"                                     ,                                     '4'                                     );                       
                                                 um.put(                                     "101"                                     ,                                     '5'                                     );                       
                                                 um.put(                                     "110"                                     ,                                     '6'                                     );                       
                                                 um.put(                                     "111"                                     ,                                     '7'                                     );                       
                         }                       
           
                         // Function to find octal equivalent of binary                       
                         static                                     String convertBinToOct(String bin)                       
                         {                       
                                                 int                                     l = bin.length();                       
                                                 int                                     t = bin.indexOf(                                     '.'                                     );                       
           
                                                 // Length of string before '.'                       
                                                 int                                     len_left = t != -                                     1                                     ? t : l;                       
           
                                                 // Add min 0's in the beginning to make                       
                                                 // left substring length divisible by 3                       
                                                 for                                     (                                     int                                     i =                                     1                                     ;                       
                                                 i <= (                                     3                                     - len_left %                                     3                                     ) %                                     3                                     ;                       
                                                 i++)                       
                                                 bin =                                     '0'                                     + bin;                       
           
                                                 // If decimal point exists                       
                                                 if                                     (t != -                                     1                                     )                       
                                                 {                       
                                   
                                                 // Length of string after '.'                       
                                                 int                                     len_right = l - len_left -                                     1                                     ;                       
           
                                                 // add min 0's in the end to make right                       
                                                 // substring length divisible by 3                       
                                                 for                                     (                                     int                                     i =                                     1                                     ;                       
                                                 i <= (                                     3                                     - len_right %                                     3                                     ) %                                     3                                     ;                       
                                                 i++)                       
                                                 bin = bin +                                     '0'                                     ;                       
                                                 }                       
           
                                                 // Create map between binary and its                       
                                                 // equivalent octal code                       
                                                 Map<String,                       
                                                 Character> bin_oct_map =                                     new                                     HashMap<String,                       
                                                 Character>();                       
                                                 createMap(bin_oct_map);                       
           
                                                 int                                     i =                                     0                                     ;                       
                                                 String octal =                                     ""                                     ;                       
           
                                                 while                                     (                                     true                                     )                       
                                                 {                       
                                   
                                                 // One by one extract from left, substring                       
                                                 // of size 3 and add its octal code                       
                                                 octal += bin_oct_map.get(                       
                                                 bin.substring(i, i +                                     3                                     ));                       
                                                 i +=                                     3                                     ;                       
                                   
                                                 if                                     (i == bin.length())                       
                                                 break                                     ;                       
           
                                                 // If '.' is encountered add it to result                       
                                                 if                                     (bin.charAt(i) ==                                     '.'                                     )                       
                                                 {                       
                                                 octal +=                                     '.'                                     ;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 // Required octal number                       
                                                 return                                     octal;                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     main(String[] args)                       
                         {                       
                                                 String bin =                                     "1111001010010100001.010110110011011"                                     ;                       
                                                 System.out.println(                                     "Octal number = "                                     +                       
                                                 convertBinToOct(bin));                       
                         }                       
                         }                       
           
                         // This code is contributed by jithin                       

Python3

                         # Python3 implementation to convert a binary number                       
                         # to octal number                       
           
                         # function to create map between binary                       
                         # number and its equivalent octal                       
                         def                                     createMap(bin_oct_map):                       
                                                 bin_oct_map[                                     "000"                                     ]                                     =                                     '0'                       
                                                 bin_oct_map[                                     "001"                                     ]                                     =                                     '1'                       
                                                 bin_oct_map[                                     "010"                                     ]                                     =                                     '2'                       
                                                 bin_oct_map[                                     "011"                                     ]                                     =                                     '3'                       
                                                 bin_oct_map[                                     "100"                                     ]                                     =                                     '4'                       
                                                 bin_oct_map[                                     "101"                                     ]                                     =                                     '5'                       
                                                 bin_oct_map[                                     "110"                                     ]                                     =                                     '6'                       
                                                 bin_oct_map[                                     "111"                                     ]                                     =                                     '7'                       
           
                         # Function to find octal equivalent of binary                       
                         def                                     convertBinToOct(                                     bin                                     ):                       
                                                 l                                     =                                     len                                     (                                     bin                                     )                       
                                   
                                                 # length of string before '.'                       
                                                 t                                     =                                     -                                     1                       
                                                 if                                     '.'                                     in                                     bin                                     :                       
                                                 t                                     =                                     bin                                     .index(                                     '.'                                     )                       
                                                 len_left                                     =                                     t                       
                                                 else                                     :                       
                                                 len_left                                     =                                     l                       
                                   
                                                 # add min 0's in the beginning to make                       
                                                 # left substring length divisible by 3                       
                                                 for                                     i                                     in                                     range                                     (                                     1                                     , (                                     3                                     -                                     len_left                                     %                                     3                                     )                                     %                                     3                                     +                                     1                                     ):                       
                                                 bin                                     =                                     '0'                                     +                                     bin                       
                                   
                                                 # if decimal point exists                       
                                                 if                                     (t !                                     =                                     -                                     1                                     ):                       
                                   
                                                 # length of string after '.'                       
                                                 len_right                                     =                                     l                                     -                                     len_left                                     -                                     1                       
                                   
                                                 # add min 0's in the end to make right                       
                                                 # substring length divisible by 3                       
                                                 for                                     i                                     in                                     range                                     (                                     1                                     , (                                     3                                     -                                     len_right                                     %                                     3                                     )                                     %                                     3                                     +                                     1                                     ):                       
                                                 bin                                     =                                     bin                                     +                                     '0'                       
                                   
                                                 # create dictionary between binary and its                       
                                                 # equivalent octal code                       
                                                 bin_oct_map                                     =                                     {}                       
                                                 createMap(bin_oct_map)                       
                                                 i                                     =                                     0                       
                                                 octal                                     =                                     ""                       
                                   
                                                 while                                     (                                     True                                     ) :                       
                                   
                                                 # one by one extract from left, substring                       
                                                 # of size 3 and add its octal code                       
                                                 octal                                     +                                     =                                     bin_oct_map[                                     bin                                     [i:i                                     +                                     3                                     ]]                       
                                                 i                                     +                                     =                                     3                       
                                                 if                                     (i                                     =                                     =                                     len                                     (                                     bin                                     )):                       
                                                 break                       
                                   
                                                 # if '.' is encountered add it to result                       
                                                 if                                     (                                     bin                                     [i]                                     =                                     =                                     '.'                                     ):                       
                                                 octal                                     +                                     =                                     '.'                       
                                                 i                                     +                                     =                                     1                       
                                   
                                                 # required octal number                       
                                                 return                                     octal                       
           
                         # Driver Code                       
                         bin                                     =                                     "1111001010010100001.010110110011011"                       
                         print                                     (                                     "Octal number = "                                     ,                       
                                                 convertBinToOct(                                     bin                                     ))                       
           
                         # This code is contributed                       
                         # by Atul_kumar_Shrivastava                       

C#

                         // C# implementation to convert a                       
                         // binary number to octal number                       
           
                         using                                     System;                       
                         using                                     System.Collections.Generic;                       
           
                         public                                     class                                     GFG{                       
           
                         // Function to create map between binary                       
                         // number and its equivalent hexadecimal                       
                         static                                     void                                     createMap(Dictionary<String,                                     char                                     > um)                       
                         {                       
                                                 um.Add(                                     "000"                                     ,                                     '0'                                     );                       
                                                 um.Add(                                     "001"                                     ,                                     '1'                                     );                       
                                                 um.Add(                                     "010"                                     ,                                     '2'                                     );                       
                                                 um.Add(                                     "011"                                     ,                                     '3'                                     );                       
                                                 um.Add(                                     "100"                                     ,                                     '4'                                     );                       
                                                 um.Add(                                     "101"                                     ,                                     '5'                                     );                       
                                                 um.Add(                                     "110"                                     ,                                     '6'                                     );                       
                                                 um.Add(                                     "111"                                     ,                                     '7'                                     );                       
                         }                       
           
                         // Function to find octal equivalent of binary                       
                         static                                     String convertBinToOct(String bin)                       
                         {                       
                                                 int                                     l = bin.Length;                       
                                                 int                                     t = bin.IndexOf(                                     '.'                                     );                       
                                                 int                                     i = 0;                       
                                                 // Length of string before '.'                       
                                                 int                                     len_left = t != -1 ? t : l;                       
           
                                                 // Add min 0's in the beginning to make                       
                                                 // left substring length divisible by 3                       
                                                 for                                     (i = 1;                       
                                                 i <= (3 - len_left % 3) % 3;                       
                                                 i++)                       
                                                 bin =                                     '0'                                     + bin;                       
           
                                                 // If decimal point exists                       
                                                 if                                     (t != -1)                       
                                                 {                       
                                   
                                                 // Length of string after '.'                       
                                                 int                                     len_right = l - len_left - 1;                       
           
                                                 // add min 0's in the end to make right                       
                                                 // substring length divisible by 3                       
                                                 for                                     (i = 1;                       
                                                 i <= (3 - len_right % 3) % 3;                       
                                                 i++)                       
                                                 bin = bin +                                     '0'                                     ;                       
                                                 }                       
           
                                                 // Create map between binary and its                       
                                                 // equivalent octal code                       
                                                 Dictionary<String,                       
                                                 char                                     > bin_oct_map =                                     new                                     Dictionary<String,                       
                                                 char                                     >();                       
                                                 createMap(bin_oct_map);                       
           
                                                 i = 0;                       
                                                 String octal =                                     ""                                     ;                       
           
                                                 while                                     (                                     true                                     )                       
                                                 {                       
                                   
                                                 // One by one extract from left, substring                       
                                                 // of size 3 and add its octal code                       
                                                 octal += bin_oct_map[                       
                                                 bin.Substring(i,  3)];                       
                                                 i += 3;                       
                                   
                                                 if                                     (i == bin.Length)                       
                                                 break                                     ;                       
           
                                                 // If '.' is encountered add it to result                       
                                                 if                                     (bin[i] ==                                     '.'                                     )                       
                                                 {                       
                                                 octal +=                                     '.'                                     ;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 // Required octal number                       
                                                 return                                     octal;                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     Main(String[] args)                       
                         {                       
                                                 String bin =                                     "1111001010010100001.010110110011011"                                     ;                       
                                                 Console.WriteLine(                                     "Octal number = "                                     +                       
                                                 convertBinToOct(bin));                       
                         }                       
                         }                       
           
                         // This code is contributed by 29AjayKumar                       

Javascript

                         <script>                       
           
                         // Javascript implementation to convert a                       
                         // binary number to octal number                       
           
                         // Function to create map between binary                       
                         // number and its equivalent hexadecimal                       
                         function                                     createMap(um)                       
                         {                       
                                                 um.set(                                     "000"                                     ,                                     '0'                                     );                       
                                                 um.set(                                     "001"                                     ,                                     '1'                                     );                       
                                                 um.set(                                     "010"                                     ,                                     '2'                                     );                       
                                                 um.set(                                     "011"                                     ,                                     '3'                                     );                       
                                                 um.set(                                     "100"                                     ,                                     '4'                                     );                       
                                                 um.set(                                     "101"                                     ,                                     '5'                                     );                       
                                                 um.set(                                     "110"                                     ,                                     '6'                                     );                       
                                                 um.set(                                     "111"                                     ,                                     '7'                                     );                       
                         }                       
           
                         // Function to find octal equivalent of binary                       
                         function                                     convertBinToOct(bin)                       
                         {                       
                                   
                                                 let l = bin.length;                       
                                                 let t = bin.indexOf(                                     '.'                                     );                       
           
                                                 // Length of string before '.'                       
                                                 let len_left = t != -1 ? t : l;                       
           
                                                 // Add min 0's in the beginning to make                       
                                                 // left substring length divisible by 3                       
                                                 for                                     (let i = 1;                       
                                                 i <= (3 - len_left % 3) % 3;                       
                                                 i++)                       
                                                 bin = '0                                     ' + bin;                       
           
                                                 // If decimal point exists                       
                                                 if (t != -1)                       
                                                 {                       
                                   
                                                 // Length of string after '                                     .                                     '                       
                                                 let len_right = l - len_left - 1;                       
           
                                                 // add min 0'                                     s                                     in                                     the end to make right                       
                                                 // substring length divisible by 3                       
                                                 for                                     (let i = 1;                       
                                                 i <= (3 - len_right % 3) % 3;                       
                                                 i++)                       
                                                 bin = bin +                                     '0'                                     ;                       
                                                 }                       
           
                                                 // Create map between binary and its                       
                                                 // equivalent octal code                       
                                                 let bin_oct_map =                                     new                                     Map();                       
           
                                                 createMap(bin_oct_map);                       
           
                                                 let i = 0;                       
                                                 let octal =                                     ""                                     ;                       
           
                                                 while                                     (                                     true                                     )                       
                                                 {                       
                                   
                                                 // One by one extract from left, substring                       
                                                 // of size 3 and add its octal code                       
                                                 octal += bin_oct_map.get(bin.substr(i, 3));                       
                                                 i += 3;                       
           
                                                 if                                     (i == bin.length)                       
                                                 break                                     ;                       
           
                                                 // If '.' is encountered add it to result                       
                                                 if                                     (bin.charAt(i) ==                                     '.'                                     )                       
                                                 {                       
                                                 octal +=                                     '.'                                     ;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 // Required octal number                       
                                                 return                                     octal;                       
                         }                       
           
                         // Driver code                       
                         let bin =                                     "1111001010010100001.010110110011011"                                     ;                       
                         document.write(                                     "Octal number = "                                     +                       
                                                 convertBinToOct(bin));                       
           
                         // This code is contributed by gfgking                       
           
                         </script>                       

输出：

Octal number = 1712241.26633

时间复杂度：O（n），其中n是字符串的长度。

本文由 阿尤什·焦哈里 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END