class Solution {
public:
    long long maxKelements(vector<int>& nums, int k) {
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
        
        std::priority_queue<int> queue;
        for(const auto& num: nums){
            queue.push(num);
        }
        
        long long sum = 0;
        while(k--){
            sum += static_cast<long long> (queue.top());
            auto cur = std::ceil(queue.top() / 3.0);
            queue.pop();
            queue.push(cur);
        }
        return sum;
    }
};

cmake_minimum_required(VERSION 3.29)
project(untitled4)

set(CMAKE_CXX_STANDARD 20)

find_package(nlohmann_json REQUIRED)
find_package(cpr REQUIRED)

add_executable(untitled4 main.cpp
        first.cc)

target_link_libraries(${PROJECT_NAME} PRIVATE nlohmann_json::nlohmann_json)
target_link_libraries(${PROJECT_NAME} PRIVATE cpr::cpr)

#include <iostream>
#include <cpr/cpr.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main() {
    try {
        cpr::Response response = cpr::Get(cpr::Url{"https://jsonplaceholder.typicode.com/posts/1"});

        if (response.status_code != 200) {
            throw std::runtime_error("Error HTTP: " + std::to_string(response.status_code));
        }

        try {
            json response_json = json::parse(response.text);

            std::cout << "ID: " << response_json["id"] << std::endl;
            std::cout << "Title: " << response_json["title"] << std::endl;
            std::cout << "Body: " << response_json["body"] << std::endl;

        } catch (const json::parse_error& e) {
            throw std::runtime_error("Error parsing Json: " + std::string(e.what()));
        }

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

class Solution {
public:
    int longestSquareStreak(vector<int>& nums) {
        std::unordered_set<long long> mp;

        for(const auto& num: nums){
            mp.insert(static_cast<long long>(num));
        }

        int mx = 0;
        for(const auto& num: nums){
            int cnt = 1;
            long long cur = static_cast<long long>(num);
            while(mp.count(cur * cur)){
                cur = cur * cur;
                cnt++;
            }
            
            mx = std::max(cnt, mx);
        }
        return (mx != 1) ? mx : -1;
    }
};

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
      auto last = std::unique(nums.begin(), nums.end());
      nums.erase(last, nums.end());
      return nums.size();  
    }
};

n=array.length
i=0..n-1
j=i..n
gacha agar array[i] == array[j] bulsa belgilab olamiz
oxirida shu belgiga asoslanib yo davom etamiz yoki shu joyda tuxtatib ekranga chop etamiz.

class Solution {
public:
    int singleNumber(vector<int>& nums) 
    {
        unordered_map<int,int> num;
        for (auto i:nums)
        {
            num[i]++;
        }

        for(auto i:num)
        {
            if(i.second==1)
            return i.first;
        }
        return -1;
    }
};

class Solution {
public:
    int singleNumber(const std::vector<int>& nums) {
        int xorr = 0;
        for (const auto& num : nums) {
            xorr ^= num;
        }
        return xorr;
    }
};

#include <iostream>
#include <vector>
#include <string>

class Quiz {
private:
    std::vector<std::pair<std::string, std::string>> questions;
    int score = 0;

public:
    Quiz() {
        questions = {
            {"What is 2 + 2?", "4"},
            {"What is the capital of France?", "Paris"},
            {"Who wrote '1984'?", "George Orwell"}
        };
    }

    void runQuiz() {
        for (const auto& [question, answer] : questions) {
            std::cout << question << " ";
            std::string userAnswer;
            std::getline(std::cin, userAnswer);
            if (userAnswer == answer) {
                score++;
            }
        }
        std::cout << "You scored " << score << " out of " << questions.size() << "!\n";
    }
};

int main() {
    Quiz quiz;
    quiz.runQuiz();
    return 0;
}

#include <iostream>
#include <vector>
#include <string>

class Question {
public:
    std::string questionText;
    std::string correctAnswer;

    Question(const std::string& text, const std::string& answer)
        : questionText(text), correctAnswer(answer) {}
};

class QuizManager {
private:
    std::vector<Question> questions;
    int score = 0;

public:
    QuizManager(const std::vector<Question>& q) : questions(q) {}

    void runQuiz() {
        for (const auto& q : questions) {
            std::cout << q.questionText << " ";
            std::string userAnswer;
            std::getline(std::cin, userAnswer);
            if (userAnswer == q.correctAnswer) {
                score++;
            }
        }
    }

    int getScore() const { return score; }
    int getTotalQuestions() const { return questions.size(); }
};

class QuizUI {
public:
    static void displayResult(int score, int totalQuestions) {
        std::cout << "You scored " << score << " out of " << totalQuestions << "!\n";
    }
};

int main() {
    std::vector<Question> questions = {
        {"What is 2 + 2?", "4"},
        {"What is the capital of France?", "Paris"},
        {"Who wrote '1984'?", "George Orwell"}
    };

    QuizManager quizManager(questions);
    quizManager.runQuiz();

    QuizUI::displayResult(quizManager.getScore(), quizManager.getTotalQuestions());

    return 0;
}

#include <iostream>
#include <string>

// Function that violates OCP by using if-else for each message type
class MessageHandler {
public:
    void handle(const std::string& type, const std::string& message) {
        if (type == "text") {
            std::cout << "Handling text message: " << message << '\n';
        } else if (type == "error") {
            std::cerr << "Handling error message: " << message << '\n';
        } else {
            std::cout << "Unknown message type: " << message << '\n';
        }
    }
};

int main() {
    MessageHandler handler;
    handler.handle("text", "Hello, World!");
    handler.handle("error", "Something went wrong.");
    handler.handle("info", "New message type!");  // Adding new types requires modifying the method
    return 0;
}

#include <iostream>
#include <string>
#include <memory>
#include <vector>

// Base class that defines the interface
class MessageHandler {
public:
    virtual ~MessageHandler() = default;
    virtual void handle(const std::string& message) const = 0;
};

// Handler for text messages
class TextMessageHandler : public MessageHandler {
public:
    void handle(const std::string& message) const override {
        std::cout << "Handling text message: " << message << '\n';
    }
};

// Handler for error messages
class ErrorMessageHandler : public MessageHandler {
public:
    void handle(const std::string& message) const override {
        std::cerr << "Handling error message: " << message << '\n';
    }
};

int main() {
    std::vector<std::shared_ptr<MessageHandler>> handlers;
    handlers.emplace_back(std::make_shared<TextMessageHandler>());
    handlers.emplace_back(std::make_shared<ErrorMessageHandler>());

    for (const auto& handler : handlers) {
        handler->handle("Hello, World!");  // No need to change the existing code
    }

    return 0;
}