从十进制到三进制的 C 基础转换

Question

我正在将一个整数值转换为一个三进制数（它是一个字符串）。我怀疑应该有更好的方法来减少计算量。

我的算法直接实现了长除法，将数字在十进制和任意基数之间转换。

char *get_ternary_str(int value) {
  char buffer[3] = { "000" };
  int dividend = value;

  int i = 0;
  do {
    int remainder = dividend % 3;
    dividend = dividend / 3;
    buffer[i] = ((char)remainder + '0');
    i++;
  } while(dividend >= 1 && i < 3);

  char temp = buffer[2];
  buffer[2] = buffer[0];
  buffer[0] = temp;

  return buffer;
}

即使在这个例子中三进制数是 3 位数长，我的目标是让它长 n 位数。也欢迎提出如何对 n 位三进制数执行此操作的建议。

Answer 1

• 您应该使用 malloc 动态分配缓冲区。
• 您可以使用 memset 将 char 数组初始化为零。
• 最后，您可以用数学方法计算 char 数组的长度。以 Log [value] base 3 为基础的上限将为您提供字符串的字符大小。请记住添加一个额外的字符来使用 null。

由于您要求建议，我不提供代码。但是，如果您需要进一步的帮助，您可以在评论中指出。

Answer 2

代码有问题。

返回指向局部变量的指针

返回指向本地（非静态）变量的指针是未定义的行为 (UB)。不要依赖该内存在函数完成后有效。

char *get_ternary_str(int value) {
  char buffer[3] = ...
  ...
  return buffer;  // UB
}

以负数失败

-1 % 3 --> -1，所以remainder + '0'不会生成数字字符。

int remainder = dividend % 3;
...
buffer[i] = ((char)remainder + '0');

空间不足

buffer[3] 对于"000" 的字符串 来说太小了，因为null 字符 需要空格。 buffer[3] 足以容纳 3 位字符的数组，但肯定需要 字符串。

// char buffer[3] = { "000" };
char buffer[3+1] = { "000" };

从未分配空字符

当然，结果应该是一个 字符串，它需要一个 空字符 '\0'。需要修改代码以确保这一点。

---

我的目标是让它长 n 位数
也欢迎提出如何对 n 位三进制数执行此操作的建议。

需要一个char 缓冲区来处理形成的字符串。一个简单的解决方案是传入一个足够大的缓冲区指针以应对最坏的情况。我建议也传递缓冲区的大小。

以下是处理任何基数 2-36 的解决方案。

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// Maximum buffer size (worst case: INT_MIN and base 2)
#define ITOA_BASE_N (1 + sizeof(int)*CHAR_BIT + 1)

char *itoa_base(char *dest, size_t sz, int i, unsigned base) {
  char buf[ITOA_BASE_N];
  char *s = &buf[sizeof buf - 1];  // set to last character.
  *s = '\0';
  unsigned u = (unsigned) i;  // Use unsigned to cope with INT_MIN ...
  if (i < 0) {
    u = -u;                   // ... as -INT_MIN is UB
  }
  do {
    *(--s) = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[u % base];
    u /= base;
  } while (u);
  if (i < 0) {
    *(--s) = '-';
  }
  size_t size_used = &buf[sizeof buf] - s;
  if (size_used > sz) {
    return NULL;  // or some other error handling.
  }
  return memcpy(dest, s, size_used);
}

测试使用复合文字进行临时存储，但如果需要，可以传入固定缓冲区。

#define TO_BASE3(x) itoa_base((char [ITOA_BASE_N]){0}, ITOA_BASE_N, (x), 3)

void test3(int x) {
  char *s = TO_BASE3(x);
  // do stuff with `s`, it is valid for until the end of this block
  printf("base10:%11d base3:'%s'\n", x, s);
}

int main(void) {
  test3(0);
  test3(1);
  test3(42);
  test3(-81);
  test3(INT_MAX);
  test3(INT_MIN);
}

输出

base10:          0 base3:'0'
base10:          1 base3:'1'
base10:         42 base3:'1120'
base10:        -81 base3:'-10000'
base10: 2147483647 base3:'12112122212110202101'
base10:-2147483648 base3:'-12112122212110202102'

Answer 3

如果您担心，您可以使用一些内存空间来换取计算时间，使用一个简单而小的查找表。

考虑这个 C++（你的问题的早期版本也要求用该语言提供想法）sn-p 作为我提议的算法的一个例子。

#include <iostream>
#include <array>
#include <vector>
#include <string>
#include <iomanip>
#include <algorithm>
#include <limits>

std::string ternary_from(int value)
{ 
    // The idea is to elaborate three figures (in base 3) at a time
    constexpr int dim = 3 * 3 * 3;

    // Note the values, are "reversed"
    static const std::array<std::string, dim> inner_parts {
        "000", "100", "200", "010", "110", "210", "020", "120", "220", 
        "001", "101", "201", "011", "111", "211", "021", "121", "221", 
        "002", "102", "202", "012", "112", "212", "022", "122", "222" 
    };

    static const std::array<std::string, dim> parts {
        "", "1", "2", "01", "11", "21", "02", "12", "22", 
        "001", "101", "201", "011", "111", "211", "021", "121", "221", 
        "002", "102", "202", "012", "112", "212", "022", "122", "222" 
    };

    if ( value == 0 )
        return std::string{"0"};

    std::string result;

    // Thanks @Chux for recalling that -INT_MIN is UB
    unsigned tmp = value;
    if ( value < 0 )
        tmp = -tmp;

    // note that 'dim' = 27, so you are performing a third of the calculations
    while (tmp >= dim)
    {
        unsigned remainder = tmp % dim;
        // concatenating a string at the end is easier...
        result += inner_parts[remainder];
        tmp = tmp / dim;
    }
    result += parts[tmp];

    if (value < 0)
        result += '-';

    // now the string needs to be reversed. e.g. 3 -> 10(3), not 01 
    std::reverse(result.begin(), result.end());
    return result;
}

int main()
{
    std::vector<int> tests {
        42, -8, 0, 81, 27, -28, std::numeric_limits<int>::max(), std::numeric_limits<int>::min()
    };

    std::cout << "   decimal           ternary\n";
    for (int i : tests)
    {
        std::cout << std::setw(12) << i << std::setw(23) << ternary_from(i) << '\n';
    }
}

输出

 十进制 三进制
          42 1120
          -8 -22
           0 0
          81 10000
          27 1000
         -28 -1001
  2147483647 12112122212110202101
 -2147483648 -12112122212110202102

Answer 4

我在main 函数中分配动态内存并将指针传递给该函数。这样我可以管理内存。对于每个分配，您都需要重新分配。我为字符串终止分配了超过字符串长度的 1 个元素。你的算法几乎没有变化。我更改了缓冲区的索引以避免重新排序缓冲区元素。

#include<stdio.h>
#include<stdlib.h>

void get_ternary_str(char* buffer, int value, unsigned int n) {
  int dividend = value;

  int i = 0;
  do {
    int remainder = dividend % 3;
    dividend = dividend / 3;
    buffer[n - 1 - i] = ((char)remainder + '0');
    i++;
  } while(i < n);

  buffer[i] = 0;
}

int main() {
    int n = 5;
    char* buffer = (char*) malloc(n * sizeof(char));

    int value = 31;
    get_ternary_str(buffer, value, n - 1);

    printf("%s", buffer);
    free(buffer);
    return 0;
}

根据 Y.Doktur 的想法，这里是具有动态长度的相同代码。我使用指针来传递和接收指针。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

char* get_ternary_str(unsigned int value) {
  int n = value > 2 ? 1 + floor(log(value) / log(3)) : 1;
  char* buffer = (char*) malloc((n+1) * sizeof(char));
  int dividend = value;

  int i = 0;
  do {
    int remainder = dividend % 3;
    dividend = dividend / 3;
    buffer[n - 1 - i] = ((char)remainder + '0');
    i++;
  } while(i < n);

  buffer[i] = 0;
  return buffer;
}

int main() {

  int value = 31;
  char* buffer = get_ternary_str(value);

  printf("%s", buffer);
  free(buffer);
  return 0;
}