Programming Challenge: Two Wizards algorithm challenge

This is such an unintuitive approach for me. I've been writing a recursive takeTurn() function that simulates the state of the game from beginning to end, making a spell choice each time, repositioning the wizards after every teleport, and returning who the winner is when they go out of bounds.

You've just bypassed that whole process using a deterministic winner-identifying algorithm. I would've never jumped to that solution and honestly I'm having trouble wrapping my head around how it works. Nowhere in your code is a single spell selected or turn simulated. I'm agog.

I've put together a JS implementation which includes your edit (changing part 2 from "every next move" to "any next move"). My results for examples 1-3 are consistent with your expected output, but I'm getting true for example 4 and I'm not sure if it's a problem with my code or your scenario. Mind taking a look?

Note that I'm using false, true, and undefined where your implementation used 1, 2, and 0 respectively.

var field	= [400,400];
var spells	= [ [9,2], [15,1], [1,4], [7,20], [3,100], [6,4], [9,0], [7,0], [8,3], [8,44] ];

function Game(field, spells){

	this.width	= field[0];
	this.height = field[1];
	this.spells = spells;
	this.maxX	= this.width - 1;
	this.maxY	= this.height - 1;
	this.map = [];
	for(i = 0; i < this.width; i++){
		this.map[i] = new Array(this.height);
	}
	
	this.validate = function(spell, coords, condition){
		let newCoords = [spell[0] + coords[0], spell[1] + coords[1]];
		if(this.width > newCoords[0] && this.height > newCoords[1]){
			if(condition === null)
				return true;
			return this.map[newCoords[0]][newCoords[1]] === condition;
		}
		return false;
	};
	
	// loop through all coordinates backwards
	for(x = this.maxX; x >= 0; x--){
		for(y = this.maxY; y >= 0; y--){
			
			// If every next move overflows from game field
			for(const spell of this.spells){
				if(this.validate(spell, [x,y], null)){
					this.map[x][y] = undefined;
					continue;
				}
				this.map[x][y] = false;
			}
			
			// Else if every next move goes into tile labeled false
			if(this.map[x][y] !== false){
				let orig = this.map[x][y];
				for(const spell of this.spells){
					if(this.validate(spell, [x,y], false)){
						this.map[x][y] = true;
						break;
					}
				}
			}
			
			// Else if every next move goes into tile labeled true
			if(this.map[x][y] === undefined){
				for(const spell of this.spells){
					if(!this.validate(spell, [x,y], true)){
						this.map[x][y] = undefined;
						continue;
					}
					this.map[x][y] = false;
				}
			}
			
		}
	}
	
	// console.table(this.map);
	this.winner = this.map[0][0];

}

console.log(new Game(field, spells).winner);

This is a great approach. Determine losing positions and back-propagate winning and losing positions from there until you reach the origin point.

The only point I think needs clarifying is what happens if none of your three conditions hold? That is, what if different next moves land on different labeled tiles? If this never occurs, it's not immediately intuitive to me as to why.

I agree with balooga... I never would have thought to do this by anything other than brute force. Thanks for posting your solution!