Question

here’s my dilema.

I have for example this string:

“1 2 3 4 5 ….. 100” , but it can be any length (usually much, much bigger one, talking about 4 digit numbers).

What I need to do: re-arrange the elements of the string based on a known possition.
E.g: the position in question is 70. I need to have the following output:
“70 71 ….100 1 2 3 …69”

Conditions:

1. I know the key: e.g the above “70”. Can be also 500, 5000, depends on the string length.
2. I can’t use any string buffers or string management functions.
3. There’s little to none memory available.
4. There are two 1 byte buffers available.
5. Operation should be done in with the least possible steps (time critical).

I’ve been trying to find a good algorithm that would not depend on the position of key in the string. Basically shifting left/right depending on what half I am still makes it for a lot of reads/writes and I don’t want that.

Thanks a lot!

Answer 1

this code fits your decription, but you’ve been vague enough that I doubt it does what you want…

#include <string>
#include <iostream>
#include <cmath>
#include <cassert>
#include <stdint.h>

int main() {
    int n = 15;
    std::string s = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20  ";

    uint16_t index;
    switch((int)log10(n)) {
    case 0: // 0 - 9 
        // -2 to account for lack of "0" in the list which would have occupied 2 chars..
        index = (2 * (n)) + -2;
        break;
    case 1: // 10 - 99
        index = (3 * (n % 10)) + (10 * 2 - 2);
        break;
    case 2: // 100 - 999
        index = (4 * (n % 100)) + (90 * 3) + (10 * 2 - 2);
        break;
    case 3: // 1000 - 9999
        index = (5 * (n % 1000)) + (900 * 4) + (90 * 3) + (10 * 2 - 2);
        break;
    }

    std::string::iterator first  = s.begin();
    std::string::iterator middle = s.begin() + index;
    std::string::iterator last   = s.end();

    std::string::iterator next = middle;
    while(first != next) {

        char temp1;
        temp1 = *first;
        *first = *next;
        *next = temp1;

        ++first;
        ++next;

        if (next == last) {
            next = middle;
        } else if (first == middle) {
            middle = next;
        }
    }

    std::cout << s << std::endl;
}

Produces the following output:

$ ./test 
15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14

But should work just the same for sequences all the way up to 9999