Alexander Movchan

На кой вам этот foreach, используйте плюсовый range-for.

Потому, что zip возвращает генератор, а генератор может быть использован только один раз. Соответственно, строка

value = sum( target_fn(x_i, y_i, theta) for x_i, y_i in data )

срабатывает, а цикл for x_i, y_i in in_random_order(data): уже нет. Если же использовать list, то в переменной data окажется не генератор, а данные, которые он генерирует.

Пусть турнир назначен на этаже X.
На этажах 1…X живут L’ людей, на этажах X+1…N — H′ людей.
Вопрос 1. Стоит ли переносить турнир на этаж X+1?
Тогда для L′ людей добавляется лишний этаж, для H′ — исчезает лишний этаж, и выигрыш будет H′−L′.
Стоит, если H′ > L′. Не стоит, если H′ < L′. Безразлично, если H′ = L′.

Вопрос 2. Возможно ли такое: вверх на 1 перенести не удаётся (будет хуже или безразлично), но этаж Y > X оптимальнее (строго)?
Раз вверх на 1 перенести нельзя, то H’ <= L’.
Если этаж Y − 1 безразличен с Y, перенесём турнир туда. Если Y − 2 тже безразличен, то туда, и т.д. Остановимся на этаже Z. Видно, что Z > X + 1: если мы в результате этих движений добрались до X+1, то он лучше X, противоречие.
Раз Z — оптимальный этаж, то у этажа Z−1 > X есть свои L″ и H″, и поскольку с Z−1 на этаж вверх перенести всё же можно, то H″ > L″.
С другой стороны, при повышении этажа увеличивается L и уменьшается H, и L″ >= L′ >= H‘ >= H″, то есть H″ <= L″. Противоречие.

Следствие 3. Если турнир выгодно перенести на несколько этажей выше/ниже, то его выгодно перенести и на этаж выше/ниже.

Задача 4. Пусть на этажах 1…X−1 живут L людей, на этаже X — M людей, на этажах X+1…N — H людей.
Для простоты считаем, что сверху и снизу есть по фиктивному пустому этажу — то есть теоретически можно (на практически неоптимально) проводить турнир в подвале и на чердаке.
Задачу с переносом турнира вверх мы уже решали, и условие того, что турнир нельзя (или безразлично) перенести на этаж вверх: H <= L + M.
Условие того, что турнир можно (или безразлично) перенести с этажа X−1: H + M >= L.
Поскольку H + M + L = N (кол-во людей), то эти условия можно записать в виде: L + M >= N/2, L <= N/2
(всё, получили чеканное условие, и ключи от чердака и подвала можно отдать техслужбам гостиницы.)

Решение: Идём по этажам, считаем людей. Где накопится N/2, там проводим турнир.

// считаем полное кол-во
N = 0
для i = [0..nFloors)
  N += a[i]
// ищем, где половинка N
sum = 0;
для i = [0..nFloors)
  sum += a[i]
  если sum * 2 >= N
    вывести: i
    СТОП

Расширенное решение: Если накопилось ровно N/2, безразличны данный этаж, все нулевые над ним, и ещё один ненулевой. (Можно без кода?)

Можно очень просто. Сохраняешь в бд последнее время, когда игрок обновил энергию. Потом, при следующем запросе ты смотришь, пора? Далее, если необходимо, проверяешь, сколько раз стоило восстановить энергию. Ну и добавляешь необходимое количество пунктов.

0. Бросать ли мне OpenGL?

Не забудьте C++ дальше учить.

1.Возможно ли создание шейдеров OpenGL на Visual Studio?(он же вроде с Директом дружит)

А что конкретно от Студии нужно? Файлы редактировать сможете, расширения для подсветки тоже были, думаю сможете найти. С дебагом вроде не так круто как с HLSL, но вам может пока и не надо.

2.Какое расширение должно быть у кода, самого шейдера?

.frag/.vert или .frag.glsl/.vert.glsl или просто .glsl, это всё условность, загружать текст шейдеров всё равно вы сами будете.

3.Как собрать шейдер, и где мне найти линковщик, компилятор?

glSharedSource/glCompileShader - пока этого будет вам достаточно.

Уже бесит меня этот OpenGL. Знал что будет не просто, но чтобы настолько.

Видимо у вас наивное представление о предмете разговора.
OpenGL - это графическое API, которое используется как в академической, так и в профессиональной среде. Оно конечно заметно проще чем Vulkan или тем более Direct3D, но всё-таки это не учебное API. Современные версии OpenGL отвечают требованиям даже крупных игровых проектов, т.е. у современного OpenGL достаточно продвинутая архитектура, отвечающая темпам развития графического оборудования.
Иными словами, вы выбрали в общем-то профессиональный инструмент, и вы пока что к этому не готовы. GLSL - это отдельная большая история, он требует знаний не меньше, чем весь остальной OpenGL. По языку шейдеров пишут самостоятельные книги, по нему даже соревнования проводят на всяких сценерских движухах - кто круче шейдер напишет за ограниченное время.

Это я пишу не чтобы отбить у вас желание учить, а для того чтобы вы понимали, что в IT и программировании есть достаточно сложные и объёмные вещи, которыми с разбегу не овладеешь. Если вы ещё и C++ только начали учить, но вам тем более тяжело должно быть. Я впервые сделал что-то потребное на OpenGL только на 4-м курсе, уже чувствуя себя комфортно в плюсах.

if i%3 == 0; i%5 == 0 {
Точка с запятой внутри блока if просто разделяет инструкции, выполняющиеся по порядку.
Скорее всего, вы хотели сделать так:
if i%3 == 0 && i%5 == 0 {

Но я бы ваш кусок упростил вот так:

if i%3 == 0 {
	fmt.Print(i, "Fizz")
}
if i%5 == 0 {
	fmt.Print(i, "Buzz")
}
fmt.Println("")
i++

По умолчанию нумерация начинается с 0, и когда вы пишите range(10) он выдает 10 элементов, а не 11, и это удобно. Остальные кейсы подстроены под это.

Это - деление по модулю, но есть нюанс:
В разных языках оно реализовано по-разному, т.е. это не вполне "математическая функция".
Вот питон

MOD = 3

def f(x):
    return (x - 1) % MOD

for x in range(MOD):
    print(f'f({x}) = {f(x)}')

А в javascript'е уже надо ловчить

const MOD = 3;
const f = x => (x + MOD - 1) % MOD;
for (let x = 0; x < MOD; x++)
    console.log(`f(${x}) = ${f(x)}`);

Причем в питоне javascript'овый вариант работать будет )

Первый вариант -- просто сделать это:

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newVec](const A &a)
		{
			return std::find_if(newVec.begin(), newVec.end(), [&a](const A &newA){ return a.id ==  newA.id; }) == newVec.end();
		}),
	myVec.end());

Для упрощения можно перегрузить оператор == для A так, чтобы он сравнивал id:

struct A
{
	//...
	bool operator==(const A &other) const
	{
		return a.id == other.id;
	}
	//...
};

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newVec](const A &a)
		{
			return std::find(newVec.begin(), newVec.end(), a) == newVec.end();
		}),
	myVec.end());

Эти решения будут пробегать по всем элементам из newVec для каждого элемента в myVec. Уже при размере в 1000 элементов для каждого, надо будет сделать 1 000 000 сравнений. ВЫход -- использовать set или unordered_set:

namespace std
{
	//для unordered_set
	template<>
	struct hash<A>
	{
		std::size_t operator()(const A &a)
		{
			return std::hash<int>()(a.id);
		}
	}

	//для std::set
	template<>
	struct less<A>
	{
		bool operator()(const A &lha, const A &rha)
		{
			return lha.id < rha.id;
		}
	}
}

std::unordered_set<A> newSet;
//std::set<A> newSet

newSet.insert(a);
newSet.insert(b);
newSet.insert(d);

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newSet](const A &a)
		{
			return newSet.find(a) == newSet.end();
		}),
	myVec.end());

Может для начала покажите как выглядит сейчас и что хотите в итоге?
Чтобы выглядело прилично нужно:
1) Освещение
2) Самозатенение
3) Bump карта для мелких деталей
4) Specular и glossiness для отражений и его интенсивности.
5) MipMap для устранения "резкости" на отдалении.

num |= 0xF << (sizeof(num) * 8 - 4);

Если нет других ограничений, то [(n-1)/30]+1 30-местных автомобилей.