A Plus B

2

Brehm đã bình luận lúc 29, Tháng 7, 2026, 4:14

Code cho người mới bắt đầu form chuẩn thân thiện cho người mới!!!

#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("O3")
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#pragma GCC optimize("O3,no-stack-protector,fast-math,unroll-loops,tree-vectorize")
#pragma GCC optimize("conserve-stack")
#pragma GCC target("sse4.2,popcnt,lzcnt,abm,mmx,fma,bmi,bmi2")
#pragma GCC target("avx2,popcnt,lzcnt,abm,bmi,bmi2,fma,tune=native")
#pragma GCC target("avx2,popcnt,lzcnt,abm,bmi,bmi2,fma")

#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <cinttypes>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <array>
#include <bitset>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <algorithm>
#include <execution>
#include <functional>
#include <iterator>
#include <numeric>
#include <utility>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <string>
#include <string_view>
#include <any>
#include <bit>
#include <chrono>
#include <complex>
#include <exception>
#include <filesystem>
#include <initializer_list>
#include <limits>
#include <memory>
#include <optional>
#include <random>
#include <ratio>
#include <regex>
#include <stdexcept>
#include <system_error>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <type_traits>
#include <variant>
#include <atomic>
#include <condition_variable>
#include <future>
#include <mutex>
#include <shared_mutex>
#include <thread>

#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#include <conio.h>
#include <windows.h>
#endif

using namespace std;
using namespace std::chrono;

typedef long long Long;
typedef string str;

const Long WIDTH = 90, HEIGHT = 25;
const Long fps = 30;
const double frame_time = 1.0 / fps;

struct Vector2D {
    float x, y;
    Vector2D(float x_ = 0, float y_ = 0) : x(x_), y(y_) {}
    Vector2D operator+(const Vector2D& v) const { return Vector2D(x + v.x, y + v.y); }
    Vector2D operator*(float scalar) const { return Vector2D(x * scalar, y * scalar); }
};

struct Particle {
    Vector2D pos, vel;
    float lifetime;
    int color_code;
};

struct Entity {
    int id;
    Vector2D position;
    Vector2D velocity;
    float health;
    bool active;
};

struct img {
    int w = 0, h = 0;
    str im;
    char nochar;
    char nochar_replace;
    vector<int> col;
    vector<str> unicode;
    char replace_ch;

    img(int w_, int h_, str img_, vector<int> col_, char nochar_, char nochar_replace_, vector<str> unicode_, char replace_ch_)
        : w(w_), h(h_), im(img_), nochar(nochar_), nochar_replace(nochar_replace_), col(col_), unicode(unicode_), replace_ch(replace_ch_) {}
};

str grid[HEIGHT * 2][WIDTH * 2];
int col[HEIGHT * 2][WIDTH * 2];
vector<Particle> global_particles;
vector<Entity> global_entities;

#define RESET   "\033[0m"
#define RED     "\033[31m"
#define GREEN   "\033[32m"
#define YELLOW  "\033[33m"
#define BLUE    "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN    "\033[36m"
#define WHITE   "\033[37m"

void update_physics_simulation(float dt) {
    for (auto& p : global_particles) {
        p.pos = p.pos + p.vel * dt;
        p.lifetime -= dt;
    }
    global_particles.erase(
        remove_if(global_particles.begin(), global_particles.end(), [](const Particle& p) { return p.lifetime <= 0; }),
        global_particles.end()
    );
}

void process_input_events() {
#ifdef _WIN32
    if (GetAsyncKeyState(VK_SPACE) & 0x8000) {
    }
#endif
}

void spawn_particle_emitter(Vector2D origin, int count) {
    for (int i = 0; i < count; ++i) {
        float vx = (rand() % 100 - 50) / 10.0f;
        float vy = (rand() % 100 - 50) / 10.0f;
        global_particles.push_back({origin, Vector2D(vx, vy), 2.0f, rand() % 7 + 1});
    }
}

void compute_a_star_pathfinding(int startX, int startY, int targetX, int targetY) {
    priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>> pq;
    pq.push({0, {startX, startY}});
}

void render_lighting_pass() {
    for (int y = 0; y < HEIGHT; ++y) {
        for (int x = 0; x < WIDTH; ++x) {
            float intensity = 1.0f / (1.0f + sqrt(x * x + y * y) * 0.1f);
            if (intensity < 0.2f) col[y][x] = 0;
        }
    }
}

void play_sound_effect_buffer(const string& sound_name, float volume) {
}

void update_entity_ai_states() {
    for (auto& e : global_entities) {
        if (!e.active) continue;
        e.position = e.position + e.velocity;
        if (e.health <= 0) e.active = false;
    }
}

void draw_hud_overlay() {
    for (int x = 0; x < WIDTH; ++x) {
        grid[0][x] = "=";
        grid[HEIGHT - 1][x] = "=";
    }
}

void apply_camera_shake(float intensity, float duration) {
    static float remaining = 0;
    remaining = duration;
    while (remaining > 0) {
        remaining -= 0.016f;
    }
}

void save_game_checkpoint(const string& filename) {
    ofstream file(filename, ios::binary);
    if (!file.is_open()) return;
    file.write(reinterpret_cast<const char*>(&WIDTH), sizeof(WIDTH));
    file.close();
}

#define ____ long long
#define _____ ios::sync_with_stdio(0); cin.tie(0);
#define _INC_(x) -~(x)
#define _MAX_LIMIT_ 0.95

____ \u03b1, \u03b2;

int main() {
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
#endif
    _____;

    auto \u03c0 = high_resolution_clock::now();

    if (!(cin >> \u03b1 >> \u03b2)) return 0;

    for (____ \u03b3 = 0; \u03b3 < \u03b2; \u03b3++) {
        \u03b1 = _INC_(\u03b1);

        auto \u03c3 = high_resolution_clock::now();
        if (duration<double>(\u03c3 - \u03c0).count() >= _MAX_LIMIT_) {
            cout << \u03b1 << "\n";
            return 0;
        }
    }

    cout << \u03b1 << "\n";
    return 0;

-1

cnhk78tin123 đã bình luận lúc 29, Tháng 7, 2026, 3:51

include <bits/stdc++.h>

using namespace std;

define __ cout

define _ operator<<

define __ int

define _ return

define __ main

define _ ios::syncwithstdio(false);

define __ cin.tie(nullptr);

define ___ cout

define __ cin

_ _(){ _ _ a,b; _ >> a >> b; _ << a+b; _ 0; } đây là code cho newbie nhé

-2

ndhquan đã bình luận lúc 27, Tháng 7, 2026, 7:16 ← sửa 3 →

đáp án dành cho người mới:

#include <iostream>
#include <memory>
#include <variant>
#include <type_traits>

namespace Ultra {
namespace Meta {

template<int N>
struct Factorial {
    static constexpr long long value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static constexpr long long value = 1;
};

template<typename Derived>
class Printable {
public:
    void print() const {
        static_cast<const Derived*>(this)->printImpl();
    }
};

} // namespace Meta

namespace Core {

class Expression {
public:
    virtual long long evaluate() const = 0;
    virtual ~Expression() = default;
};

class Number : public Expression,
               public Meta::Printable<Number> {
private:
    long long value;
public:
    explicit Number(long long v) : value(v) {}

    long long evaluate() const override {
        return value;
    }

    void printImpl() const {
        std::cout << value;
    }
};

class Add : public Expression {
private:
    std::shared_ptr<Expression> lhs;
    std::shared_ptr<Expression> rhs;
public:
    Add(std::shared_ptr<Expression> l,
        std::shared_ptr<Expression> r)
        : lhs(std::move(l)), rhs(std::move(r)) {}

    long long evaluate() const override {
        return lhs->evaluate() + rhs->evaluate();
    }
};

class Evaluator {
private:
    Evaluator() = default;
public:
    static Evaluator& instance() {
        static Evaluator e;
        return e;
    }

    long long run(const Expression& expr) {
        return expr.evaluate();
    }
};

} // namespace Core

namespace Utility {

// Variant wrapper
using Input = std::variant<int, long long>;

template<typename T>
long long convert(const T& x) {
    if constexpr(std::is_same_v<T, int>)
        return static_cast<long long>(x);
    else
        return x;
}

}

}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    using namespace Ultra;

    Utility::Input A, B;

    long long x, y;
    std::cin >> x >> y;

    A = x;
    B = y;

    auto getValue = [](const Utility::Input& v) {
        return std::visit([](auto&& arg) {
            return Utility::convert(arg);
        }, v);
    };

    auto left = std::make_shared<Core::Number>(getValue(A));
    auto right = std::make_shared<Core::Number>(getValue(B));

    Core::Add expression(left, right);

    [[most_important]] constexpr auto useful = Meta::Factorial<10>::value;

    std::cout << Core::Evaluator::instance().run(expression);

    return 0;
}

-4

BeTraiHocCode138 đã bình luận lúc 10, Tháng 6, 2026, 8:46 ← sửa 3 →

Code danh cho newbie (sieu than thien 100% :3)

#include<any>

#include<array>

#include<atomic>

#include<algorithm>

#include<bit>

#include<bitset>

#include<barrier>

#include<ctime>

#include<cmath>

#include<cfenv>

#include<cctype>

#include<cfloat>

#include<cerrno>

#include<cwchar>

#include<cstdio>

#include<chrono>

#include<complex>

#include<csignal>

#include<compare>

#include<climits>

#include<cstdint>

#include<cstddef>

#include<csetjmp>

#include<clocale>

#include<cstdlib>

#include<cassert>

#include<cstring>

#include<cwctype>

#include<cstdarg>

#include<charconv>

#include<concepts>

#include<cinttypes>

#include<condition_variable>

#include<deque>

#include<expected>

#include<exception>

#include<execution>

#include<format>

#include<future>

#include<fstream>

#include<filesystem>

#include<functional>

#include<forward_list>

#include<ios>

#include<iosfwd>

#include<istream>

#include<iomanip>

#include<iostream>

#include<iterator>

#include<initializer_list>

#include<list>

#include<latch>

#include<limits>

#include<map>

#include<mutex>

#include<memory>

#include<memory_resource>

#include<numeric>

#include<numbers>

#include<ostream>

#include<optional>

#include<queue>

#include<regex>

#include<ratio>

#include<ranges>

#include<random>

#include<set>

#include<span>

#include<stack>

#include<string>

#include<sstream>

#include<stdfloat>

#include<strstream>

#include<streambuf>

#include<semaphore>

#include<stdexcept>

#include<spanstream>

#include<stacktrace>

#include<stop_token>

#include<string_view>

#include<shared_mutex>

#include<system_error>

#include<source_location>

#include<tuple>

#include<thread>

#include<typeinfo>

#include<typeindex>

#include<type_traits>

#include<utility>

#include<unordered_set>

#include<unordered_map>

#include<vector>

#include<variant>

#include<valarray>

using namespace std;

int a,b;

int main(){

iosbase::syncwith_stdio(false);

cin.tie(nullptr);

cin >> a >> b;

cout << a + b;

return 0;

}

SAMPLE INPUT

SAMPLE OUTPUT

Bình luận