Convert decimal to balanced Heptavintimal

Question

I'm trying to make a function to convert decimal to balanced Heptavintimal (0123456789ABCDEFGHKMNPRTVXZ) where 0 represent -13, D : 0 and Z 13

I have tried this but some cases are not working properly:

static const std::string HEPT_CHARS = "0123456789ABCDEFGHKMNPRTVXZ";

std::string heptEnc(int value){
    std::string result = "";

    do {
        int pos = value % 27;
        result = std::string(HEPT_CHARS[(pos + 13)%27] + result);
        value = value / 27;
    } while (value != 0);

    return result;
}

Here is what I get in this example -14, -15, 14, 15 isn't working

call(x) - expect: result
heptEnc(-9841) - 000: 000
heptEnc(-15) - CX: 
heptEnc(-14) - CZ: 
heptEnc(-13) - 0: 0
heptEnc(-1) - C: C
heptEnc(0) - D: D
heptEnc(1) - E: E
heptEnc(13) - Z: Z
heptEnc(14) - E0: 0
heptEnc(15) - E1: 1
heptEnc(9841) - ZZZ: ZZZ

What are you supposed to get for those values? Have you tried to [debug your program](https://ericlippert.com/2014/03/05/how-to-debug-small-programs/)? — Some programmer dude, May 16 '19 at 13:30
the expected value is before `:` so yes I expect E0, but I only get 0, I edited the post to specify my synthax — Jeremy Talus, May 16 '19 at 13:36
The algorithm can't be right. `(-15) % 27 == -15`. and then you access `HEPT_CHARS` at a negative offset. — Igor Tandetnik, May 16 '19 at 13:40
`value = value / 27;` cannot be correct, if `value == 14`, you have to get 2 digits, but the loop will break after the first digit. — mch, May 16 '19 at 14:01

score 3 · Accepted Answer · edited May 16 '19 at 15:16

3

Just got it working, here is the code:

static const std::string HEPT_CHARS = "0123456789ABCDEFGHKMNPRTVXZ";

inline int modulo(int a, int b) 
{
    const int result = a % b;
    return result >= 0 ? result : result + b;
}

std::string heptEnc(int value)
{
    std::string result = "";

    do {
        int pos = value%27;
        result = std::string(HEPT_CHARS[modulo(pos + 13,27)] + result);
        value = (value+pos) / 27;
    } while (value != 0);

    return result;
}

Apparently a mix of mathematical modulo, C++ modulo and modifying the way you update your value did the trick.

edited May 16 '19 at 15:16

sirandy

1,834
5
27
32

answered May 16 '19 at 15:06

Elias

56
7

indeed mathimatical trick, and since I doind calculation and paper, so my calculator use Math modulo and not c++ modulo anyway thanks – Jeremy Talus May 16 '19 at 15:15

Paul Evans · Answer 2 · 2019-05-16T14:20:12.660

1

You're using mod (%) incorrectly. It's difficult/complicated to know what a signed int will initially be set to. So try this instead:

unsigned int uvalue = std::abs(value);
unsigned int upos = uvalue % 27;
int pos = static_cast<int>(upos) - 13;

Of course you'll have to deal with the sign of your conversion separately:

int sign = value >= 0 ? 1 : -1;

edited May 16 '19 at 14:20

answered May 16 '19 at 13:44

Paul Evans

27,315
3
37
54

in fact it's not a problem of sign. more a problem around `value = value / 27;` the problem is the balanced system, since 0 represet -13 and Z +13 so E0 ca be read as 27 + -13 so it's 14 – Jeremy Talus May 16 '19 at 14:50

Convert decimal to balanced Heptavintimal

2 Answers2