#include <iostream>
#include <vector>
#include <set>
#include <string>
#include <cstdlib>
#include <ctime>
#include <thread>
#include <atomic>
#include <cmath>

// Function to calculate the transformations of the number
std::string hesapla(long long baslangic, int basamak_sayisi) {
    std::set<std::string> toplam_seti;  // To track previously seen numbers
    long long sayi = baslangic;
    long long limit = static_cast<long long>(pow(10, basamak_sayisi)); // 10^basamak_sayisi

    int adim = 0;

    while (true) {  // No max steps limit
        // Reduce number to the specified digits
        sayi %= limit;
        std::string sayi_str = std::to_string(sayi);
        while (sayi_str.length() < basamak_sayisi) {
            sayi_str = "0" + sayi_str; // Pad with leading zeros if necessary
        }

        // Compute the digit sum
        int toplam = 0;
        for (char c : sayi_str) {
            toplam += c - '0';  // Convert char to int and sum digits
        }

        // Compute the new number
        long long yeni_hane = (std::stoll(sayi_str.substr(1)) * 10 + (toplam % 10)) % limit;
        std::string yeni_hane_str = std::to_string(yeni_hane);
        while (yeni_hane_str.length() < basamak_sayisi) {
            yeni_hane_str = "0" + yeni_hane_str; // Pad with leading zeros if necessary
        }

        // Check for cycles
        if (toplam_seti.find(yeni_hane_str) != toplam_seti.end()) {
            return "Döngü oluştu! Adım: " + std::to_string(adim) + ", Girilen sayı " + std::to_string(basamak_sayisi) + " basamaklı.";
        }

        // Add the new number to the set and update variables
        toplam_seti.insert(yeni_hane_str);
        sayi = yeni_hane;
        adim++;
    }
}

// Function to get a valid numeric input from the user
std::string get_valid_input(const std::string& prompt) {
    std::string value;
    while (true) {
        std::cout << prompt;
        std::cin >> value;
        if (value.find_first_not_of("0123456789") == std::string::npos) {
            return value;
        }
        std::cout << "Geçersiz giriş! Lütfen sadece rakamlardan oluşan bir sayı giriniz." << std::endl;
    }
}

// Function to generate random start values based on the input number
std::vector<long long> generate_start_values(long long x, int count) {
    std::vector<long long> start_values;
    srand(time(0));  // Initialize random seed

    for (int i = 0; i < count; ++i) {
        start_values.push_back(x + rand() % 1001);  // Random value between x and x+1000
    }
    return start_values;
}

// Function to run the computation in parallel
void parallel_hesapla(const std::vector<long long>& start_values, int basamak_sayisi) {
    std::vector<std::string> results(start_values.size());
    std::atomic<bool> cycle_found(false);  // To detect the first cycle across threads

    auto task = [&results, &start_values, basamak_sayisi, &cycle_found](int index) {
        if (cycle_found.load()) return;  // Stop if a cycle is already found
        std::string result = hesapla(start_values[index], basamak_sayisi);
        if (!cycle_found.load() && result.find("Döngü oluştu") != std::string::npos) {
            cycle_found.store(true);
        }
        results[index] = result;
    };

    std::vector<std::thread> threads;
    for (int i = 0; i < start_values.size(); ++i) {
        threads.push_back(std::thread(task, i));
    }

    for (auto& t : threads) {
        t.join();
    }

    for (const auto& result : results) {
        if (result.find("Döngü oluştu") != std::string::npos) {
            std::cout << result << std::endl;
            break;  // Stop after the first cycle is found
        }
    }
}

int main() {
    std::string x_str = get_valid_input("Lütfen bir sayı giriniz: ");
    long long x = std::stoll(x_str);

    std::string basamak_sayisi_str = get_valid_input("Kullanılacak basamak sayısını giriniz: ");
    int basamak_sayisi = std::stoi(basamak_sayisi_str);

    if (basamak_sayisi <= 0) {
        std::cout << "Basamak sayısı pozitif bir tamsayı olmalıdır." << std::endl;
        return 1;
    }

    // Generate random start values based on the input number
    std::vector<long long> start_values = generate_start_values(x, 5);

    parallel_hesapla(start_values, basamak_sayisi);

    return 0;
}