2025-12-13：十六进制和三十六进制转化。用go语言，给定一个整数 n，先求它的平方并把该值用大写字母的 16 进制表示（符号位按需处理，数位使用 0–9 与 A–F），再求它的立方并将该值用大

2025-12-13：十六进制和三十六进制转化。用go语言，给定一个整数 n，先求它的平方并把该值用大写字母的 16 进制表示（符号位按需处理，数位使用 0–9 与 A–F），再求它的立方并将该值用大写字母的 36 进制表示（数位使用 0–9 与 A–Z）。

最后将这两个进制字符串按顺序拼接，作为函数的返回结果。

1 <= n <= 1000。

输入：n = 13。

输出： “A91P1”。

解释：

n * n = 13 * 13 = 169。在十六进制中，它转换为 (10 * 16) + 9 = 169，对应于 “A9”。

n * n * n = 13 * 13 * 13 = 2197。在三十六进制中，它转换为 (1 * 362) + (25 * 36) + 1 = 2197，对应于 “1P1”。

连接两个结果得到 “A9” + “1P1” = “A91P1”。

题目来自力扣3602。

分步过程描述

1. 给定整数 n = 13
   计算它的平方：
   ( n^2 = 13 \times 13 = 169 )

2. 平方值转换为十六进制

   • 调用toRadix(169, 16)
   • 169 除以 16 的商和余数依次是：
     • 169 ÷ 16 = 10 余 9
     • 10 ÷ 16 = 0 余 10
   • 余数映射到十六进制字符：9 → ‘9’，10 → ‘A’
   • 余数收集的顺序是从低位到高位（9, 10），即 “9A”，但最后要反转，所以得到 “A9”。

3. 计算立方
   ( n^3 = 13 \times 13 \times 13 = 2197 )

4. 立方值转换为三十六进制

   • 调用toRadix(2197, 36)
   • 2197 除以 36 的步骤：
     • 2197 ÷ 36 = 61 余 1
       • 余数 1 → ‘1’
     • 61 ÷ 36 = 1 余 25
       • 余数 25 → ‘Z’？不对，要检查字母映射：
         余数 0–9 → ‘0’–‘9’，余数 10 → ‘A’，余数 11 → ‘B’，…，余数 25 → 10+15 = 第 16 个字母？ 10→A(0), 11→B(1), …, 25 是 10+15，所以余数 25 是 10(A)+15 = 第 16 个字母是 P。
         验证：余数 10 → ‘A’，11 → ‘B’，12 → ‘C’，…，25 → ‘A’ + 15 = ‘P’ ✅
     • 1 ÷ 36 = 0 余 1
       • 余数 1 → ‘1’
   • 从低位到高位余数为 1, 25, 1，反转后是 1, 25, 1 → 字符 ‘1’, ‘P’, ‘1’ → 字符串 “1P1”。

5. 拼接结果

   • 十六进制部分 “A9” + 三十六进制部分 “1P1” → “A91P1”

复杂度分析

假设 ( n ) 给定，平方和立方计算是 ( O(1) )。

• 进制转换时，循环次数取决于数字在相应进制下的位数，最坏情况出现在 ( n = 1000 )：
  • 平方最大是 ( 10^6 )，十六进制下约 5 位。
  • 立方最大是 ( 10^9 )，三十六进制下约 6 位。
  • 每次循环是常数时间操作。

时间复杂度：
每次转换的位数是 ( O(\log M) )，这里 M 是 ( n^2 ) 或 ( n^3 )。由于输入 n ≤ 1000，位数不超过常数范围，所以可视为 ( O(1) )。但通常按大 O 表示法，是 ( O(\log n) )。

空间复杂度：
主要是strings.Builder存储的字符串长度，以及反转时用的[]rune临时空间。额外空间与结果字符串长度成线性，结果字符串长度是 ( O(\log n) )。

结论：

• 总时间复杂度：( O(\log n) )（但 n ≤ 1000 时可看作 ( O(1) )）
• 总额外空间复杂度：( O(\log n) )（存储转换结果所需空间）

Go完整代码如下：

packagemainimport("fmt""strings")funcconcatHex36(nint)string{h:=n*n ans:=toRadix(h,16)h=n*n*n ans+=toRadix(h,36)returnans}functoRadix(num,radixint)string{ifnum==0{return"0"}varbuilder strings.Builderfornum>0{rem:=num%radixvarchbyteifrem<10{ch=byte('0'+rem)}else{ch=byte('A'+rem-10)}builder.WriteByte(ch)num/=radix}// 反转字符串runes:=[]rune(builder.String())fori,j:=0,len(runes)-1;i<j;i,j=i+1,j-1{runes[i],runes[j]=runes[j],runes[i]}returnstring(runes)}funcmain(){n:=13result:=concatHex36(n)fmt.Println(result)}

Python完整代码如下：

# -*-coding:utf-8-*-defto_radix(num:int,radix:int)->str:"""将十进制整数转换为指定进制的字符串表示"""ifnum==0:return"0"digits=[]whilenum>0:rem=num%radixifrem<10:digits.append(chr(ord('0')+rem))else:digits.append(chr(ord('A')+rem-10))num//=radixreturn''.join(reversed(digits))defconcat_hex36(n:int)->str:"""返回 n^2 的十六进制字符串与 n^3 的三十六进制字符串的拼接"""h=n*n ans=to_radix(h,16)h=n*n*n ans+=to_radix(h,36)returnansdefmain():n=13result=concat_hex36(n)print(result)if__name__=="__main__":main()

C++完整代码如下：

#include<iostream>#include<string>std::stringto_radix_no_reverse(intnum,intradix){if(num==0)return"0";// 计算最大可能位数inttemp=num;intdigits=0;while(temp>0){temp/=radix;digits++;}// 从最高位开始构建std::stringresult(digits,'\0');for(inti=digits-1;i>=0;--i){intrem=num%radix;result[i]=(rem<10)?('0'+rem):('A'+rem-10);num/=radix;}returnresult;}intmain(){intn=13;std::string hex_part=to_radix_no_reverse(n*n,16);std::string base36_part=to_radix_no_reverse(n*n*n,36);std::cout<<hex_part+base36_part<<std::endl;return0;}