在十六进制转为八进制的过程中包含了将十六进制转化为二进制以及将二进制转化为八进制！

我自己测试是没什么问题，但是在蓝桥杯官网的测试系统就显示运行错误qwq

不知道为什么

附代码：
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
	string code1(char p);
	string code2(char a,char b,char c);
	int i,n,j,flag;
	cin>>n;
	string sixteen[n],two[n],eight[n];
	char twoo[n][1000],eightt[n][1000];
	int len1[n],len2[n];
	for(i=0;i<n;i++)
		cin>>sixteen[i];
	for(i=0;i<n;i++)
	{
		len1[i] = sixteen[i].length();
		for(j=0;j<len1[i];j++)
			two[i] = two[i] + code1(sixteen[i][j]);
		len2[i] = two[i].length();
		for(j=0;j<=len2[i];j++)
			twoo[i][j] = two[i][j];
		if(len2[i]%3==1)
		{
			for(j = len2[i]+1;j>=0;j--)
				twoo[i][j] = twoo[i][j-2];
			twoo[i][1] = twoo[i][0] = '0';
		}
		if(len2[i]%3==2)
		{
			for(j = len2[i];j>=0;j--)
				twoo[i][j] = twoo[i][j-1];
			twoo[i][0] = '0';
		}
		for(j=0;j<len2[i];j=j+3)
			eight[i] = eight[i] + code2(twoo[i][j],twoo[i][j+1],twoo[i][j+2]);	
		for(j=0;j<len2[i];j++)
			eightt[i][j] = eight[i][j];

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


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


string code1(char p)
{
	if(p == '0')   return("0000");
	if(p == '1')   return("0001");
	if(p == '2')   return("0010");
	if(p == '3')   return("0011");
	if(p =='4')    return("0100");
	if(p == '5')   return("0101");
	if(p == '6')   return("0110");
	if(p == '7')   return("0111");
	if(p == '8')   return("1000");
	if(p == '9')   return("1001");
	if(p == 'A')   return("1010");
	if(p == 'B')   return("1011");
	if(p == 'C')   return("1100");
	if(p == 'D')   return("1101");
	if(p == 'E')   return("1110");
	if(p == 'F')   return("1111");
}


还有十六进制转化为十进制的，这个就比较简单了

#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
	long long sum=0;
	char pp[100];
	scanf("%s",&pp);
	int len;	
	len = strlen(pp);
	for(int i=0;i<len;i++)
	{
		if(pp[i]>='0'&&pp[i]<='9')
		sum = sum + (pp[i]-48)*pow(16,len-i-1);
		if(pp[i] == 'A')
		sum = sum + 10*pow(16,len-i-1);
		if(pp[i] == 'B')
		sum = sum + 11*pow(16,len-i-1);
		if(pp[i] == 'C')
		sum = sum + 12*pow(16,len-i-1);
		if(pp[i] == 'D')
		sum = sum + 13*pow(16,len-i-1);
		if(pp[i] == 'E')
		sum = sum + 14*pow(16,len-i-1);
		if(pp[i] == 'F')
		sum = sum + 15*pow(16,len-i-1);
	 } 
	printf("%I64d",sum);
	return 0;
 } 

最近一直在划水，我的300元报名费要打水漂了呜呜呜

蓝桥杯 基础练习 十六进制转八进制
题目已经说明了每个十六进制数长度不超过100000。

长度足够的时候，数字已经非常大了。所以不能用int或者long long把十六进制先转成十进制在转为八进制过程中的数字存储起来。

利用的思路是：先将每1位十六进制数转换成4位二进制，补够位数后，再把每1位二进制转换为1位八进制，然后再按序输出（前置的0忽略）。
比如题目给的例子：



代码：
# include <iostream>
# include <string>
using namespace std;

/*每一位十六进制数字都可以转换为四位二进制数字*/
string change(char n){
    string num;
    switch(n){
        case '0':num="0000";break;
        case '1':num="0001";break;
        case '2':num="0010";break;
        case '3':num="0011";break;
        case '4':num="0100";break;
        case '5':num="0101";break;
        case '6':num="0110";break;
        case '7':num="0111";break;
        case '8':num="1000";break;
        case '9':num="1001";break;
        case 'A':num="1010";break;
        case 'B':num="1011";break;
        case 'C':num="1100";break;
        case 'D':num="1101";break;
        case 'E':num="1110";break;
        case 'F':num="1111";break;
        default:break;
    }
    return num;
}

/*补齐位数，确保二进制数字的长度是3的倍数，才能转换为八进制*/
string supply(string str){
    int len = str.size();
    if(len%3==0)
        return str;
    else if(len%3==1)
        return "00"+str;
    else
        return "0"+str;
}

/*每三位二进制数字都可以转换为一位八进制数字*/
char convert(char a,char b,char c){
    int a_ = a-48;
    int b_ = b-48;
    int c_ = c-48;
    int out = a_*4+b_*2+c_;
    return out+48;
}

int main()
{
    int n,i,j;
    string num;
    cin>>n;
    /*循环次数*/
    while(n--){
        cin>>num;/*输入十六进制数字字符串*/
        string to16_2="",to2_8="";
        int len1 = num.size();
        for(i=0;i<len1;i++){
            to16_2 += change(num[i]);/*把每一位十六进制数字转换为二进制再串起来*/
        }
        to16_2 = supply(to16_2);/*补够位数*/
        int len2 = to16_2.size();
        for(i=0;i<=(len2-3);i=i+3){
            to2_8 += convert(to16_2[i],to16_2[i+1],to16_2[i+2]);/*变成八进制*/
        }
        int flag=0,len3 = to2_8.size();
        for(i=0;i<len3;i++){/*输出*/
            if(to2_8[i]!='0'){
                flag=1;
            }
            if(flag==1){
                cout<<to2_8[i];
            }
        }
        cout<<endl;
    }
    return 0;
}

我的蓝桥杯代码仓：https://github.com/617076674/lanqiao

题目描述：



知识点：进制转换

思路：先将十六进制转换成二进制，再将二进制转换成八进制

为防止超时，用一个数组来保存十六进制和二进制间的对应关系，用一个哈希表来保存二进制和八进制间的对应关系。

由于在二进制转八进制的过程中，为方便处理，我将字符串翻转了，所以哈希表中存储的是逆序的二进制序列和其对应的八进制值。由于翻转后会存在字符串末端不足3位的情况，因此哈希表中的键需要包含2个字符及1个字符的二进制序列。

JAVA代码：

import java.util.HashMap;
import java.util.Scanner;

public class Main {
	private static String[] hexToBinary = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
			"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};
	private static HashMap<String, String> binaryToOct;	//存储逆序的2进制序列和对应的8进制值
	static {
		binaryToOct = new HashMap<String, String>();
		binaryToOct.put("000", "0");
		binaryToOct.put("100", "1");
		binaryToOct.put("010", "2");
		binaryToOct.put("110", "3");
		binaryToOct.put("001", "4");
		binaryToOct.put("101", "5");
		binaryToOct.put("011", "6");
		binaryToOct.put("111", "7");
		binaryToOct.put("00", "0");
		binaryToOct.put("10", "1");
		binaryToOct.put("01", "2");
		binaryToOct.put("11", "3");
		binaryToOct.put("0", "0");
		binaryToOct.put("1", "1");
	}
	public static void main(String[] args) throws Exception {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		scanner.nextLine();
		for(int i = 0; i < n; i++) {
			System.out.println(toOct(toBinary(scanner.nextLine())));
		}
	}
	
	private static String toBinary(String s) {
		StringBuilder result = new StringBuilder();
		for(int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if(c >= 'A' && c <= 'F') {
				result.append(hexToBinary[c - 'A' + 10]);
			}else {
				result.append(hexToBinary[c - '0']);
			}
		}
		while(result.charAt(0) == '0') {	//删除前导0
			result.deleteCharAt(0);
		}
		return result.toString();
	}
	
	private static String toOct(String s) {
		StringBuilder result = new StringBuilder();
		StringBuilder input = new StringBuilder(s);
		input.reverse();
		for(int i = 0; i < input.length(); i += 3) {
			result.append(binaryToOct.get(input.substring(i, Math.min(i + 3, input.length()))));
		}
		return result.reverse().toString();
	}
}


JAVA解题报告：



 

十六进制转十进制
m=input()
print(int(m,16))

十六进制转八进制
n=int(input())
ls=[]
for i in range(n):
    m=input()
    ls.append(m)
for s in ls:
    print('{:o}'.format(int(s,16)))

在输入过程中，本来是打算直接输入三个数字，用三个input（）实现，但是在提交时显示错误。在参考了网友的答案后，知道需要使用for…in…循环。感谢大神。https://blog.csdn.net/qq_45894553/article/details/104504592

https://www.cnblogs.com/lovejh/p/9201219.html

补充：自己几天后又做了一遍，使用列表ls是为了使得代码可以实现题目的输出要求

用int(s,16)将十六进制转换为十进制，如上题。然后用format中的{😮}将十进制转换为八进制。

以下为format中的转换

‘b’ - 二进制。

‘c’ - 字符。

‘d’ - 十进制整数。

‘o’ - 八进制。

‘x’ - 十六进制。（小写字母）

‘e’ - 幂符号。用科学计数法打印数字

‘g’ - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。

‘n’ - 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。

‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。