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;
}

#include <iostream>
#include <cmath>

bool isPrime(int number) {
    if (number <= 1) {
        return false; // 0 and 1 are not prime numbers
    }
    if (number == 2) {
        return true; // 2 is a prime number
    }
    if (number % 2 == 0) {
        return false; // Even numbers greater than 2 are not prime
    }
    for (int i = 3; i <= std::sqrt(number); i += 2) {
        if (number % i == 0) {
            return false; // Divisible by a number other than 1 and itself
        }
    }
    return true;
}

int main() {
    int number;
    std::cout << "Enter a number: ";
    std::cin >> number;

    if (isPrime(number)) {
        std::cout << number << " is a prime number.\n";
    } else {
        std::cout << number << " is not a prime number.\n";
    }

    return 0;
}

Bu yerda tub sonni aniqlaydigan sodda kod berilgan. 
Bu kodni har tomonlama optimizatsiya qilsa bo'ladi!
Fikringizni izohlarda qoldiring

#include <iostream>
#include <vector>

void sieveOfEratosthenes(int n) {
    std::vector<bool> primes(n); // Using a vector to store prime numbers
    for (int i = 0; i < n; i++) { 
        primes[i] = true; // Initialize all numbers as prime
    }
    
    primes[0] = primes[1] = false; // 0 and 1 are not prime numbers

    for (int p = 2; p < n; p++) { // Iterating up to n instead of sqrt(n)
        if (primes[p]) { // If the number is still marked as prime
            for (int i = p * p; i < n; i += p) { // Start marking multiples from p * p
                primes[i] = false; // Mark multiples as non-prime
            }
        }
    }

    // Print prime numbers
    std::cout << "Prime numbers up to " << n << ": ";
    for (int i = 2; i < n; i++) {
        if (primes[i]) {
            std::cout << i << " ";
        }
    }
    std::cout << std::endl;
}

int main() {
    int n = 50; // Fixed value for testing
    sieveOfEratosthenes(n);
    return 0;
}

#include <iostream>
#include <cmath>

constexpr bool isPrime(int number) {
    if (number <= 1) return false;
    if (number <= 3) return true; 
    if (number % 2 == 0 || number % 3 == 0) return false; 

    for (int i = 5; i * i <= number; i += 6) {
        if (number % i == 0 || number % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    int number;
    std::cin >> number;
    for(int i = 1; i <= number; i++){
        if(isPrime(i))
            std::cout << i << " ";
    }
    return 0;
}

int main() {
    constexpr int number = 15555;//bu ham compile timeda hisoblanadi
    if(isPrime(number))
       std::cout <<"Tub" << "";
    return 0;
}