正负数&&负数负数对正数

Question

We are given an array consisting of 0's and 1's. They represent a number in base -2. Example: A = (1, 1, 0, 1, 0) in decimal = (-2)^0 *(1) + (-2)^1 *(1) + (-2)^2 *(0) + (-2)^3 *(1) + (-2)^4 *(0) = 1 + (-2) + 0 + (-8) + 0 = -9

Now, we need to convert -9 to 9 in base -2. Here's my code so far:

vector<int> negative_base(vector<int> &A) {
    //first convert number to decimal base
    int n = 0;
    long count = A.size();
    int power_of_two = 1;
    for(int i=0;i<count;i++){
        n+=power_of_two*A[i];
        power_of_two = power_of_two*-2;
    }
    cout<<"number: "<<n<<endl;
    vector<int> base_minus_two;
    n=-n;
    while(n!=0){
        int x;
        if(n<0) {

            x = n%2;
            if(x!=0) x+=2;
            n = (n/-2) +1;

        } else {
            x = n%2;
            n = n/-2;
        }
        base_minus_two.push_back(x);
    }
    return base_minus_two;
}

I am asked to return the shortest possible chain of 0's and 1's. However, my code does not always do that. For this example, it generates (1, 0, 1, 1, 1). I think it's fine for this example, yet in some cases it give me long chains while there are other shorter versions. In some cases, it's generating wrong results. For instance, if we have to convert 23 to -23, we get {1, 0, 0, 0, 0, 0, 1, 1} as a result. However, this number is not equal to -23, but to -63. So, there must be something wrong going on with my calculation. I am following the simplest base conversion algorithm, where you keep dividing until you hit zero, saving all the remainders in a vector as you go on. It's a negative base, so result * (-2) + remainder should give you what you had previously.

-23 = (-2) *  12  + 1
 12 = (-2) * (-6) + 0
- 6 = (-2) *   3  + 0
  3 = (-2) * (-1) + 1
 -1 = (-2) *   1  + 1
  1 = (-2) *   0  + 1

The result should be (1, 0, 0, 1, 1, 1), yet I am getting {1, 0, 0, 0, 0, 0, 1, 1} as I stated. What's wrong with my code?

Answer 1

I found what's wrong with the code. Here's the new version:

vector<int> negative_base(vector<int> &A) {
//first convert number to decimal base
int n = 0;
long count = A.size();
int power_of_two = 1;
for(int i=0;i<count;i++){
    n+=power_of_two*A[i];
    power_of_two = power_of_two*-2;
}
cout<<"number: "<<n<<endl;
vector<int> base_minus_two;
n=-n;
while(n!=0){
    int x;
    if(n<0){
        x = n%2;
        if(x!=0){ x+=2;
        n = (n/-2) +1;
        }else{
            n = (n/-2);
        }

    }else{
        x= n%2;
        n = n/-2;

    }
    cout<<"n: "<< n <<" x: "<<x<<endl;
    base_minus_two.push_back(x);

}
return base_minus_two;
}

Answer 2

Your logic to test if remainder is negative is wrong (and you can split into sub functions).

struct div_with_positive_remainder_t
{
    int quot;
    int rem;
};

div_with_positive_remainder_t div_with_positive_remainder(int x, int y)
{
    if (y == 0)
        throw std::runtime_error("division by zero");
    int r = x % y;
    if (r < 0) {
        r += std::abs(y);
    }
    int q = (x - r) / y;
    return {q, r};
}

std::vector<int> to_negbase(int n, int negbase = -2)
{
    std::vector<int> res;

    while (n != 0) {
        auto div = div_with_positive_remainder(n, negbase);
        res.push_back(div.rem);
        n = div.quot;
    }
    return res;
}

And

int to_int(const std::vector<int> &digits, int base = -2) {
    int res = 0;
    int power = 1;
    for (auto digit : digits){
        res += power * digit;
        power *= base;
    }
    return res;
}

std::vector<int> negative_base(const std::vector<int> &v)
{
    return to_negbase(-to_int(v));
}

Demo