Mercury13

Float содержит 23 бита мантиссы и неявную единицу. Порядок float запредельный и даже qword не упрётся в него.
Это значит: всё, что дальше 23 бит от верхней единицы, должно быть нулём.

bool isPreciseFloat(unsigned long long n)
{
  // Простейшая проверка: стираем нижние 24 бита
  // Если в них вписываемся — ДА.
  unsigned long long n1 = n & ~((1ULL << 24) - 1);
  if (n1 == 0)
    return true;

  // Получаем верхнюю единицу
  // (можно также двоичным поиском, но я этого с листа не напишу)
  while (true) {
    unsigned long long n2 = n1 & (n1 - 1);
    if (n2 == 0)
      break;
    n1 = n2;
  }

  // Получаем маску всего, что ниже 23 бит от верхнего бита.
  n1 >>= 23;
  --n1;

  // Проверяем по маске
  return (n & n1) == 0;
}

Писал «с листа», могут быть ошибки.

Перед нами UTF-8. Перекодируйте исходник в рабочую кодировку (обычно DOS-866 или Windows-1251).

Или работайте в широких строках. У меня на MinGW 5.3 получился вот такой исходник.

#include <iostream>

using namespace std;

int main()
{
    setlocale(LC_ALL, "rus");
    wcout << L"Превед!" << endl;
    return 0;
}

Если N=20, X=3, Y=5, то наш выход — 8.
3, 5, 6, 9, 10, 12, 15, 18.

Лобовое решение — пройти [2, N) и пересчитать нужные числа.

Идея умного решения. Если X и Y гарантированно простые, то эти самые числа повторяются с шагом X·Y.
3, 5, 6, 9, 10, 12, 15
18, 20, 21, 24, 25, 27, 30
А дальше думайте сами.

У меня вышло: 0 1074266112 0 1074266112
Или, в 16-й системе, 0 40080000 0 40080000

Связано это с такими вещами.
1. Аргументы типа float записываются в стеке как double.
2. На x86 порядок байтов Intel (обратный).
3. Дробные числа хранятся без ведущего разряда (который всегда 1), в формате мантисса-порядок-знак (на порядке байтов Intel).
4. Для единицы (xxx·2⁰) порядок будет 011…11.

3 = 1,10…0₂·2¹, и с учётом отброшенного ведущего разряда мантисса будет 10…0.
Порядок 011…11 + 1 = 10…0.

С учётом обратного порядка байтов double 3,0 будет выглядеть так
• 6 нулевых байтов — мантисса
• 0000.1000: нижние полбайта — это мантисса, верхние — уже порядок
• 0100.0000: бит знака и ещё семь битов порядка

Получается 00.00.00.00.00.00.08.40.
Разбиваем на два куска памяти по 4 байта.
[00.00.00.00] [00.00.08.40]
Опять-таки не забудем, что у целых тоже обратный порядок байтов — и получается 0 и 40080000.

Представьте, у нас десятичная арифметика с тремя значащими цифрами. Соответственно, сложение работает не более чем с пятью цифрами: три собственно значащих, слева на перенос и справа на округление. То, что получилось, в любом случае будет округлено до трёх.

 99900000000000
+             1,00
 -----------------
 9990   →   9,99e13

Если сделать второе слагаемое покрупнее, то будет

 99900000000000
+   50000000000
 -----------------
 9995   →   1,00e14 → переполнение

То есть вот что надо добавить, чтобы случилось переполнение: в зависимости от настроек сопроцессора или ulp(FLT_MAX) (ULP = Unit of Last Place — цена младшего разряда на данном порядке), или ulp(FLT_MAX)/2.

Определение π: отношение длины окружности (P) к диаметру. То есть P=2πR.
Определение радиана: дуга, равная радиусу. Из предыдущей формулы полный оборот = 2π радиан.

Угловая скорость измеряется в угловых единицах в секунду. Из-за удобного преобразования из угловых единиц в линейные и наоборот в науке широко используют радианы, которых в полном обороте 2π.

Если T = секунд/оборот, то T/2π = секунд/радиан, и 2π/T = радианы/секунду. Вот и всё.
Хотите в градусах? Пожалуйста! T/360 = секунд/градус, и 360/T — градусы/секунду.

Одно из двух.
А. O(n³) и O(2ⁿ) — сложность каких-то алгоритмов.

Читайте определение символов Ландау, и будет всё понятно.
n³ = o(2ⁿ) при n→∞, что означает:

lim{n→∞} n³ / 2ⁿ = 0.

Что означает: при безграничном повышении n алгоритм, работающий за n³, будет иметь всё большее и большее преимущество перед конкурентом.

Б. n³ и 2ⁿ — функции, которые нам надо вычислить.

Сложность первой O(1) (всегда два умножения), сложность второй в общем случае — O(log n) (из-за того, что логарифмы от разных оснований отличаются на константу, а константу символы Ландау не учитывают, основание логарифма не пишут).

UPD. Что значит «в общем случае»? Оценку могут увеличить различные второстепенные алгоритмы вроде выделения памяти и преобразования в десятичный вид, и уменьшить — то, что 2ⁿ можно вычислть сдвигом. Не забудьте, что сложность алгоритмов определяется при n→∞.

Закорот USB обычно приводит к отключению компьютера, проверено на собственной шкуре.

Ранние USB не выдерживали переполюсовку, это было реальной проблемой, когда разводка косички была не стандартизирована. Я с ней не сталкивался, первый комп с USB 2.0 у меня появился в 2008 и тогда вроде всё было не так мрачно.

Наушникам закорот не вреден.

UPD. Стандарт USB таков, что устройство ОБЯЗАНО выдерживать переполюсовку, но «гладко было на бумаге»…
UPD2. Вставка наушников в компах определяется физическим присутствием штыря, в телефонах — как придётся.

Бизнес-логика — это то, что программа делает с точки зрения пользователя. По-другому (и более понятно) — логика предметной отрасли.

Например, у нас есть игра в шахматы. Бизнес-логика — это правила шахмат, принципы работы часов, команды «попросить ход назад», «сдаться» и «согласиться на ничью». Если нужно начинать не с исходной позиции, а с любой — то редактор.

Крайне спорно, относить ли к бизнес-логике — анимация фигурок на манер Battle Chess и боты.

Логика, которая не бизнес — это работа с сетью, графикой, конфигурационными файлами, сохранениями досок и партий, античит и многое другое. В общем, то, что нужно для жизнеобеспечения программы, а не для предметной отрасли. Сохранять партии в PGN или XML, как перекидываться пакетами по сети и какие настройки держать для совместимости…

Работает в новых мобилах. В старых надо поменять провода местами.

Чтобы определить, где земля, где микрофон, берём подходящую гарнитуру и звоним. От земли до уха 30 Ом, от микрофона до уха — очень много (килоомы).

std::forward предназначен для использования в шаблонах; без шаблона можно использовать старый добрый std::move.
Кроме того, std::forward налажен таким образом, что шаблонный параметр надо указывать явно.

Задача std::forward — передать далее простую или временную ссылку в зависимости от того, какую ссылку передаёт пользователь.