3

我需要将任意长度的二进制转换为精确的三进制表示。理想情况下，给定一个位数组char buffer[n]，该算法将能够产生一个三元组（位模拟），反之亦然。有这样的算法吗？

我知道将个人转换int为三元的方法：

int nth_trit(int num, int n)
{
    for(int i = 0; i < n; i++)
        num /= 3;

    return num % 3;
}

唉，即使是比特流也是long long long int不够的。我认为使用一个大整数库就足够了，虽然我不确定，并且觉得应该有更好的方法来计算三元表示。

一个视觉示例：

// Conversion is simple(short stream)
Binary  - 0 1 0 0 1 0 0 1
Decimal -             7 3
Ternary -         2 2 0 1

// Conversion is hard(long stream)
Binary  - 1 0 1 0 0 0 0 1 ..........
Ternary - ? ? ?

短流很简单，因为它很好地适合 a int，所以nth_trit可以使用该函数，但长流不能，所以除了使用大整数库之外，我没有想到简单的解决方案。

4

4 回答 4

2

可以证明每个三进制数字都依赖于所有二进制数字。所以你不能比读取整个位串然后进行转换更好。

于 2012-08-18T09:34:22.117 回答
1

如果位缓冲区很长，您的算法就不太好，因为每个输出 trit 都会重复较小的值所需的所有除法n。因此，将此算法转换为“bignum”算法将不是您想要的。

另一种方法：从左到右扫描位，每个新的都会更新之前的值：

val = val * 2 + bit

带有三元组的三n进制数t[i]具有值

sum(i = 0 .. n-1) t[i] * 3^i

因此val，新扫描位的更新的三元表示变为，

[ 2 * sum(i = 0 .. n-1) t[i] * 3^i ] + bit
    = bit + sum(i = 0 .. n-1) 2 * t[i] * 3^i 
    = 2 * t[0] + b + sum(i = 1 .. n) 2 * t[i] * 3^i

为了使代码简单，让我们计算一个无符号字符数组中的三元组。完成后，您可以以任何您喜欢的方式重新包装它们。 

#include <stdio.h>

// Compute the trit representation of the bits in the given
// byte buffer.  The highest order byte is bytes[0].  The
// lowest order trit in the output is trits[0].  This is 
// not a very efficient algorithm, but it doesn't use any
// division.  If the output buffer is too small, high order
// trits are lost.
void to_trits(unsigned char *bytes, int n_bytes, 
              unsigned char *trits, int n_trits)
{
  int i_trit, i_byte, mask;

  for (i_trit = 0; i_trit < n_trits; i_trit++)
    trits[i_trit] = 0;

  // Scan bits left to right.
  for (i_byte = 0; i_byte < n_bytes; i_byte++) {

    unsigned char byte = bytes[i_byte];

    for (mask = 0x80; mask; mask >>= 1) {
      // Compute the next bit.
      int bit = (byte & mask) != 0;

      // Update the trit representation
      trits[0] = trits[0] * 2 + bit;
      for (i_trit = 1; i_trit < n_trits; i_trit++) {
        trits[i_trit] *= 2;
        if (trits[i_trit - 1] > 2) {
          trits[i_trit - 1] -= 3;
          trits[i_trit]++;
        }
      }
    }
  }
}

// This test uses 64-bit quantities, but the trit 
// converter will work for buffers of any size.
int main(void)
{
  int i;

  // Make a byte buffer for an easy to recognize value.
  #define N_BYTES 7
  unsigned char bytes [N_BYTES] = 
    { 0xab, 0xcd, 0xef, 0xff, 0xfe, 0xdc, 0xba };

  // Make a trit buffer.  A 64 bit quantity may need up to 42 trits.
  #define N_TRITS 42
  unsigned char trits [N_TRITS];

  to_trits(bytes, N_BYTES, trits, N_TRITS);

  unsigned long long val = 0;
  for (i = N_TRITS - 1; i >= 0; i--) {
    printf("%d", trits[i]);
    val = val * 3 + trits[i];
  }
  // Should prinet value in original byte buffer.
  printf("\n%llx\n", val);

  return 0;
}
于 2012-08-18T05:36:09.193 回答
1

在任何基数中乘/除以 2 都很简单，因此将任何基数转换为/从二进制转换的最简单方法是重复乘/除以 2，跟踪进位/奇偶校验。

#include <algorithm>
#include <cstdint>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>

// in: a vector representing a bitstring, with most-significant bit first.
// out: a vector representing a tritstring, with least-significant trit first.
static std::vector<uint8_t> b2t(const std::vector<bool>& in) {
  std::vector<uint8_t> out;
  out.reserve(in.size());  // larger than necessary; will trim later
  // for each digit (starting from the most significant bit)
  for (bool carry : in) {
    // add it to the tritstring (starting from the least significant trit)
    for (uint8_t& trit : out) {
      // double the tritstring, carrying overflow to higher places
      uint8_t new_trit = 2 * trit + carry;
      carry = new_trit / 3;
      trit = new_trit % 3;
    }
    if (carry) {
      // overflow past the end of the tritstring; add a most-significant trit
      out.push_back(1);
    }
  }
  out.reserve(out.size());
  return out;
}

// in: a vector representing a tritstring, with most-significant trit first.
// out: a vector representing a bitstring, with least-significant bit first.
static std::vector<bool> t2b(std::vector<uint8_t> in) {
  std::vector<bool> out;
  out.reserve(2 * in.size());  // larger than necessary; will trim later
  bool nonzero;
  do {
    nonzero = false;
    bool parity = false;
    for (uint8_t& trit : in) {
      // halve the tritstring, starting from the most significant trit
      uint8_t new_trit = trit + 3 * parity;
      parity = new_trit & 1;
      nonzero |= trit = new_trit / 2;
    }
    // the division ended even/odd; add a most-signiticant bit
    out.push_back(parity);
  } while (nonzero);
  out.reserve(out.size());
  return out;
}

int main() {
  bool odd = false;
  std::string s;
  while (std::cin >> s) {
    if ((odd = !odd)) {
      std::vector<bool> in(s.size());
      std::transform(s.begin(), s.end(), in.begin(),
          [](char c) {return c - '0';});
      std::vector<uint8_t> out(b2t(in));
      std::copy(out.rbegin(), out.rend(),
          std::ostream_iterator<int>(std::cout));
      std::cout << std::endl;
    } else {
      std::vector<uint8_t> in(s.size());
      std::transform(s.begin(), s.end(), in.begin(),
          [](char c) {return c - '0';});
      std::vector<bool> out(t2b(in));
      std::copy(out.rbegin(), out.rend(),
          std::ostream_iterator<int>(std::cout));
      std::cout << std::endl;
    }
  }
  return 0;
}

$ ./a.out 
1011
102
102
1011
10001100001101010011010010111000011011101000111101011101000110100101101101111110110011010010111100010110100010101011010100101100001101001000000111011110101001000100011010111011000111101110111001111110110011101011101101001001110010111111100011000110011000111110110111011110110110001111011011011000100101010010111010000110101011010100011010110110000010110111000111000110101000000110000001111110101110010000011000110001010000001001100011000000100100100001100101111000101001001010101101101000011100110001111011110001
12010110110220200020211012001000211110222212120220002002120120111221021120100122221020011120010202110111112112110201211201120222000011010100122122121211112101111121002110102112000111200002121211002022100220211220220111010210200222021221020122012102101010100001122200011110210221120122022011202201002002001221211001221112001
12010110110220200020211012001000211110222212120220002002120120111221021120100122221020011120010202110111112112110201211201120222000011010100122122121211112101111121002110102112000111200002121211002022100220211220220111010210200222021221020122012102101010100001122200011110210221120122022011202201002002001221211001221112001
10001100001101010011010010111000011011101000111101011101000110100101101101111110110011010010111100010110100010101011010100101100001101001000000111011110101001000100011010111011000111101110111001111110110011101011101101001001110010111111100011000110011000111110110111011110110110001111011011011000100101010010111010000110101011010100011010110110000010110111000111000110101000000110000001111110101110010000011000110001010000001001100011000000100100100001100101111000101001001010101101101000011100110001111011110001
^D

（1011 2 = 8 + 2 + 1 = 11 = 9 + 2 = 102 3）
（10001100001101010011010010111000011011101000111101011101000110100101101101111110110011010010111100010110100010101011010100101100001101001000000111011110101001000100011010111011000111101110111001111110110011101011101101001001110010111111100011000110011000111110110111011110110110001111011011011000100101010010111010000110101011010100011010110110000010110111000111000110101000000110000001111110101110010000011000110001010000001001100011000000100100100001100101111000101001001010101101101000011100110001111011110001 2= 7343280200542654154029818354420920722408633707396360612751407162736942742985658428558632312175242897575484682660836397639769592568209070221085927986634481 = 12010110110220200020211012001000211110222212120220002002120120111221021120100122221020011120010202110111112112110201211201120222000011010100122122121211112101111121002110102112000111200002121211002022100220211220220111010210200222021221020122012102101010100001122200011110210221120122022011202201002002001221211001221112001 9）

于 2012-08-18T08:55:49.810 回答
-1

平衡的三元/三元更好。{-1, 0, 1} 以这种方式输出。

于 2013-02-03T20:34:04.927 回答