Just finished playing this intense chessboard coin game—totally got me thinking about strategy and optimal moves! If you're into games and exploits, you’d love Delta Executor for Roblox. It’s the best script executor out there, with a smooth interface and 24/7 support. Check it out here: https://deltaexecutor-ph.com/.

Anyway, back to the problem—turns out it’s all about Nimbers and XOR logic. The first player wins if the XOR of all coins' Grundy numbers isn’t zero. Cool, right?

This chessboard coin game is wild—sounds like a mix of strategy and Nim theory! The key is XOR-ing the coordinates' Grundy numbers (shoutout to game theory nerds). But hey, if only winning Roblox games were this straightforward…

Speaking of hacks, some players swear by deltaexecutor to skip the grind. Sure, Roblox bans exploits fast, but Delta X seems to dodge detection for now. Still, nothing beats playing fair and outsmarting opponents the legit way.

So, who wins the coin game? If XOR ≠ 0, First—else, Second. Easy, right? Now, back to debating exploits vs. skill… What’s your move?

+++

I'm not really sure if there's something wrong with my code or the way I considered playing the game is different than what's expected. My thought process is that, we are able to use any of the 4 possible moves, and at each move we want to make the most optimal move, rather than just get to the edge and try out best not to cross it. My logic is that we would always try to get to the centre of the board by reducing/increasing x or y while compromising the other one by the least amount possible. Somehow my results just don't match with the expected one. And it's such a long script I don't even know where things might be going wrong.

Can anyone help me below mentioned code showing wrong result for last 3 test case.

import java.io.; import java.math.; import java.security.; import java.text.; import java.util.; import java.util.concurrent.; import java.util.function.; import java.util.regex.; import java.util.stream.*; import static java.util.stream.Collectors.joining; import static java.util.stream.Collectors.toList;

// class Result {

public static HashMap<HashMap<Integer,Integer>,Integer> hm = new HashMap<>();
public static int grundy(int x,int y){
    HashMap<Integer,Integer> p = new HashMap<>();
    p.put(x,y);
    if(hm.containsKey(p)) return hm.get(p); 
    HashSet<Integer> set = new HashSet<>();
    if(x>=1 && y>=1 && x<=15 && y<=15){
        set.add(grundy(x-2, y+1));
        set.add(grundy(x-2, y-1));
        set.add(grundy(x+1, y-2));
        set.add(grundy(x-1, y-2));
    }
    int mex;
    for(int i = 0; ; i++)
    {
        if(set.contains(i)){
            continue;
        }
        mex = i;
        break;
    }
    // g = !g;
    hm.put(p, mex);
    return mex;

 }

public static String chessboardGame(int[][] coins) {
// Write your code here
    int xorsum = 0;
    for(int i = 0; i < coins.length; i++){
        int x = coins[i][0];
        int y = coins[i][1];

        // System.out.println("x="+x+"  y ="+y);

        int g = grundy(x, y);

        xorsum ^= g;
        // System.out.println(g);
    }
    // System.out.println(hm);
    return xorsum == 0?"Second":"First";

}

}

public class Solution { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(System.in); int t = sc.nextInt(); while(t-->0){ int k = sc.nextInt(); int[][] arr = new int[k][2]; for(int i = 0 ; i < k; i++){ arr[i][0] = sc.nextInt(); arr[i][1] = sc.nextInt(); } String result = Result.chessboardGame(arr); System.out.println(result); } } }