Как нарисовать кривую Серпинского (см. ниже), не используя графические библиотеки, а '*' или слешы?

void DrawCurve(char* output, int stride, int order) {
    if (order == 0) {
        output[0] = output[stride+1] = '/';
        output[1] = output[stride] = '\\';
        return;
    }
    int sz = (3 << (order - 1)) - 1;
    DrawCurve(output, stride, order-1);
    DrawCurve(output+(sz+1)*stride, stride, order-1);
    DrawCurve(output+sz+1, stride, order-1);
    DrawCurve(output+(sz+1)*stride+sz+1, stride, order-1);
    output[(sz-1)*stride+sz-1] = ' ';
    output[(sz+1)*stride+sz-1] = ' ';
    output[(sz-1)*stride+sz+1] = ' ';
    output[(sz+1)*stride+sz+1] = ' ';
    for (int i = 0; i < 2*sz+1; ++i) {
        output[i*stride + sz] = output[sz*stride + i] = ' ';
    }
    output[sz*stride+sz-1] = '[';
    output[sz*stride+sz+1] = ']';
    output[(sz-2)*stride+sz] = '_';
    output[(sz+1)*stride+sz] = '_';
}

int main()
{
    const int order = 3;
    const int stride = 3 << order ;
    const int height = (3 << order) - 1;
    char field[stride*height];
    memset(field, 0, sizeof(field));
    DrawCurve(field, stride, order);
    for (int i = 0; i < height; ++i) {
        cout << field + i*stride << "\n";
    }
    return 0;
}

Как из первых N натуральных чисел составить максимальное количество пар, суммы которых являются простыми?

Alexandroppolus, Да, похоже, так и надо. Только это не ДП, а умная жадность. Мы так доказали, что можно все floor(n/2) пар составить. Тут какая-то теорема о том, что среди K..2K обязательно есть простое число нужна (не помню, как она называется), чтобы доказать, что минимальное простое число, большее N будет меньше 2N. А значит можно всегда взять и откусить какие-то максимальные гири.

Как из первых N натуральных чисел составить максимальное количество пар, суммы которых являются простыми?

Для 500000 гирек полный перебор займет вечность.

Экспорт файла SolidWorks для дальнейшего парсинга?

Я бы сделал так, прочитал файл и распарсил строчки AXIS2_PLACEMENT_3D, DIRECTION, CARTESIAN_POINT и CIRCLE. Можно поддерживать 4 разных мапа с ключами - номер строки, и данными оттуда. Что-то вроде map, map и map.

При парсинге не надо никаких регулярок - просто разбиваете строку на токены по пробелам, первый - ключ ("#20"), второй должен быть "=", а третий - это тип строки. если он "CIRCLE" и т.д., то берете соответствуюие 1-3 токена в данные (можно float получить через функцию stof(). Для CIRCLE у вас одна строка - ключ (5-ый токен) и float - радиус (6-ой токен). Для Axis выделяете 3 cтроки - ключа. Для Direction и Cartesian_point вы выделяете 3 float.

Потом проходитесь по всем CIRCLE, берете AXIS c нужным ключем, оттуда берете 3 строки c ключами для Cartesian Point и двух осей. Хотя оси, наверно, можно и игнорировать вообще. Потом в map-е для точки берете точку с нужным ключем. И вот у вас отверстие описывается радиусом, тройкой координат центра и двумя тройками координат осей. Оси, возможно, можно игнорировать. Все эти данные складывайте в новый класс. которые кладите в свой set. Оно автоматически дубликаты считать не будет. в конце его size() - это количество отверстий. И можно их все координаты вывести.

Экспорт файла SolidWorks для дальнейшего парсинга?

#357 = CIRCLE ( 'NONE', #49, 20.00000000000000355 ) ;

А что написано в строке #49?

Возьмите все 4 строки CIRCLE для одного отверстия и все 4 строки, на которые они ссылаются. Наверно, там будут отдельно записаны центры окружностей.

Тогда стоит парсить все строчки CIRCLE и все строчки вида того, на что они ссылаются. Потом из них собирать тройки (координаты, радиус) и вот эти вот уникальные выдавать в ответ.

Экспорт файла SolidWorks для дальнейшего парсинга?

Artem Kirsov, Вы на весь файл смотрите. Может это и не отверстие.

А вообще, можете реверс-инженирингом занятся. Подвигайте одно отверстие, если можете и смотрите, что в файле меняется.

Экспорт файла SolidWorks для дальнейшего парсинга?

Artem Kirsov, Ну структура там, так или иначе - как у всех 3d моделей. Полигоны/треугольники в пространстве. Или набор точек с координатами. а потом набор индексов, описывающих грани. Или набор граней заданных координатами точек.

А вот как дырки искать - это отдельная очень сложная задача. В топологическом смысле? Вот сколько на этой картинке отверстий у объектов?

Ее, наверно. можно даже решить, если у вас отверстия все вот такие - цилиндрическе в плоской модели. Но там все равно будет куча крайних случаев и исключений.

Экспорт файла SolidWorks для дальнейшего парсинга?

После парсинга нужно получить количество отверстий, их диаметр и расположение относительно друг друга или краев.

Собственно алгоритм этого парсинга у вас уже есть?

Что за странная запись в С++?

Вова, ну просто забыли уже ненужную спецификацию удалить, наверно. Оно ничего не делает, смысла не добавляет.

Что за странная запись в С++?

Может, там было какое-то наследование. Может, раньше функция возвращала какого-то наследника Process, и вот так вызывался именно метод у предка.

Задания с CodeForces. Вариант решения есть, но не подходит для всех тестов. Может неправильно понял реализацию решения?

Alexandroppolus, Да, целочисленное. Да, это решение. Я лишь предложил более простое в понимании O(1) решение без аккуратного разбора случаев.

Задания с CodeForces. Вариант решения есть, но не подходит для всех тестов. Может неправильно понял реализацию решения?

stioann, Alexandroppolus, можно над случаями особо не думать, а просто перебрать до 0-1 шагов +3, 0-2 шагов -2 вложенными циклами, потом, если оставшийся путь отрицателен и делится на 2, или положителен и делится на 3, брать оставшееся количество ходов. Из всех вариантов выбираем мнинимальный.

Как подступиться? Нужна ли равномерная сетка ВЫЧМАТ?

P1(x) - это полином первой степени?

Как сделать, что бы скрипт искал только фиксированное количество слагаемых?

Canp,
сделайте for x : Gen(...) : print(x)

Как сделать, что бы скрипт искал только фиксированное количество слагаемых?

Canp, У вас очевидно проблема XY. Вы что-то придумали как вашу исходную задачу решать, свели ее к этому и ищите решение вот этой другой задачи. А она решений не имеет. Если вам порядок важен, всех вариантов просто тупо слишком много.

Как сделать, что бы скрипт искал только фиксированное количество слагаемых?

Canp, Вы вообще представляете, сколько их там этих сочетаний? 7*10^51. Будет считать до тепловой смерти вселенной. Ваш исходный алгоритм, вообще-то тоже.

У вас, я так понял, задача другая. Набрать разбить число на слагаемые от 1 до 7.

Можно хоть и 6 вложенными циклами подсчитать (число 7-ок от 0 до 227//7. Число 6-ок от 0 до (227-7*num7)//6, Число 5-ок от 0 до сколько там влезает в оставшуюся часть числа. И т.д. Число 2 циклом,а число единиц - сколько осталось. Потом через тот же itertools.permutations генерируйте все варианты перемешать набор из num7 7-ок, num6 6-рок и т.д. Можно выходить из цикла если слагаемых слишком много, или если оставшехся чисел не хватит набрать слагаемые. Ну или короче рекурсией.

import itertools

def Gen(s, k, m, cur): # разбить S на K слагаемых от 1 до M
  if m == 1:
    if s != k: return
    new_list = list(cur)
    new_list.extend([1]*k)
    yield from set(itertools.permutations(new_list))
    #yield new_list # если порядок не важен
    return
  can_fit = min(s//m, k, (s-k)//(m-1))
  need_take = max(0, s-k*(m-1))
  new_list = list(cur)
  new_list.extend([m]*need_take)
  for i in range(need_take, can_fit+1):
    yield from Gen(s-m*i, k-i, m-1, new_list)
    new_list.append(m)

print(Gen(227, 52, 7, []))

Только там даже без перестановок 360 тысяч решений, и это умножается на какое-то офигенно большое число, ибо 52 слагаемых можно тасовать кучей способов. Там только одно из решений [5]*19+[4]*33 можно перетасовать 52!/19!/33! ~= 7*10^13 способами. Вы только его одно будете годами тасовать.

Как сделать, что бы скрипт искал только фиксированное количество слагаемых?

Canp, порядок слагаемых не важен?

Что означает T()?

rPman, Это да, но вот int x{}; синициализирует 0. Или можно в функцию передать int().

Что означает T()?

У всех встроенных типов конструктор по умолчанию есть. Дает обычно 0.

Почему мой код не проходит по времени?

leean, Ну поэтапно же все познается. Формулуkol+= m/j-(n-1)/j то понял? Дальше разбиваем на 2 отдельные суммы. Одну с m, другую с n-1.

Дальше, слагаемые с j до корня считаем просто тупо циклом. А оставшиеся слагаемые группируем. Это тот же прием, что и в самом начале сделали. Вместо счета суммы чисел, считаем, а сколько раз каждое число в сумме участвует.

И я там накосячил, надо же "сколько раз число в сумме" домножить на само число. Что-то вроде должно быть
kol += (m/j) +j*(m/j- m/(j+1)) ;