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

  /**
       *  @brief  Builds a %vector from an initializer list.
       *  @param  __l  An initializer_list.
       *  @param  __a  An allocator.
       *
       *  Create a %vector consisting of copies of the elements in the
       *  initializer_list @a __l.
       *
       *  This will call the element type's copy constructor N times
       *  (where N is @a __l.size()) and do no memory reallocation.
       */
      _GLIBCXX20_CONSTEXPR
      vector(initializer_list<value_type> __l,
       const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
  _M_range_initialize(__l.begin(), __l.end(),
          random_access_iterator_tag());
      }