Wataru

Проще всего двигать элементы по одному, справа-налево. Элемент можно сдвинуть, если справа стоит 0 или такой же элемент. Поддерживаем инвариант, что все элементы правее current уже сдвинуты и уплотнены до предела. Двигаем текущий пока можем. Чтобы не было циклов не двигаем нули.

int n = a.size();
int current = n-1;
while (current >= 0) {
    while (a[current] > 0 && current < n-1 && 
          ((a[current+1] == a[current]) || (a[current+1] == 0))) {
      a[current+1] += a[current];
      a[current] = 0;
      ++current;
    }
    --current;
}

Это называется яркость света. Цвет лазера особо не меняется. Наверно, можно считать, что яркость уменьшается очень медленно линейно из-за рассеивания воздухом. Для не лазерных источников света яркость убывает квадратично от расстояния.

Try doing what the error messages are telling you:

Detected compiler newer than Visual Studio 2022, please update min version checking in WindowsPlatformCompilerSetup.h

Or install the Visual Studio 2022 instead of what you have.

100gb - это не так и много. Даже не надо кластера, чтобы это обрабатывать.

Быстрее, конечно, работать будет на C++/rust каком-нибудь, но обработка csv может быть легче реализованна на питоне.

Разница как бы есть. В одном случае у вас *(p++), а в другом просто p++. И то и другое сдвинет указатель p на одну ячейку вправо, т.е. код имеет ровно тот же результат. Но в случае с * вы еще и адрес p, который там был до увеличения, разименуете, т.е. получите доступ. Но просто такое выражение, где вы его разименовываете и ничего с ним не делаете не имеет смысла. Его можно использовать, если вы со значением что-то делаете, например:

void Copy(char *src, char *dst) {
    while (*src) {
      *dst++ = *src++;
    }
    *dst = '\0';
  }

Тут вы значение по адресу src берете и записываете в адрес dst. Но из-за ++ оба указатлея сдвинутся. Получается копирование сишной строки.

Но делать просто *p++; смысла никакого нет. Это примерно то же что и:

int i;
i;

Вот выражение `i;` - оно как бы получает доступ к i, но со значением ничего не делает. Это странный и бесполезный код.

Так что * у вас там явно лишняя.

В ошибке же написано "Unexpected compiler version, expected CUDA 10.1 Update 2 or newer."

Перевод на русский - поставьте CUDA версии 10.1 update 2 или новее.

Основаня идея простая: ориентируйте многоугольник, допустим, против часовой стрелки. Потом для каждой точки пересечения надо знать, входит ли в ней многоугольник внутрь, или выходит наружу из нужной области. Потом обходите многоугольник начиная с какой-то точки пересечения, пока отрезки снаружи - пропускаете их, пока внутри - дописываете в ответ. Надо еще помнить, где у вас последний отрезок в ответе заканчивается, так что иногда новый отрезок будет с ним не связан - это надо будет взять отрезки из прямоугольника в ответ. Но есть крайние случаи: пересечение по прямой, многоугольник выходит за границу в одной стороне, а входит в другой.

Самая концептуально простая реализация будет, если сделать функцию для отсечения группы многоугольников полуплоскостью. Прямоугольник ваш - это 4 полуплоскости: 2 вертикальные и 2 горизонтальные. Пересечение с полуплоскостью проще - там тупо прямая же одна. Вот пресеките многоугольник с первой, полученные ответ со второй, потом что осталось с третьей и потом с четвертой полуплоскостью.

Удобно хранить множество точек и для каждой - указатель на сделующую в обходе многоугольника (ориентированного так, что слева от отрезка внутренность многоугольника). В таком виде входные данные, в таком виде будет и ответ.

Точки будем помечать, как обработанные.

Обойдите все точки циклом, для всех необработанных еще, которые лежат внутри полуплоскости, начинайте с них строить ломанную-ответ. Идите к следующей точке, пока отрезок не пересечет полуплоскость (это значит конец строго внутри удаляемой области), помечая точки обработанными. До этого момента добавляйте точки в ответ сохраняя указатель на следующую точку. Для текущей следующей сделайте новую точку - точку пересечения. Еще запомните где-то эту точку пересечения, это потом понадобится. Продолжайте обход, пока отрезок не выйдет из полуплоскости (конец строго снаружи удаляемой области). Тут создайте точку пересечения, запишите ее в ответ, и для нее следующей сделайте конец отрезка снаружи. Продолжайте обход как в начале. Если встретили уже обработанную точку, вы закончили строить ломанную ответ.

Потом надо будет все точки пересечения соединить в порядке вдоль прямой парами (смотрите так, чтобы удаляемая область была справа от направления движения). Их будет четное количество.

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

Удобно прямую хранить в виде Ax+By+C=0. И знак подобрать так, что точки внутри хорошей области, если их подставить в это уравнение дают положительные значения (а точки снаружи - будут отрицательные). Соответственно, проверка, что с точки можно начать обход - просто посмотреть на знак. Проверка, что есть пересечение - конец отрезка дает отрицательный знак (а потом - положительный). Точки удобно хранить в виде массива координат и массива номеров следующей точки в обходе. Никаких сишных указателей - номера следующей точки в массиве. Сортировать точки пересечения надо будет по значению Ay-Bx.

Если вам надо различать изначальные точки многоугольника и добавленные, то можете это свойство у точек копировать из входных данных в ответ, когда точка добавляется в ответ из многоугольника, а не создается новая точка пересечения.

Это все удовольстивие будет работать за O(n log n) - потому что надо потом точки пересечения на прямой отсортировать.