Поворот массива вправо на K мест (грубая сила)

Предположим, ваш вектор имеет длину 5 элементов, вы делаете правильный int n = nums.size();, а затем хотите повернуть на k=3. В вашем цикле for, поскольку i == k и k == 3, ваша первая итерация затем обращается к num[3+3], который выходит за пределы и, следовательно, выходит из строя.

Чтобы правильно реализовать алгоритм вращения, вы должны учитывать размер массива во время итерации и корректировать свой индекс с помощью оператора по модулю внутри вашего цикла. Поскольку это обучающее упражнение, я не хочу сразу давать вам полное решение — но, возможно, этого уже достаточно, чтобы направить вас на правильный путь.

Ваш подход верен, но вы поменялись ролями k и n - k.

Как было объяснено в комментариях, вы также неправильно применили идиому языка C для определения размера массива — std::vector. std::vector несет в себе свой размер. Вы можете получить его, вызвав функцию-член size().

• На первом этапе поместите первые элементы n - k в вектор temp.

• На втором этапе скопируйте последние элементы k в начало вектора.

• На последнем этапе скопируйте элементы n - k из временного вектора в конец вектора nums (начиная с нижнего индекса k).

При вашем подходе нет необходимости использовать оператор %.

Подстрочные индексы должны использовать тип std::size_t, который находится в заголовке <cstddef>. Следующая программа аккуратно приводит k к типу std::size_t и использует этот тип для всех переменных управления циклом.

// main.cpp
#include <cassert>
#include <cstddef>
#include <iostream>
#include <string_view>
#include <utility>
#include <vector>

// This using declaration allows the LeetCode Solution 
// to be used without modifying its function signature.
// 
// (Shame on you, LeetCode, for teaching programmers to 
// rely on `using namespace std;`.)
using std::vector;

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        // Preconditions:
        // `nums.size()` lies on the interval [0, 10^5]
        // `k` lies on the interval [0, 10^5]
        assert(nums.size() <= 100'000u);
        assert(k >= 0 && k <= 100'000);

        // Vector size (and subscripts) use type `std::size_t`, from 
        // header <cstddef>. Force `kk` to the half-open interval [0, n).
        std::size_t const n{ nums.size() };
        std::size_t const kk{ static_cast<std::size_t>(k) % n };

        // Treat the "no-rotatation" circumstance as a special case.
        if (kk == 0u)
            return;

        // Copy the first (n - kk) elements into a temporary vector.
        vector<int> temp;
        for (std::size_t i{}; i < (n - kk); ++i) {
            temp.push_back(nums[i]);
        }

        // Copy the last kk elements to the front of the vector.
        std::size_t from{ n - kk };
        for (std::size_t i{}; i < kk; ++i)
            nums[i] = nums[from++];

        // Copy (n - kk) elements from the temporary vector to the 
        // end of vector nums (beginning with subscript `kk`).
        from = 0u;
        for (std::size_t i{ kk }; i < n; ++i)
            nums[i] = temp[from++];
    }
};
class put_vector
{
    std::vector<int> const& v;
public:
    put_vector(std::vector<int> const& v) : v(v) {}
    friend std::ostream& operator<< (std::ostream& ost, put_vector const& pv) {
        ost.put('[');
        if (!pv.v.empty()) {
            ost << pv.v.front();
            for (std::size_t i{ 1u }; i < pv.v.size(); ++i)
                ost << ',' << pv.v[i];
        }
        ost.put(']');
        return ost;
    }
};
void solve(
    std::string_view heading,
    std::vector<int> nums,
    int k)
{
    std::cout
        << heading
        << '\n'
        << "\n  Input: nums = " << put_vector(nums) << ", k = " << k;
    Solution{}.rotate(nums, k);
    std::cout
        << "\n  Output: " << put_vector(nums)
        << "\n\n";
}
int main() {
    std::cout << "LeetCode 189. Rotate Array"
        "\nhttps://leetcode.com/problems/rotate-array/"
        "\n\n";
    solve("Example 1", { 1,2,3,4,5,6,7 }, 3);
    solve("Example 2", { -1,-100,3,99 }, 2);
}
// end file: main.cpp

Выход

Вывод соответствует примерам с сайта LeetCode.

LeetCode 189. Rotate Array
https://leetcode.com/problems/rotate-array/

Example 1

  Input: nums = [1,2,3,4,5,6,7], k = 3
  Output: [5,6,7,1,2,3,4]

Example 2

  Input: nums = [-1,-100,3,99], k = 2
  Output: [3,99,-1,-100]

std::copy

В комментариях ниже @Evg указывает, что векторные элементы можно копировать с помощью std::copy (и итераторов). Я избегал использования вышеперечисленных, потому что хотел остаться в стиле ФП. Однако если они вас устраивают, программу можно значительно упростить.

std::copy позволяет удалить циклы, и вместе с ними полученный код легче читать и легче поддерживать.

Как показано ниже, std::copy принимает три аргумента, каждый из которых является итератором. Первые два описывают диапазон копирования: [первый, последний). Третий определяет пункт назначения.

// Copy the first (n - k) elements into a temporary vector.
auto const nk{ n - k };
vector<int> temp(nk);
std::copy(nums.cbegin(), nums.cbegin() + nk, temp.begin());

// Copy the last k elements to the front of the vector.
std::copy(nums.cbegin() + nk, nums.cend(), nums.begin());

// Copy (n - k) elements from the temporary vector to the 
// end of vector `nums` (beginning with subscript `k`).
std::copy(temp.cbegin(), temp.cend(), nums.begin() + k);

Примечание

Как предложил @Jarod42, использование std::rotate сводит это к одной строке.

Чтобы решить эту проблему более эффективно, используйте следующий трюк:

• Создайте функцию void reverse(std::vector<int>& nums, int start, int end), которая работает за временную сложность O(n/2).
• Обратный массив от индекса 0 до n
• Переверните первое разбиение из [0...k), а второе — из [k, n)

Готово, вектор сдвигается на k элементов.