I'm expecting that the model will struggle once the problems start to get harder. The first few days of AOC are very trivial. To keep AoC competitive we would just need to start at a slightly higher difficulty.
It gave me a genetic algorithm:
// Define a class for representing a single city in the TSP class City { constructor(public x: number, public y: number) {}
// Calculate the distance to another city
public distanceTo(city: City): number {
const dx = this.x - city.x;
const dy = this.y - city.y;
return Math.sqrt(dx * dx + dy * dy);
}// Define a class for representing a solution to the TSP class Tour { private cities: City[]; private fitness = 0; private distance = 0;
constructor(tour?: City[]) {
if (tour) {
this.cities = tour;
} else {
this.cities = [];
}
}
// Add a city to the tour
public addCity(city: City) {
this.cities.push(city);
}
// Get the tour as an array of cities
public getTour(): City[] {
return this.cities;
}
// Get the fitness of the tour (lower is better)
public getFitness(): number {
if (this.fitness === 0) {
this.fitness = 1 / this.getDistance();
}
return this.fitness;
}
// Get the total distance of the tour
public getDistance(): number {
if (this.distance === 0) {
let tourDistance = 0;
// Loop through all cities in the tour and sum the distances
for (let i = 0; i < this.cities.length; i++) {
const fromCity = this.cities[i];
const toCity = this.cities[0];
if (i + 1 < this.cities.length) {
toCity = this.cities[i + 1];
}
tourDistance += fromCity.distanceTo(toCity);
}
this.distance = tourDistance;
}
return this.distance;
}
// Generate a random tour
public generateIndividual(): Tour {
const newTour = new Tour();
for (let i = 0; i < Tour.numberOfCities(); i++) {
newTour.addCity(Tour.getCity(i));
}
return newTour.shuffle();
}
// Shuffle the cities in the tour
public shuffle(): Tour {
const newTour = new Tour(this.cities);
const currentIndex = newTour.cities.length;
let temporaryValue;
let randomIndex;
// While there remain elements to shuffle...
while (currentIndex !== 0) {
// Pick a remaining element...
randomIndex = Math.floor(Math.random() * currentIndex);
currentIndex -= 1;
// And swap it with the current element
temporaryValue = newTour.cities[currentIndex];
newTour.cities[currentIndex] = newTour.cities[randomIndex];
newTour.cities[randomIndex] = temporaryValue;
}
return
...