Ebben a lottórendszerben 10 számot húznak véletlenszerűen 1-től 49-ig. A játékosok 5 számot választanak, és a nyeremények a kihúzott számokkal való találatok száma alapján kerülnek kiosztásra.
Ez egy érdekes dinamikát hoz létre, ahol a nagyobb nyeremények rendkívül ritkák, míg a kisebb nyerések viszonylag gyakrabban előfordulnak.
A P(k) valószínűség, hogy pontosan k szám egyezik az 5-ből:
Ahol:
• C(n,k) a kombinációkat jelöli (n elemből k kiválasztásának módjai)
• 5 a játékos által választott számok száma
• 10 a kihúzott nyertes számok száma
• 49 a lehetséges számok teljes száma
P(k) = [C(5,k) × C(44,10-k)] / C(49,10)
P(3) = [C(5,3) × C(44,7)] / C(49,10)
= (10 × 38,608,020) / 8,217,822,536
≈ 386,080,200 / 8,217,822,536
≈ 0.04698 ≈ 1 a 21.28-ból
P(4) = [C(5,4) × C(44,6)] / C(49,10)
= (5 × 7,059,052) / 8,217,822,536
≈ 35,295,260 / 8,217,822,536
≈ 0.004295 ≈ 1 a 233-ból
P(5) = [C(5,5) × C(44,5)] / C(49,10)
= (1 × 1,086,008) / 8,217,822,536
≈ 1,086,008 / 8,217,822,536
≈ 0.000132 ≈ 1 a 7,566-ból
P(nyerés) = P(3) + P(4) + P(5)
≈ 0.04698 + 0.004295 + 0.000132
≈ 0.0514 ≈ 1 a 19.45-ből
Ez azt jelenti, hogy egy játékosnak körülbelül 5.14% esélye van bármilyen nyereményre.
/**
* Generates an array of unique random integers within a specified range in sorted order.
*
* Performed daily for draws with parameters of generateUniqueRandomSortedIntegers(10, 1, 49)
*
*
* @param {number} count - The number of unique integers to generate (must be positive)
* @param {number} min - The lower bound of the range (inclusive)
* @param {number} max - The upper bound of the range (inclusive)
* @returns {number[]} A sorted array of unique random integers
* @throws {Error} If the requested count exceeds the possible unique values in the range
* or if any parameter is invalid
*/
function generateUniqueRandomSortedIntegers(count, min, max) {
// Validate input parameters
if (!Number.isInteger(count) || !Number.isInteger(min) || !Number.isInteger(max)) {
throw new Error("All parameters must be integers");
}
if (count <= 0) {
throw new Error("Count must be a positive integer");
}
if (min > max) {
throw new Error("Minimum value cannot exceed maximum value");
}
const rangeSize = max - min + 1;
if (count > rangeSize) {
throw new Error(`Cannot generate ${count} unique numbers in range [${min}, ${max}]`);
}
// For small ranges relative to count, use Fisher-Yates shuffle algorithm
if (count > rangeSize / 2) {
const allNumbers = Array.from({length: rangeSize}, (_, i) => min + i);
// Fisher-Yates shuffle
for (let i = allNumbers.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
}
return allNumbers.slice(0, count).sort((a, b) => a - b);
}
// For larger ranges relative to count, use Set approach
const uniqueNumbers = new Set();
while (uniqueNumbers.size < count) {
const randomNumber = Math.floor(Math.random() * rangeSize) + min;
uniqueNumbers.add(randomNumber);
}
return Array.from(uniqueNumbers).sort((a, b) => a - b);
}