进制转换

复制import math

def convert_base(num_str: str, from_base: int, to_base: int) -> str:
    """任意进制转换，支持负数和小数"""
    if from_base < 2 or to_base < 2:
        raise ValueError("进制必须 >= 2")
    
    negative = num_str.startswith('-')
    if negative:
        num_str = num_str[1:]
    
    # 分离整数和小数部分
    parts = num_str.split('.')
    int_part = parts[0]
    frac_part = parts[1] if len(parts) > 1 else ''
    
    # 转十进制整数
    decimal_int = int(int_part, from_base) if int_part else 0
    
    # 转十进制小数
    decimal_frac = 0.0
    if frac_part:
        for i, digit in enumerate(frac_part):
            decimal_frac += int(digit, from_base) * (from_base ** -(i + 1))
    
    # 十进制整数转目标进制
    if decimal_int == 0:
        result_int = '0'
    else:
        digits = []
        n = abs(decimal_int)
        while n > 0:
            digits.append('0123456789ABCDEF'[n % to_base])
            n //= to_base
        result_int = ''.join(reversed(digits))
    
    # 十进制小数转目标进制（精度 10 位）
    result_frac = ''
    if decimal_frac > 0:
        f = decimal_frac
        for _ in range(10):
            f *= to_base
            digit = int(f)
            result_frac += '0123456789ABCDEF'[digit]
            f -= digit
            if f == 0:
                break
    
    result = ('-' if negative else '') + result_int
    if result_frac:
        result += '.' + result_frac
    return result

# 示例：十进制 255.5 → 十六进制
print(convert_base('255.5', 10, 16))  # FF.8

# 示例：二进制 -1010.11 → 八进制
print(convert_base('-1010.11', 2, 8))  # -12.6

复制package main

import (
	"fmt"
	"math/big"
	"strings"
)

// ConvertBase 任意进制转换，支持负数和小数
func ConvertBase(numStr string, fromBase, toBase int) (string, error) {
	if fromBase < 2 || toBase < 2 {
		return "", fmt.Errorf("进制必须 >= 2")
	}

	negative := strings.HasPrefix(numStr, "-")
	if negative {
		numStr = numStr[1:]
	}

	// 分离整数和小数
	parts := strings.Split(numStr, ".")
	intPart := parts[0]
	fracPart := ""
	if len(parts) > 1 {
		fracPart = parts[1]
	}

	// 解析整数部分
	intVal := new(big.Int)
	intVal.SetString(intPart, fromBase)

	// 解析小数部分
	fracVal := new(big.Rat)
	if fracPart != "" {
		fracNum := new(big.Int)
		fracNum.SetString(fracPart, fromBase)
		fracDen := new(big.Int).Exp(big.NewInt(int64(fromBase)), big.NewInt(int64(len(fracPart))), nil)
		fracVal.SetFrac(fracNum, fracDen)
	}

	// 整数转目标进制
	resultInt := intVal.Text(toBase)

	// 小数转目标进制（精度 10 位）
	resultFrac := ""
	if fracVal.Num().BitLen() > 0 {
		f := new(big.Rat).Set(fracVal)
		for i := 0; i < 10; i++ {
			f.Mul(f, big.NewRat(int64(toBase), 1))
			num, _ := f.Float64()
			digit := int(num)
			resultFrac += fmt.Sprintf("%X", digit)
			f.Sub(f, big.NewRat(int64(digit), 1))
			if f.Num().BitLen() == 0 {
				break
			}
		}
	}

	result := ""
	if negative {
		result = "-"
	}
	result += resultInt
	if resultFrac != "" {
		result += "." + resultFrac
	}
	return result, nil
}

func main() {
	// 示例：十进制 255.5 → 十六进制
	result, _ := ConvertBase("255.5", 10, 16)
	fmt.Println(result) // FF.8

	// 示例：二进制 -1010.11 → 八进制
	result, _ = ConvertBase("-1010.11", 2, 8)
	fmt.Println(result) // -12.6
}

复制/**
 * 任意进制转换，支持负数和小数
 * @param {string} numStr - 输入数字字符串
 * @param {number} fromBase - 原进制 (2-36)
 * @param {number} toBase - 目标进制 (2-36)
 * @returns {string} 转换结果
 */
function convertBase(numStr, fromBase, toBase) {
  if (fromBase < 2 || toBase < 2) {
    throw new Error('进制必须 >= 2');
  }

  const negative = numStr.startsWith('-');
  if (negative) numStr = numStr.slice(1);

  // 分离整数和小数
  const [intPart, fracPart = ''] = numStr.split('.');

  // 整数部分转换
  const decimalInt = parseInt(intPart, fromBase);
  const resultInt = decimalInt.toString(toBase).toUpperCase();

  // 小数部分转换
  let resultFrac = '';
  if (fracPart) {
    // 将小数部分转为十进制
    let decimalFrac = 0;
    for (let i = 0; i < fracPart.length; i++) {
      decimalFrac += parseInt(fracPart[i], fromBase) * Math.pow(fromBase, -(i + 1));
    }

    // 十进制小数转目标进制（精度 10 位）
    let f = decimalFrac;
    for (let i = 0; i < 10; i++) {
      f *= toBase;
      const digit = Math.floor(f);
      resultFrac += digit.toString(toBase).toUpperCase();
      f -= digit;
      if (f === 0) break;
    }
  }

  let result = (negative ? '-' : '') + resultInt;
  if (resultFrac) result += '.' + resultFrac;
  return result;
}

// 示例：十进制 255.5 → 十六进制
console.log(convertBase('255.5', 10, 16)); // FF.8

// 示例：二进制 -1010.11 → 八进制
console.log(convertBase('-1010.11', 2, 8)); // -12.6