Làm thế nào để cải thiện việc tạo số ngẫu nhiên này trong ngữ cảnh của tôi?

Trong trò chơi của tôi có một từ ở phía trên màn hình, các chữ cái đang mưa từ trên xuống và người dùng phải chạm vào các chữ cái để hoàn thành từ đó.

Hiện tại tôi đang tạo các chữ cái ngẫu nhiên (thực tế số và số ngẫu nhiên là chỉ số cho mảng các chữ cái. Ví dụ: 0 = a, 1 = b) nhưng vấn đề là phải mất quá nhiều thời gian để có được tất cả các chữ cái cần thiết để hoàn thành từ.

Điều tôi muốn là các số ngẫu nhiên mà tôi đang tạo sẽ tạo ra các chữ cái cần thiết thường xuyên hơn để người chơi không phải dành cả ngày để hoàn thành một từ.

Tôi đã thử các phương pháp sau:

1. Phát hiện tất cả các chữ cái trong từ (từ luôn dài 6 chữ cái), tạo ra mảng chỉ số có độ dài 6, gán từng chỉ số của mảng cho số ngẫu nhiên từ chữ-2 đến chữ + 2 và cuối cùng chọn ngẫu nhiên một chỉ mục từ mảng để hiển thị.

2. Có một biến chọn có giá trị nằm trong phạm vi [0..2], được tạo ngẫu nhiên, nếu bộ chọn == 0 thì phát hiện các chữ cái tạo ra từ đó và chọn ngẫu nhiên một chữ cái, khác ngẫu nhiên lấy bất kỳ bảng chữ cái nào từ az.

Cả hai phương pháp này đều không cung cấp cho tôi bất kỳ trợ giúp nào. Tôi sẽ rất hạnh phúc nếu bạn có thể giúp tôi.

Cảm ơn đã đọc nó, tôi hy vọng bạn hiểu câu hỏi và tôi đang chờ câu trả lời.

Bạn không thực sự muốn một phân phối ngẫu nhiên. Tôi chỉ ra điều này một cách rõ ràng, bởi vì những gì chúng ta coi là "ngẫu nhiên" cho thiết kế thường không phải là sự ngẫu nhiên thực sự.

Bây giờ, với ý nghĩ đó, hãy thêm một số giá trị điều chỉnh - đây là những điều bạn sẽ thích thú cho đến khi thiết kế cảm thấy "đúng".

ChooseLetter() {
    const float WordLetterProbability = 0.5f;
    if (Random.NextFloat01() < WordLetterProbability) {
        // Pick a random letter in the word
    }
    else {
        // Pick a random letter *not* in the word
    }
}

Xác suất kiểm soát khả năng một cuộc gọi nhất định tới PickLetter sẽ cung cấp cho bạn một chữ cái - ở mức 0,5, bạn sẽ nhận được một chữ cái gần như mọi lúc. Tại 0,25, một trong bốn sẽ là một chữ cái, v.v.

Điều này vẫn hơi đơn giản - bởi vì tính ngẫu nhiên là, ngẫu nhiên , bạn thực sự không có một sự đảm bảo về thời gian bạn sẽ đi giữa các chữ cái. (Về lý thuyết, bạn có thể đi mãi mãi mà không cần một chữ cái, điều đó rất khó xảy ra.) Thay vào đó, chúng ta có thể thêm một yếu tố để tăng xác suất của một chữ cái mỗi khi chúng ta không nhận được một chữ cái:

const float BaseWordLetterProbability = 0.5f;
const float WordLetterProbabilityIncrease = 0.25f;
float WordLetterProbability = BaseWordLetterProbability;
ChooseLetter() {
    if (Random.NextFloat01() < WordLetterProbability) {
        // Pick a random letter in the word
        WordLetterProbability = BaseWordLetterProbability;
    }
    else {
        // Pick a random letter *not* in the word
        WordLetterProbability += WordLetterProbabilityIncrease;
    }
}

Được rồi, vì vậy bây giờ chúng tôi không bao giờ đi quá hai chữ cái mà không có một chữ cái. (Bởi vì, sau hai lần bỏ lỡ, chúng tôi có xác suất 1.0 để nhận được một chữ cái.)

Cuối cùng, chúng ta cần xem xét cách chọn chữ cái trong một từ hoạt động. Để cung cấp cho người chơi các chữ cái họ thực sự cần, chúng tôi cần xóa các chữ cái khỏi bộ khi họ nhận được chúng.

Ví dụ: nếu từ đó là "thử nghiệm" và người chơi đã có 's', chúng tôi không muốn cung cấp cho họ 's' khác, vì họ không cần nó!

Từ đây, phần còn lại là điều chỉnh để phù hợp với thiết kế của bạn.

Bạn có thể cân nhắc xác suất của tất cả các chữ cái của bạn theo tần suất xuất hiện trong ngôn ngữ mà từ của bạn đang sử dụng. Một hướng dẫn tốt là tập hợp chữ viết nguệch ngoạc . Ví dụ, phiên bản tiếng Anh có 12 chữ E nhưng chỉ có một chữ Z và một chữ Q.

Một cách đơn giản để thực hiện điều này là bằng cách đặt tất cả các chữ cái trong một chuỗi liên tiếp với mỗi chữ cái xuất hiện thường xuyên như mong muốn và sau đó RNG của bạn lấy một chữ cái từ một vị trí ngẫu nhiên. Ví dụ mã giả:

const String letters = "AAAAAAAAABBCCDDDDEEEEEEEEEEEEFFGGGHHIIIIIIIIIJ/*...and so on...*/"

char randomLetter = letters[randomIntegerBetween(0, letters.length - 1)];

Đây là một cách để cải thiện nó bằng một tham số duy nhất k mà bạn có thể điều chỉnh.

Thay vì chỉ chọn một chữ cái ngẫu nhiên:

1. chọn một lá thư ngẫu nhiên A
2. chọn một số ngẫu nhiên X
3. nếu X > k và A không ở trong [list of remaining needed letters], hãy thử lại ở 1.

Càng nhỏ k, thư cuối cùng Asẽ càng thường xuyên thực sự cần thiết.

Để điều chỉnh thuật toán, hãy chơi với bất kỳ giá trị nào k, vd k = 0.5 . Nếu bạn thấy trò chơi quá khó, hãy thử 0.4thay vào đó, vv cho đến khi bạn tìm thấy một giá trị hợp lý. Điều này cũng trực tiếp cung cấp cho bạn một cài đặt khó khăn , ví dụ bạn có thể muốn tăng lên khi người chơi tiến lên trong trò chơi.

Một cách đơn giản để đảm bảo rằng các chữ cái được yêu cầu hiển thị trong một thời gian nhất định là sử dụng điền vào một mảng với các chữ cái trong từ và phần còn lại của bảng chữ cái (có thể lặp lại), sau đó xáo trộn ngẫu nhiên mảng (c ++ có std :: Random_shuffle trong thư viện chuẩn, nếu bạn đang sử dụng một ngôn ngữ khác thì không khó để thực hiện).

Nếu bạn muốn các chữ cái trong từ hiển thị nhanh hơn, hãy đặt nhiều bản sao của các chữ cái trong mảng.

Nếu bạn đang sử dụng C ++, bạn có thể sử dụng bản phân phối đã có sẵn http://en.cppreference.com/w/cpp/numeric/random/piecewise_constant_distribution

Nó cũng được khấu hao theo độ phức tạp thời gian liên tục tốt hơn các phương pháp ngây thơ. thí dụ:

#include <iostream>
#include <string>
#include <map>
#include <random>
#include <numeric>

int main()
{
    constexpr double containedLetterWeight = 3.0;
    constexpr int iterations = 10000;
    std::string word = "DISTRIBUTION";

    std::mt19937 rng(123);

    std::vector<double> values('Z' - 'A' + 2);
    std::iota(values.begin(), values.end(), 0.0);

    std::vector<double> weights('Z' - 'A' + 1, 1.0);
    for(const auto& c : word) weights[c - 'A'] = containedLetterWeight;

    std::piecewise_constant_distribution<> dist(values.begin(), values.end(), weights.begin());

    std::map<char, int> results;
    for(int n = 0; n < iterations; ++n)
    {
        ++results[static_cast<char>(dist(rng)) + 'A'];
    }
    for(const auto& p : results)
    {
        std::cout << p.first << ' ' << static_cast<float>(p.second) / iterations << '\n';
    }
}