Lottery Number GeneratorComplete Guide

// Full Wheel System - guarantees win if enough numbers match
function fullWheel(numbers, selectCount) {
  const combinations = [];
  
  function generateCombinations(arr, size, start = 0, current = []) {
    if (current.length === size) {
      combinations.push([...current]);
      return;
    }
    
    for (let i = start; i < arr.length; i++) {
      current.push(arr[i]);
      generateCombinations(arr, size, i + 1, current);
      current.pop();
    }
  }
  
  generateCombinations(numbers, selectCount);
  return combinations;
}

// Abbreviated Wheel - covers more numbers with fewer tickets
function abbreviatedWheel(numbers, selectCount, guarantee) {
  // Implementation depends on specific guarantee requirements
  // Example: guarantee 3-if-4 (3 matches if 4 of your numbers are drawn)
  const combinations = [];
  
  // Complex algorithm to optimize coverage
  // This is a simplified example
  const totalCombos = Math.min(50, combinations.length);
  
  return combinations.slice(0, totalCombos);
}

// Balanced number selection
function balancedSelection(min, max, count) {
  const numbers = [];
  const mid = Math.floor((min + max) / 2);
  
  // Aim for roughly equal distribution
  const lowCount = Math.floor(count / 2);
  const highCount = count - lowCount;
  
  // Select from low range
  while (numbers.filter(n => n <= mid).length < lowCount) {
    const num = Math.floor(Math.random() * (mid - min + 1)) + min;
    if (!numbers.includes(num)) numbers.push(num);
  }
  
  // Select from high range
  while (numbers.filter(n => n > mid).length < highCount) {
    const num = Math.floor(Math.random() * (max - mid)) + mid + 1;
    if (!numbers.includes(num)) numbers.push(num);
  }
  
  return numbers.sort((a, b) => a - b);
}

class LotteryGenerator {
  constructor() {
    this.history = [];
    this.statistics = {
      frequency: {},
      lastDrawn: {},
      patterns: []
    };
  }
  
  // Generate random numbers for any lottery format
  generateNumbers(config) {
    const { mainNumbers, mainRange, bonusNumbers = 0, bonusRange = 0 } = config;
    
    const main = this.selectUniqueNumbers(mainNumbers, 1, mainRange);
    const bonus = bonusNumbers > 0 ? 
      this.selectUniqueNumbers(bonusNumbers, 1, bonusRange) : [];
    
    return {
      main: main.sort((a, b) => a - b),
      bonus: bonus.sort((a, b) => a - b),
      timestamp: new Date().toISOString(),
      config
    };
  }
  
  // Cryptographically secure number selection
  selectUniqueNumbers(count, min, max) {
    const numbers = new Set();
    const range = max - min + 1;
    
    if (count > range) {
      throw new Error('Cannot select more numbers than available in range');
    }
    
    while (numbers.size < count) {
      // Use crypto.getRandomValues for security
      const array = new Uint32Array(1);
      crypto.getRandomValues(array);
      
      const num = (array[0] % range) + min;
      numbers.add(num);
    }
    
    return Array.from(numbers);
  }
  
  // Generate multiple tickets with different strategies
  generateMultipleTickets(config, count, strategy = 'random') {
    const tickets = [];
    
    for (let i = 0; i < count; i++) {
      let ticket;
      
      switch (strategy) {
        case 'balanced':
          ticket = this.generateBalancedNumbers(config);
          break;
        case 'hot':
          ticket = this.generateHotNumbers(config);
          break;
        case 'cold':
          ticket = this.generateColdNumbers(config);
          break;
        default:
          ticket = this.generateNumbers(config);
      }
      
      tickets.push(ticket);
    }
    
    return tickets;
  }
  
  // Balanced selection (mix of high/low, odd/even)
  generateBalancedNumbers(config) {
    const { mainNumbers, mainRange } = config;
    const mid = Math.floor(mainRange / 2);
    const numbers = [];
    
    // Aim for balanced distribution
    const lowCount = Math.floor(mainNumbers / 2);
    const highCount = mainNumbers - lowCount;
    const oddCount = Math.floor(mainNumbers / 2);
    
    // Select from low range
    const lowNumbers = this.selectUniqueNumbers(lowCount, 1, mid);
    // Select from high range  
    const highNumbers = this.selectUniqueNumbers(highCount, mid + 1, mainRange);
    
    numbers.push(...lowNumbers, ...highNumbers);
    
    // Ensure odd/even balance if possible
    this.balanceOddEven(numbers, oddCount, 1, mainRange);
    
    return {
      main: numbers.sort((a, b) => a - b),
      bonus: config.bonusNumbers > 0 ? 
        this.selectUniqueNumbers(config.bonusNumbers, 1, config.bonusRange) : [],
      timestamp: new Date().toISOString(),
      strategy: 'balanced',
      config
    };
  }
  
  // Statistical analysis of historical data
  analyzeHistory(drawHistory) {
    const analysis = {
      frequency: {},
      gaps: {},
      patterns: {
        consecutive: 0,
        evenOdd: { even: 0, odd: 0 },
        highLow: { high: 0, low: 0 },
        sums: []
      }
    };
    
    drawHistory.forEach((draw, index) => {
      const numbers = draw.main || draw.numbers;
      
      // Frequency analysis
      numbers.forEach(num => {
        analysis.frequency[num] = (analysis.frequency[num] || 0) + 1;
        analysis.gaps[num] = 0; // Reset gap counter
      });
      
      // Update gaps for non-drawn numbers
      for (let i = 1; i <= draw.config.mainRange; i++) {
        if (!numbers.includes(i)) {
          analysis.gaps[i] = (analysis.gaps[i] || 0) + 1;
        }
      }
      
      // Pattern analysis
      const sum = numbers.reduce((a, b) => a + b, 0);
      analysis.patterns.sums.push(sum);
      
      // Count consecutive numbers
      let consecutive = 0;
      for (let i = 0; i < numbers.length - 1; i++) {
        if (numbers[i + 1] === numbers[i] + 1) consecutive++;
      }
      if (consecutive > 0) analysis.patterns.consecutive++;
      
      // Even/odd analysis
      numbers.forEach(num => {
        if (num % 2 === 0) {
          analysis.patterns.evenOdd.even++;
        } else {
          analysis.patterns.evenOdd.odd++;
        }
      });
    });
    
    return analysis;
  }
  
  // Utility method for odd/even balancing
  balanceOddEven(numbers, targetOdd, min, max) {
    const currentOdd = numbers.filter(n => n % 2 === 1).length;
    const needMore = targetOdd - currentOdd;
    
    if (needMore > 0) {
      // Need more odd numbers
      for (let i = 0; i < needMore && numbers.length < 6; i++) {
        let num;
        do {
          num = Math.floor(Math.random() * max) + min;
        } while (numbers.includes(num) || num % 2 === 0);
        
        // Replace an even number if possible
        const evenIndex = numbers.findIndex(n => n % 2 === 0);
        if (evenIndex !== -1) {
          numbers[evenIndex] = num;
        }
      }
    }
  }
}

// Usage examples
const generator = new LotteryGenerator();

// Generate Powerball numbers
const powerballConfig = {
  mainNumbers: 5,
  mainRange: 69,
  bonusNumbers: 1,
  bonusRange: 26
};

const powerballTicket = generator.generateNumbers(powerballConfig);
// Output: Powerball numbers

// Generate multiple balanced tickets
const balancedTickets = generator.generateMultipleTickets(
  powerballConfig, 
  5, 
  'balanced'
);
// Output: Balanced ticket numbers