Generate a list of weighted random letters - flutter

Question

I'm trying to create a word game and want to present letters to a user for them to build words. Given that, I have a source list of available letters named lettersList that for now is just the 26 letters of the English alphabet.
For the user, I only want them to have say 5 letters to build a word with. To generate that list of 5 letters, I have the following:
var randomList = new List.generate(5, (_) => lettersList[Random().nextInt(lettersList.length)]).toList();
This sort of works since I don't mind duplicates, but I want certain letters to appear more than others such as vowels and the most common consonants.
So the only solution I could think of was to augment my lettersList to add more of the characters I want to show up more often (e.g., so for the letter E maybe I'll add 5 more instances of it in the letterList or add 3 instances of the letter N) and change my code to use shuffle instead.
lettersList.shuffle();
return lettersList.take(5).toList();
So even though that works, I'm just curious, is there a better or more efficient way to do this?

Answer 1

The way you have suggested (using multiples of some letters) isn't a bad idea per-se but doesn't have a lot of flexibility.
What you really want to be able to do is to have a weighted set of values for each letter, and then choose between them.
A simple way of doing this would be to just define the weights for each letter in the alphabet, i.e.
{ 'a': 1, "b": 0.8, "c": 1.2 ... }
Then, to get a random distribution, you could use random.nextDouble() * <sum of all the weights>. This would result in a number between 0 and the sum total - all you need to do is figure out which position corresponds to that. You could do that by starting at 0, and checking if each respective number's weight added to the running total is bigger than the random double.
You could then wrap this up in a class, potentially doing some initialization of defaults. You can check it out on dartpad but I've included it below as well.
This class handles the random distribution in a generic way:
import 'dart:math';
import 'package:collection/collection.dart';
class WeightedRandom<T> {
WeightedRandom(Map<T, double> allWeights)
: _totalWeight = allWeights.values.sum,
_allWeightsList = allWeights.entries.toList(growable: false);
final double _totalWeight;
final Random _random = Random.secure();
final List<MapEntry<T, double>> _allWeightsList;
T getNext() {
final weightedRandom = _random.nextDouble() * _totalWeight;
double totalSoFar = 0;
for (final entry in _allWeightsList) {
if (weightedRandom < totalSoFar + entry.value) {
return entry.key;
}
totalSoFar += entry.value;
}
return _allWeightsList.last.key;
}
}
And this one makes it letter-specific with the added bonus of setting defaults:
class RandomWeightedLetter extends WeightedRandom<String> {
static final _defaultWeights = Map.fromEntries(
List.generate(26, (ind) => MapEntry(String.fromCharCode(ind + 97), 1.0)));
RandomWeightedLetter._(Map<String, double> allWeights): super(allWeights);
factory RandomWeightedLetter(Map<String, double> specialWeights) {
for (final entry in specialWeights.entries) {
assert(entry.key.length == 1 &&
entry.key.codeUnits.first >= 97 &&
entry.key.codeUnits.first <= 122);
}
final allWeights = _defaultWeights..addAll(specialWeights);
return RandomWeightedLetter._(allWeights);
}
}
You can use it in a pretty simple way, i.e.:
void main() {
final random = RandomWeightedLetter({'f': 26});
final counts = Map.fromEntries(
List.generate(26, (ind) => MapEntry(String.fromCharCode(ind + 97), 0)));
const rounds = 100000;
for (int i = 0; i < rounds; ++i) {
final randomLetter = random.getNext();
counts[randomLetter] = counts[randomLetter]! + 1;
}
print(counts.map((key, value) => MapEntry(key, value / (rounds / random._totalWeight))));
}
(which prints out something like this, showing that the distribution works):
{a: 0.95421, b: 0.99144, c: 0.9894000000000001, d: 0.98634, e: 0.99297, f: 26.18646, g: 0.9679800000000001, h: 1.03479, i: 0.9741, j: 0.9945, k: 1.02408, l: 0.9639, m: 0.98481, n: 0.9537, o: 1.0098, p: 0.99093, q: 1.00827, r: 0.97971, s: 1.0251000000000001, t: 1.02204, u: 0.97104, v: 1.01286, w: 0.98634, x: 0.94911, y: 1.04142, z: 1.0047}
Then, to exactly what you want, you could simply to this:
final random = RandomWeightedLetter(...);
final randomList = List.generate((_) => random.next());
Note that this isn't particularly optimized - you could pre-calculate the 'buckets' and do some fancier algorithm than just iterating through each time to go from the random double to the letter, but this is probably good enough for a fairly small set of potential values. If you were going to have a ton of potential values, you'd want to do something smarter - a simple way to do it would be to calculate the max for each potential response, and then use something like a balanced tree to 'sort' the new value into it.