精华内容
下载资源
问答
  • C语言 · 十六进制转十进制
    千次阅读
    2021-05-23 06:10:49

    问题描述 从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出. 注:十六进制数中的10~15分别用大写的英文字母A.B.C.D.E.F表示. 样例输入 FFFF 样例输出 65535   思路:感觉自己的下面两个方法都对,但是···不说了[狡诈]... 方案一: #include#include#includeint main(){ char s[50]; scanf("%s&qu…

    二进制是计算技术中广泛采用的一种数制.二进制数据是用0和1两个数码来表示的数.它的基数为2,进位规则是"逢二进一",借位规则是"借一当二",由18世纪德国数理哲学大师莱布尼兹发现.当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的.计算机中的二进制则是一个非常微小的开关,用"开"来表示1,"关"来表示0. 19世纪爱尔兰逻辑学家乔治布尔对逻辑命题的思考过程转化为对符号"0''.''1''…

    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 进制转换 { class Program { static void Main(string[] args) { //由于二进制数在C#中无法直接表示,所以所有二进制数都用一个字符串来表示,例如: 二进制: 1010 表示为 字符串:"1010&q…

    更多相关内容
  • 要转换的十六进制正整数,每个十六进制数长度不超过100000 1.思路:16进制转2进制,再转8进制,我先转的10进制,数据小还 行,数据大了就game over了。(本题数据最大为10万位) 2.判断2进制的位数对3取模是多少,...
  • 接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式 输出n行,每行为输入对应的八进制正整数。 【注意】 输入的十六进制数不会有前导0,...

    十六进制转八进制

    问题描述

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

    输入格式

    输入的第一行为一个正整数n (1<=n<=10)。
    接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。

    输出格式

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

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

    样例输入

    2
    39
    123ABC

    样例输出

    71
    4435274

    【提示】
    先将十六进制数转换成某进制数,再由某进制数转换成八进制。

    代码如下:

    import java.math.BigInteger;
    import java.util.Scanner;
    
    public class 十六进制转八进制 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		sc.nextLine();
    		for (int i = 0; i < n; i++) {
    			System.out.println(new BigInteger(sc.nextLine(), 16).toString(8));
    		}
    	}
    }
    

    在这里插入图片描述

    十六进制转十进制

    问题描述

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

    样例输入

    FFFF

    样例输出

    65535

    代码如下:

    Java
    import java.util.Scanner;
    
    public class 十六进制转十进制 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String n = sc.nextLine();
    		System.out.println(Long.valueOf(n, 16));
    	}
    }
    

    在这里插入图片描述

    C++
    #include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    int main()
    {
    	long long s;
    	scanf("%llx", &s);
    	printf("%lld", s);
    	return 0;
    }
    

    在这里插入图片描述

    十进制转十六进制

    问题描述

    十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

    代码如下:

    Java
    import java.util.Scanner;
    
    public class 十进制转十六进制 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		System.out.println(Integer.toHexString(n).toUpperCase());//转为十六进制A---F大写
    	}
    }
    

    在这里插入图片描述

    C++
    #include<iostream>
    #include <cstdio>
    
    using namespace std;
    
    int main()
    {
       int n;
       scanf("%d",&n);
       printf("%X",n);
       return 0;
    }
    

    在这里插入图片描述

    小结:

    十进制向二、八、十六进制的转换
    Integer.toBinaryString(i)表示十进制转为二进制
    Integer.toOctalString(i)表示十进制转为八进制
    Integer.toHexString(i)表示十进制转为十六进制

    进制转换问题可以直接用格式化输出。
    十进制整数,%o表示以八进制进行输出
    十进制整数,%X / %x表示以十六进制进行输出,大写X表示使用大写字母,小写x表示使用小写字母。
    另外使用%#o,%#X,%#x,得到的输出包含前缀0,0X,0x。

    展开全文
  • 十六进制转八进制

    千次阅读 2021-01-31 14:35:13
    接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式 输出n行,每行为输入对应的八进制正整数。 【注意】 输入的十六进制数不会有前导0,...

    进制转换是一个程序员基本的能力,今天就来一道进制转换来下下饭。

    十六进制转八进制

    资源限制

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

    问题描述

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

    输入格式

    输入的第一行为一个正整数n (1<=n<=10)

    接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000

    输出格式

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

    【注意】

    输入的十六进制数不会有前导0,比如012A
    输出的八进制数也不能有前导0

    样例输入

        2
        39
        123ABC
    

    样例输出

        71
        4435274
    
    【提示】

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

    题目解析

    首先要注意的是,题中说“每个十六进制数长度不超过100000”,这里是长度而不是大小,所以输入有可能是十万位的十六进制数,这个数非常大,我们不能通过简单的%X输入十六进制到变量中再%O输出八进制来实现,因为没有一个变量能够直接存放这么大的数,所以整个转换流程都是以字符串操作的方式实现的。

    再一个就是输入输出的数中都不应该有前导0,也就是不会出现类似012A的数,而应该是12A,输出也不应该是0452,而应该只有452,前导0在转换过程中会不可避免得出现,必须进行处理保证不会输出。

    还有就是在提示中说了,“先将十六进制数转换成某进制数,再由某进制数转换成八进制。”,在实际计算时,对于2的幂的进制互转,都会先转为二进制再进行转换,比如本次的十六进制和八进制,分别都是2的4次幂和2的3次幂,所以先转为二进制再转换会更容易操作。

    二进制,八进制,十进制,十六进制的对应关系如下表所示。

    二进制八进制十六进制十进制
    0000000
    0001111
    0010222
    0011333
    0100444
    0101555
    0110666
    0111777
    100088
    100199
    1010A
    1011B
    1100C
    1101D
    1110E
    1111F

    十六进制与二进制的互转只需要将1位十六进制转换为4位二进制,二进制则相反,不足4的倍数的在左侧补0。

    八进制与二进制互转同理,只不过4变为3。

    这样就有了整道题的思路,只需要对字符串进行操作即可。

    代码

    本题的流程可以写成以下几点:

    1. 输入正整数n(十六进制数个数)
    2. 输入十六进制数
    3. 十六进制字符串转二进制字符串
    4. 二进制字符串转八进制字符串
    5. 输出八进制字符串

    只需要循环以上2~5步即可转换所有的十六进制数。

    代码框架如下:

    #include <stdio.h>
    #include <string.h>
    
    int main(void)
    {
        //1.输入正整数n
        //2.输入十六进制字符串
        //3.十六进制字符串转二进制字符串
        //4.二进制字符串转八进制字符串
        //5.输出八进制字符串
    
        return 0;
    }
    

    加入string.h头文件以帮助处理字符串。

    然后加入输入n和循环。

    #include <stdio.h>
    #include <string.h>
    
    int main(void)
    {
        int n = 0;
        int i = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            //3.十六进制字符串转二进制字符串
            //4.二进制字符串转八进制字符串
            //5.输出八进制字符串
        }
        return 0;
    }
    

    由于要通过字符串进行处理,那么必然要有三个数组用来保存输入的十六进制字符串、中间产生的二进制字符串和最后的八进制字符串。并且因为转换时同一个数不同进制的长度不同,所以三个字符串的大小应为3:12:4的关系(1位十六进制换4位二进制,1位八进制换3位二进制)。

    声明以上三个数组并加入十六进制字符串输出部分。

    #include <stdio.h>
    #include <string.h>
    
    char hex[100001]; //最长100000位,结尾多加一个放结束符
    char bin[400001]; //4倍于十六进制
    char oct[140001]; //3/4倍于十六进制取整
    
    int main(void)
    {
        int n = 0;
        int i = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            scanf("%s", hex);
            //3.十六进制字符串转二进制字符串
            //4.二进制字符串转八进制字符串
            //5.输出八进制字符串
        }
        return 0;
    }
    

    十六进制转二进制时我们首先要知道每一个十六进制位代表的数是多少,所以写一个函数用来将1个十六进制字符转为1个0-15的整型数。题中说明十六进制字符串中只会出现“0~9大写字母A~F”,所以进行如下处理,最后的返回-1为了补全else。

    int hex2int(char ch)
    {
        if (ch >= '0' && ch <= '9')
        {
            return ch - '0';
        }
        else if (ch >= 'A' && ch <= 'F')
        {
            return ch - 'A' + 10;
        }
        else
        {
            return -1;
        }
    }
    

    随后将这一位转为二进制数表示,在我前面的文章中已经写过二进制的计算方法:

    进制,即进位计数制,是人为定义的一种带进位的计数方法,便于使用有限的数字字符表示所有的数。对于任何一种进制都表示某一位置上的数字达到某一值后向上进一位。如常用的十进制计算9+1时,当个位数字9增加1时,应该变为十,但是我们采用十进制计数,所以在这一位上并不会出现表示十的数字,而是向上进位变为10。同理,对于8进制而言,当计算7+1时,并不出现8这个数字,而是变为10,而这个8进制的10与十进制的8是相等的。也可以发现,进制的转换并不会改变数值本身的大小,只是表示方法的改变。

    进制的转换通常可以使用连续做除法取余数的方式,如十进制数6转二进制可以如下方式计算:

    6 ÷ 2 = 3......0 6 ÷2 = 3 ...... 0 6÷2=3......0
    3 ÷ 2 = 1......1 3 ÷2 = 1 ...... 1 3÷2=1......1
    1 ÷ 2 = 0......1 1 ÷2 = 0 ...... 1 1÷2=0......1

    将余数从下往上倒过来即是相应进制,即6的二进制表示为110

    因为在进制转换的过程中数值大小本身并不变化,所以人工计算时对于不方便计算的数值也可以通过转换为其他进制作为媒介来进行。

    ——蓝桥专题之二进制数数(及其优化)

    在转为二进制时,我们可以将0~F的二进制字符串写成数组,然后通过char *strcat(char *des, const char *src)进行拼接即可,

    据此,我们可以写出转二进制代码。返回值为二进制字符串长度(非必须)。

    //0~F的二进制分别为以下16个字符串
    const char binarr[16][5] = {
        "0000", "0001", "0010", "0011",
        "0100", "0101", "0110", "0111",
        "1000", "1001", "1010", "1011",
        "1100", "1101", "1110", "1111"};
    
    /**************************************
     * @param hex 要转换的十六进制字符串
     * @param bin 转换后的二进制字符串
     * @retval 转换后的二进制字符串长度
     *************************************/
    int hex2bin(const char *hex, char *bin)
    {
        int i = 0;
        size_t size = 0;
        //将bin数组第0位置为'\0',即字符串长度为0
        bin[0] = '\0';
        //获取十六进制数长度
        size = strlen(hex);
        for (i = 0; i < size; i++)
        {
            //将十六进制字符串的一位转为整型数然后
            //通过strcat()将对应的二进制添加至二进制字符串结尾
            strcat(bin, binarr[hex2int(hex[i])]);
        }
        return 4 * size;
    }
    

    在编写程序的时候,我们通常会将复杂的程序逻辑分成模块进行,这也是函数的意义之一。对于复杂的程序,应该在编写完一个模块后优先对该模块进行测试,以保证模块的正确性。对于刚刚完成的部分程序,即十六进制字符串转二进制部分,我们可以先编写程序保证这部分的正确性。

    在主函数做如下改动,并将上面编写的转换函数一并放入源代码运行。

    int main(void)
    {
        int n = 0;
        int i = 0;
        int len = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            scanf("%s", hex);
            //3.十六进制字符串转二进制字符串
            //调用十六进制转二进制字符串的函数,将长度返回len
            len = hex2bin(hex, bin);
            //打印出转换好的二进制字符串
            printf(bin);
            //4.二进制字符串转八进制字符串
    
            //5.输出八进制字符串
        }
        return 0;
    }
    

    测试数据输入1行十六进制字符串123ABC,根据1字符变4字符原则转换后应该为000100100011101010111100

    测试结果如下

    1
    123ABC
    000100100011101010111100
    

    可以看到已经成功将十六进制数转为了二进制。下面开始二进制字符串到八进制字符串的转换。

    在二进制转八进制时,可能二进制字符串的长度不是3的倍数,这样在3位二进制换1位八进制的时候会出现长度不足的情况,所以我们需要对二进制字符串进行判断,并使长度不足3的倍数的二进制字符串补足到3的倍数。

    随后3个字符一组和1位八进制对应的3位二进制字符串进行比较,使用int strncmp(const char *, const char *, size_t)比较指定长度的字符串,返回0时为二者相等。循环将3位二进制字符和数组中的进行比较,相等时将对应的八进制数放入字符串。然后返回八进制字符串的长度(非必须)。

    //八进制0~7的二进制分别为以下8个字符串
    const char oct2binarr[8][4] = {
        "000", "001", "010", "011",
        "100", "101", "110", "111"};
    
    /**************************************
     * @param bin 要转换的十六进制字符串
     * @param oct 转换后的二进制字符串
     * @retval 转换后的二进制字符串长度
     *************************************/
    int bin2oct(char *bin, char *oct)
    {
        int i = 0;
        int j = 0;
        size_t size = 0;
        //将oct数组第0位置为'\0',即字符串长度为0
        oct[0] = '\0';
        //获取二进制数长度
        size = strlen(bin);
        //如果二进制字符串长度不为3的倍数,
        //则不能直接转换,需要补齐为3的倍数
        if (size % 3 != 0)
        {
            //将二进制字符串复制到向后3 - size % 3个字符的位置
            //3 - size % 3
            //3减size对3的余数的差即为需要补足的字符个数
            j = 3 - size % 3;
            for (i = size - 1; i >= 0; i--)
            {
                bin[i + j] = bin[i];
            }
            //然后将前面留出的3 - size % 3个字符置为'0'
            for (i = 0; i < j; i++)
            {
                bin[i] = '0';
            }
        }
        //获取新的二进制字符串长度
        size = strlen(bin);
        for (i = 0; i < size / 3; i++)
        {
            for (j = 0; j < 8; j++)
            {
                //比较字符串是否相等
                if (strncmp(bin + i * 3, oct2binarr[j], 3) == 0)
                {
                    oct[i] = j + '0';
                }
            }
        }
        return size / 3;
    }
    

    输入4位十六进制数5678,二进制应为0101011001111000,16位不是3的倍数,八进制应补齐3的倍数个并转换为53170,看我们的代码能否正确转换。

    使用如下主函数进行测试。

    int main(void)
    {
        int n = 0;
        int i = 0, j = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            scanf("%s", hex);
            //3.十六进制字符串转二进制字符串
            //调用十六进制转二进制字符串的函数,将长度返回len
            hex2bin(hex, bin);
            //4.二进制字符串转八进制字符串
            bin2oct(bin, oct);
            //5.输出八进制字符串
            printf(oct);
        }
        return 0;
    }
    

    测试结果如下

    1
    5678
    053170
    

    可以看出我们的程序已经正常工作了,但是现在存在前导0,所以还需要在输出时去除,可以在输出时先通过循环找到第一个非'0'的字符,然后将该字符和后面的字符串输出。

    int main(void)
    {
        int n = 0;
        int i = 0, j = 0;
        int len = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            scanf("%s", hex);
            //3.十六进制字符串转二进制字符串
            //调用十六进制转二进制字符串的函数,将长度返回len
            hex2bin(hex, bin);
            //4.二进制字符串转八进制字符串
            //len为八进制字符串长度
            len = bin2oct(bin, oct);
            //5.输出八进制字符串
            //从头循环每一个字符
            for (j = 0; j < len; j++)
            {
                //如果不是'0'则从该位开始输出
                if (oct[j] != '0')
                {
                    printf("%s\n", oct + j);
                    //随后直接退出循环
                    break;
                }
            }
        }
        return 0;
    }
    

    按照要求使用更长的数据进行测试。结果符合预期。(以下结果除第一行外,输入和输出交替)

    7
    76
    166
    931FA
    2230772
    C9DAB2B36C
    14473254531554
    248B87D6AE33F9A
    11105607655270637632
    62D7183A5D5789E4B2D6
    142656140722725361171131326
    B441E2411DC709E111C7E1E7ACB6F8CAC0BB2FC4C8BC2AE3BAAAB9165CC458E199CB89F51B135F7091A5ABB0874DF3E8CB45
    13210170440435616047410434374171726266761453005662770462136052707352525621313461054341463456117521542327670221513256604164676372145505
    43A5EB93B0441E9CA4C2B0FB3D30875CBF29ABD5B1ACF38984B35AE882809DD4CFE7ABC5C61BAA52E053B4C3643F204EF259D2E98042A948AAC5E884CB3EC7DB925643FD34FDD467E2CCA406035CB2744CB90A63E51C9737903343947E02086541E4C48A99630AA9AECE153843A4B190274EBC955F8592E30A2205A485846248987550AAF2094EC59E7931DC650C7451CC61C0CB2C46A1B3F2C349FAFF763C7F8D14DDFF946351744378D62C59285A8D7915614F5A2AC9E0D68ACA6248A9227AB8F1930EE38AC7A9D239C9B026A481E49D53161F9A9513FE5271C32E9C21D156EB9F1BEA57F6AE4F1B1DE3B7FD9CEE2D9CCA7B4C242D26C31D000B7F90B7FE48A131C7DEBFBE58165266DE56E1EDF26939AF07EC69AB1B17D8DB62143F2228B51551C3D2C7DE3F5072BD4D18C3AEB64CB9E8CBA838667B6ED2B2FCAB04ABAE8676E318B402A7D15B30D2D7DDB78650CC6AF82BC3D7AA805B02DD9AA523B7374A1323EE6B516D1B81E5F709C2C790EDAF1C3FA9B0A1DBC6DABC2B5ED267244C458752002B106D6381FAD58A7E193657BDE0FE029120F8379316891F828B8D24A049E5B86D855BCFED56765F9DA1AC54CAEAF9257ABC67B451BC70B0E52817DD1B704A6B418A83FD4A9CA4C89E1A6E779F8D9E9DF18747591E5B314C05763EDCD59632423CA83F14D6F073D784DB2B7001643A6760
    4164572711660210172345114126076636460416562771232572554326363423022632656420240116724637636536134303352451340247323033103744023571131645646002052451052542750411454766175562225441775151767243176131451003003271311642313441230762434456336201464162437401010312407446110523130605251535470251604164454310047235362252770262270605042013222054106111046072520525710112354263636230734312061642434614160145454215206637454151176577566170776150515677745061521350415706542613112055215362125412365505262360326425451422212444236534361446073434254365164434711540232444036223524613037465124237745116160627234103505267271743372453766534474330736166777316356133163123664604413223303072000133771026777444241143437365773713005451146674533417337115116327407730646530661373066661024176210505521252160751307674375203453651506141656554462717214565016063173335512627712540452727206355614305500124764255460645537355570312063065370127417275250013300556632512216671564502310767153242664334036276702341307441666570703765154120733615552741265732231622114213035220002542033261601765526123741446625736740774012211017406744613211077012134322224022362670333025336376652635457635503261246256537111275274317321215707026071224027672155602246550142501775225162446211703233473637433172357430350726217133142460053543733465313062204362501761232674071727411554533400054416463540
    

    提交练习系统OJ进行评测,发现运行超时。

    这说明算法效率还不够,数据处理用时太长。主要原因是以上代码中使用了C库中的函数
    char *strcat(char *des, const char *src)int strncmp(const char *, const char *, size_t)。这两个库函数的运行效率非常低,所以我们需要手动实现我们通过这两个库函数实现的功能。

    int hex2bin(const char *hex, char *bin)函数中的strcat()使用逐个赋值的方式进行替换,并在最后添加结束符。

    int hex2bin(const char *hex, char *bin)
    {
        int i = 0;
        size_t size = 0;
        //将bin数组第0位置为'\0',即字符串长度为0
        bin[0] = '\0';
        //获取十六进制数长度
        size = strlen(hex);
        for (i = 0; i < size; i++)
        {
            //将十六进制字符串的一位转为整型数然后
            //通过strcat()将对应的二进制添加至二进制字符串结尾
            //strcat(bin, hex2binarr[hex2int(hex[i])]);
            bin[i * 4 + 0] = hex2binarr[hex2int(hex[i])][0];
            bin[i * 4 + 1] = hex2binarr[hex2int(hex[i])][1];
            bin[i * 4 + 2] = hex2binarr[hex2int(hex[i])][2];
            bin[i * 4 + 3] = hex2binarr[hex2int(hex[i])][3];
        }
        //结尾添加结束符
        bin[size * 4] = '\0';
        return 4 * size;
    }
    

    int bin2oct(char *bin, char *oct)函数中的strcmp()使用按二进制位加权求和的方式进行替换。并在结尾添加结束符。

    int bin2oct(char *bin, char *oct)
    {
        int i = 0;
        int j = 0;
        size_t size = 0;
        //将oct数组第0位置为'\0',即字符串长度为0
        oct[0] = '\0';
        //获取二进制数长度
        size = strlen(bin);
        //如果二进制字符串长度不为3的倍数,
        //则不能直接转换,需要补齐为3的倍数
        if (size % 3 != 0)
        {
            //将二进制字符串复制到向后3 - size % 3个字符的位置
            //3 - size % 3
            //3减size对3的余数的差即为需要补足的字符个数
            j = 3 - size % 3;
            for (i = size - 1; i >= 0; i--)
            {
                bin[i + j] = bin[i];
            }
            //然后将前面留出的3 - size % 3个字符置为'0'
            for (i = 0; i < j; i++)
            {
                bin[i] = '0';
            }
        }
        //获取新的二进制字符串长度
        size = strlen(bin);
        for (i = 0; i < size / 3; i++)
        {
            // for (j = 0; j < 8; j++)
            // {
            //     if (strncmp(bin + i * 3, oct2binarr[j], 3) == 0)
            //     {
            //         oct[i] = j + '0';
            //     }
            // }
            oct[i] = (bin[i * 3 + 0] - '0') * 4 +
                     (bin[i * 3 + 1] - '0') * 2 +
                     (bin[i * 3 + 2] - '0') * 1 + '0';
        }
        //结尾添加结束符
        bin[size / 3] = '\0';
        return size / 3;
    }
    

    最终代码如下所示,篇幅限制,删除注释。

    #include <stdio.h>
    #include <string.h>
    
    char hex[100001];
    char bin[400001];
    char oct[140001];
    
    int hex2int(const char ch)
    {
        if (ch >= '0' && ch <= '9')
        {
            return ch - '0';
        }
        else if (ch >= 'A' && ch <= 'F')
        {
            return ch - 'A' + 10;
        }
        else
        {
            return -1;
        }
    }
    
    const char hex2binarr[16][5] = {
        "0000", "0001", "0010", "0011",
        "0100", "0101", "0110", "0111",
        "1000", "1001", "1010", "1011",
        "1100", "1101", "1110", "1111"};
    
    int hex2bin(const char *hex, char *bin)
    {
        int i = 0;
        size_t size = 0;
        bin[0] = '\0';
        size = strlen(hex);
        for (i = 0; i < size; i++)
        {
            bin[i * 4 + 0] = hex2binarr[hex2int(hex[i])][0];
            bin[i * 4 + 1] = hex2binarr[hex2int(hex[i])][1];
            bin[i * 4 + 2] = hex2binarr[hex2int(hex[i])][2];
            bin[i * 4 + 3] = hex2binarr[hex2int(hex[i])][3];
        }
        bin[size * 4] = '\0';
        return 4 * size;
    }
    
    const char oct2binarr[8][4] = {
        "000", "001", "010", "011",
        "100", "101", "110", "111"};
    
    int bin2oct(char *bin, char *oct)
    {
        int i = 0;
        int j = 0;
        size_t size = 0;
        oct[0] = '\0';
        size = strlen(bin);
        if (size % 3 != 0)
        {
            j = 3 - size % 3;
            for (i = size - 1; i >= 0; i--)
            {
                bin[i + j] = bin[i];
            }
            for (i = 0; i < j; i++)
            {
                bin[i] = '0';
            }
        }
      
        size = strlen(bin);
        for (i = 0; i < size / 3; i++)
        {
            oct[i] = (bin[i * 3 + 0] - '0') * 4 +
                     (bin[i * 3 + 1] - '0') * 2 +
                     (bin[i * 3 + 2] - '0') * 1 + '0';
        }
        return size / 3;
    }
    
    int main(void)
    {
        int n = 0;
        int i = 0, j = 0;
        int len = 0;
        //1.输入正整数n
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            //2.输入十六进制字符串
            scanf("%s", hex);
            //3.十六进制字符串转二进制字符串
            hex2bin(hex, bin);
            //4.二进制字符串转八进制字符串
            len = bin2oct(bin, oct);
            //5.输出八进制字符串
            for (j = 0; j < len; j++)
            {
                if (oct[j] != '0')
                {
                    printf("%s\n", oct + j);
                    break;
                }
            }
        }
        return 0;
    }
    

    提交OJ评测,正确。

    本题还挺考验思维能力的,有时候不能使用传统思维进行处理,比如本题的输入数据虽然是数,但是我们却不能按照数值来进行计算。尝试锻炼思维能力对算法设计非常重要。

    展开全文
  •  接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。输出格式 输出n行,每行为输入对应的八进制正整数。 【注意】 输入的十六进制数不会有前导...













    十六进制转八进制

    问题描述

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

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

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

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

    样例输入
      2
      39
      123ABC

    样例输出
      71
      4435274

       提示
      先将十六进制数转换成某进制数,再由某进制数转换成八进制。
    #include <string>
    #include <stdio.h>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    int main() {
    	int n;
    	scanf("%d", &n);
    	while(n--) {
    		string str1, str2 = "";
    		cin >> str1;
    		for(int i = 0; i < str1.length(); i++) {
    			switch(str1[i]) {
    				case '0': str2 += "0000";break;
    				case '1': str2 += "0001";break;
    				case '2': str2 += "0010";break;
    				case '3': str2 += "0011";break;
    				case '4': str2 += "0100";break;
    				case '5': str2 += "0101";break;
    				case '6': str2 += "0110";break;
    				case '7': str2 += "0111";break;
    				case '8': str2 += "1000";break;
    				case '9': str2 += "1001";break;
    				case 'A': str2 += "1010";break;
    				case 'B': str2 += "1011";break;
    				case 'C': str2 += "1100";break;
    				case 'D': str2 += "1101";break;
    				case 'E': str2 += "1110";break;
    				case 'F': str2 += "1111";break;
    				default: break;
    			}
    		}
    		int m = str2.length();
    		if(m%3 == 1) 
    			str2 = "00" + str2;
    		else if(m%3 == 2) 
    			str2 = "0" + str2;
    		int flag = 0;
    		//cout << str2 <<endl;
    		for(int i = 0; i <= str2.length()-3; i+=3) {
    			m = 2*2*(str2[i]-'0') + 2*(str2[i+1]-'0') + 1*(str2[i+2]-'0');
    			if(m) flag = 1;
    			if(flag) cout<<m;
    		}
    		puts("");
    	}
    	return 0;
    }

    十六进制转十进制

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

    #include <string>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    #define LL long long
    LL Pow_mod(LL a, LL b) { // a^b
    	LL ret = 1;
    	while(b != 0) {
    		if(b%2 == 1) 
    		ret *= a;
    		a *= a;
    		b /= 2;
    	}
    	return ret;
    }
    int main() {
    	string str1;
    	cin >> str1;
    	LL sum = 0;
    	int n = 0;
    	for(int i = str1.length()-1; i >= 0; i--) {
    		if(str1[i] >= '0' && str1[i] <= '9') {
    			sum += (str1[i]-'0')*Pow_mod(16, n);
    		}
    		else sum += (str1[i]-'A'+10)*Pow_mod(16, n);
    		n++;
    	}
    	cout << sum << endl;
    	return 0;
    }

    十进制转十六进制

    问题描述
      十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

    #include <stdio.h>
    char c[17] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    int main() {
    	int p = 0;
    	long long n;
    	int ans[1005];
    	scanf("%lld", &n);
    	if(!n) puts("0");
    	else
    	while(n) {
    		ans[p++] = n%16;
    		n /= 16;
    	}
    	for(int i = p-1; i >= 0; i--) {
    		printf("%c", c[ans[i]]);
    	}
    	return 0;
    }

    展开全文
  • 蓝桥杯 十六进制转为八进制 C语言版

    千次阅读 多人点赞 2022-01-01 16:35:26
     接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。 【注意】  输入的十六进制数不会有前导...
  • #include <iostream> #include <... //str、e、b分别保存十六、二、八进制数 cin>>n; while(n--) //连续输入 { cin>>str; int len=0; //保存二进制数的长度 for(i=s
  • 展开全部八进制与十六进制之间的转换32313133353236313431303231363533e4b893e5b19e31333366303831有两种方法:第一种:他们之间的转换可以先转成二进制然后再相互转换。第二种:他们之间的转换可以先转成十进制然后...
  • 16进制计算器开始——所有程序——附件——计算器电脑计算器16进制转换10进制怎么用在电脑自带的计算器中启用“程序员”设置,即可进行16进制转换10进制的操作。具体操作请参照以下步骤。1、在电脑的任务栏中找到...
  • C语言 · 十六进制转十进制问题描述从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出。注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。样例输入FFFF样例输出65535...
  •  接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。  【注意】  输入的十六进制数...
  • 接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式 输出n行,每行为输入对应的八进制正整数。 注意 输入的十六进制数不会有前导0,比如...
  • 在数学计算中,二进制计数系统的公分母是最小的,它以2为基数。你还记得在小学或中学时所学的不同的计数系统吗?笔者在上小学时,曾在一堂数学课中学过以6为基数的计数系统;你先数1,2,3,4,5,然后是10,11,12,...
  • Java实现蓝桥杯十六进制转八进制

    万次阅读 多人点赞 2019-06-06 20:54:50
    基础练习 十六进制转八进制 时间限制:1.0s 内存限制:512.0MB ... 接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n...
  • C语言 · 十六进制转十进制问题描述从键盘输入一个不超过8位的正的十六进制数字符串,将它转换为正的十进制数后输出。注:十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。样例输入FFFF样例输出65535...
  •  输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于n 。 输入格式  输入一行,包含一个正整数n。 输出格式  按从小到大的顺序输出满足条件的整数,每个整数占一行。 样例输入 52 样例...
  • 二进制和十六进制

    千次阅读 2018-08-16 08:40:17
    课程导言 【最早的编程语言是二进制语言,也是计算机能够直接...通过本篇的学习,你将了解到为什么计算机能够直接识别二进制语言,二进制的计数原理以及与十进制、十六进制之间的数值转换。】   在讲述二进制之...
  • 试题 基础练习 十六进制转八进制

    千次阅读 2020-04-26 00:36:00
     接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。 【注意】  输入的十六进制数不会有前导...
  • 十六进制转八进制(浅显易懂)

    千次阅读 多人点赞 2019-03-02 13:09:57
    十六进制转八进制 ...=10,每个数的长度不超过10000。 这里涉及到字符型以及string类类类型,待会再强调。 下面分析一下此题: 要想把十六进制转成八进制,首先想到把十六进制转成二进制再转成...
  •  接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。 【注意】  输入的十六进制数不会有前导...
  • 十进制转十六进制 解题思路 十六进制转十进制 解题思路 十六进制转八进制 解题思路 数列排序 解题思路 这几道题涉及到java进制转换的函数,一定要记住鸭~   十进制转十六进制 解题思路 import java....
  •  接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。 【注意】  输入的十六进制数不会有前导...
  • 文章目录前言1、二进制1.1、二进制转八进制1.2、二进制转十进制1.2、二进制转十六进制2、八进制1.1、八进制转二进制1.2、八进制转十进制1.2、八进制转十六进制3、十进制3.1、十进制转二进制3.2、十进制转八进制3.3、...
  •  接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式  输出n行,每行为输入对应的八进制正整数。 【注意】  输入的十六进制数不会有前导...
  • C语言实现 八位以内的十六进制转化为10进制
  • 蓝桥杯——十六进制转八进制,Java,基础练习
  • 接下来n行,每行一个由09、大写字母AF组成的字符串,表示要转换的十六进制正整数,每个十六进制数长度不超过100000。 输出格式 输出n行,每行为输入对应的八进制正整数。 【注意】 输入的十六进制数不会有前导0,...
  •  接下来n行,每行一个由0~9、大写字母A~F组成的字符串,表示要转换的十六进制正整数, 每个十六进制数长度不超过100000。输出格式  输出n行,每行为输入对应的八进制正整数。  【注意】  输入的十六进制数不会有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,836
精华内容 22,334
关键字:

十六进制不能超过