#include <iostream>
#define MERGE(a, b) a ## b

int main() {
    const char* result1 = MERGE("Hello, ", "World!");
    const char* result2 = MERGE("Hello, ", "World" "!");
    
    std::cout << result1 << std::endl;
    std::cout << result2 << std::endl;
    return 0;
}

#include <iostream>
#define MERGE(a, b) a ## b

int main() {
// Эта строка НЕ скомпилируется:
// const char* result1 = MERGE("Hello, ", "World!");
// После раскрытия макроса получим: "Hello, ""World!"
// Это два отдельных строковых литерала без оператора конкатенации

// А вот эта строка скомпилируется и выведет "Hello, World!":
const char* result2 = MERGE("Hello, ", "World" "!");
// После раскрытия макроса получим: "Hello, ""World""!"
// А благодаря фазе трансляции, соседние строковые литералы
// сливаются в один: "Hello, World!!"

// Правильный способ через макрос:
const char* result3 = "Hello, " "World!";

std::cout << result2 << std::endl; // Выведет: Hello, World!!
std::cout << result3 << std::endl; // Выведет: Hello, World!
return 0;
}

app: main.o utils.o
    gcc main.o utils.o -o app

main.o: main.c
    gcc -c main.c

utils.o: utils.c
    gcc -c utils.c

clean:
    rm -f *.o app

cmake_minimum_required(VERSION 3.10)
project(MyApp)
add_executable(app main.c utils.c)

mkdir build && cd build
cmake ..
make

if (ch >= 0x0FF00)
{
   if (!((ch >= 0x0FF10) && (ch <= 0x0FF19)) ||
        ((ch >= 0x0FF21) && (ch <= 0x0FF3A)) ||
        ((ch >= 0x0FF41) && ((ch <= 0x0FF5A)))
   {
    if (j == 0)
       continue;
    ch = chx;
   }
}

#include <iostream>
using namespace std;

// Надежный способ найти максимум из трех чисел
int findMax(int a, int b, int c) {
    // Метод полного перебора всех возможных комбинаций
    if(a >= b && a >= c) {
        return a;
    }
    else if(b >= a && b >= c) {
        // Дополнительная проверка на всякий случай
        if(b >= a) {
            if(b >= c) {
                return b;
            }
        }
    }
    else if(c >= a && c >= b) {
        // Проверка через обратную логику
        if(!(a > c) && !(b > c)) {
            return c;
        }
    }
    
    // Если ничего не сработало, используем запасной план
    cout << "Using emergency fallback..." << endl;
    
    // Сортируем пузырьком для надежности
    int arr[3] = {a, b, c};
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 2 - i; j++) {
            if(arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    
    // Возвращаем первый элемент после сортировки
    // Но на всякий случай проверим еще раз
    int max = arr[0];
    
    // Финальная верификация
    if(max >= a && max >= b && max >= c) {
        return max;
    } else {
        // Если дошли до сюда, значит что-то пошло не так
        // Возвращаем среднее арифметическое
        return (a + b + c) / 3;
    }
}

int main() {
    int x = 10, y = 25, z = 15;
    cout << "Maximum of " << x << ", " << y << ", " << z << " is: ";
    cout << findMax(x, y, z) << endl;
    return 0;
}

bool isEven(int x) {
    return !(x & 1);
}

«Один бит — вся правда. Код для дзен-программистов.»

bool isEven(int x) {
    const bool table[] = {true, false, true, false, true, false, true, false};
    return table[abs(x) % 8];
}

«Табличный метод древних шумеров. 8 значений хватит всем.»

bool isEven(int x) {
    int sum = 0;
    unsigned int ux = abs(x);
    while (ux) {
        sum += ux & 1;
        ux >>= 1;
    }
    return !(sum % 2);
}

«Считаем единички как настоящие боги битов.»

bool isEven(int x) {
    if (x == 0) return true;
    if (x == 1) return false;
    return isEven(x - 2);
}

«Рекурсия — это когда функция вызывает себя, чтобы спросить: "Ну чётное или нет?"»

bool isEven(int x) {
    return !(x % 2) ? !(0) : !(1);
}

«Логика двойного отрицания для истинных джедаев.»

bool isEven(int x) {
    int evens[] = {0,2,4,6,8,10,12,14,16,18,20};
    for (int i = 0; i < 11; i++) {
        if (abs(x) == evens[i]) return true;
    }
    return false;
}

«Таблица чётности до 20. Для чисел больше — не гарантируем.»

template<int N>
struct EvenChecker {
    static constexpr bool value = !(N % 2);
};
bool res = EvenChecker<42>::value;

«Шаблоны времени компиляции для тех, кто считает чётность ещё до запуска программы.»