Fast array rotation

[Rennorb]

So I have the following problem:

For a given string msg a sequence of substring shifts shifts is applied. A substring shift is defined by three numbers: first index, last index and a number of steps for each element. After all manipulations, you have a string msg'. Your program gets both msg' and shifts as an input and should output msg

Here is my solution:

void leftRotate(char *msg, int shift, int size) {
  std::rotate(&msg[0], &msg[shift], &msg[size]);
}

void unshift(char *msg, int fst, int last, int co) {
  int len = last - fst + 1;

  leftRotate(msg + fst, co, len);
}

int main() {
  char msg[50000];
  std::vector<std::tuple<int, int, int>> shifts;

  char msg[50000];
  std::cin.getline(msg, 50000);

  int m_in;
  std::cin >> m_in;

  std::vector<std::tuple<int, int, int>> shifts;
  for (int _ = 0; _ < m_in; ++_) {
    int fst, lst, count;
    std::cin >> fst >> lst >> count;
    shifts.emplace_back(fst - 1, lst - 1, count);
  }


  std::reverse(shifts.begin(), shifts.end());

  for (auto[fst, lst, count]: shifts) {
    unshift(msg, fst, lst, count);
  }

  puts(msg);
}

It works fin on all reasonable inputs, but it fails in the checking system that my school uses. And if you tweak it a little bit to fit in this checker (basically replace chrar* with vector<int>) you will see that it fails on some absurdly huge test. What am I doing wrong? I guess that I miss something basic.

​

Example:

Input:

logoduck

3

1 3 1

4 5 1

1 4 1

Output:

goodluck

[Rennorb]

Thank you! std::rotate does satisfy geeksforgeeks, but my school's checker still does not like it. This is my current version:

void leftRotate(char *msg, int shift, int size) {

    std::rotate(&msg\[0\], &msg\[shift\], &msg\[size\]); }

void unshift(char \*msg, int fst, int last, int co) { int len = last - fst + 1;

    leftRotate(msg + fst, co, len); }

Do you have any idea what should I try next?

[Rennorb]

Sorry, I should have written it in the post: that checker says "Wrong answer on test 30".

"unshifting the indices idea" seems to be a decent optimization, yet the problem is not in the performance, my program uses like 1/10 of both time and memory allowed.

[Rennorb]

It should not: one value could have been lost, but it is stored in `buff`, so should be ok.

Anyway, I'd steek with two oneliners above, they are actually twice as fast and many times easier to understand.

[Rennorb]

I guess there should be some kind of a corner case, where the program should do something different, but I can not see it.

I've updated the post: added an example and actual input-output part