The Snake vs the Wind | Editorial by aksingh007

This problem will be solved by DFS and recursion.The main idea of the question is to convert its description into some rules based on the direction of the wind 
and then to implement these rules by using recursion.
On the basis of direction of wind flow we are required to make following decisions:
1. When the wind is pointing to North:
        a. if there is another position above and if it hasn't been visited before, move to it
        b. if there is another position to the right and if it hasn't been visited before, move to it
        c. if there is another position to the left and if it hasn't been visited before, move to it
        d. if there is another position below and if it hasn't been visited before, move to it
2. When the wind is pointing to South:
        a. if there is another position below and if it hasn't been visited before, move to it
        b. if there is another position to the right and if it hasn't been visited before, move to it
        c. if there is another position to the left and if it hasn't been visited before, move to it
        d. if there is another position above and if it hasn't been visited before, move to it
3. When the wind is pointing to East:
        a. if there is another position to the right and if it hasn't been visited before, move to it
        b. if there is another position above and if it hasn't been visited before, move to it
        c. if there is another position below and if it hasn't been visited before, move to it
        d. if there is another position to the left and if it hasn't been visited before, move to it
4. When the wind is pointing to West:
        a. if there is another position to the left and if it hasn't been visited before, move to it
        b. if there is another position above and if it hasn't been visited before, move to it
        c. if there is another position below and if it hasn't been visited before, move to it
        d. if there is another position to the right and if it hasn't been visited before, move to it

```

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    public static void tvsN(int n,int x,int y,int grid[][],boolean visited[][],int val){
        if(x<0||y<0 || x>=n||y>=n)
            return;
        if(visited[x][y])
            return;
        visited[x][y]=true;
        grid[x][y]=val;
        tvsN(n,x-1,y,grid,visited,val+1);
        tvsN(n,x,y+1,grid,visited,val+1);
        tvsN(n,x,y-1,grid,visited,val+1);
        tvsN(n,x+1,y,grid,visited,val+1);
     }
    public static void tvsE(int n,int x,int y,int grid[][],boolean visited[][],int val){
        if(x<0||y<0 || x>=n||y>=n)
            return;
        if(visited[x][y])
            return;
        visited[x][y]=true;
        grid[x][y]=val;
        tvsE(n,x,y+1,grid,visited,val+1);
        tvsE(n,x-1,y,grid,visited,val+1);
        tvsE(n,x+1,y,grid,visited,val+1);
        tvsE(n,x,y-1,grid,visited,val+1);
     }
    public static void tvsW(int n,int x,int y,int grid[][],boolean visited[][],int val){
        if(x<0||y<0 || x>=n||y>=n)
            return;
        if(visited[x][y])
            return;
        visited[x][y]=true;
        grid[x][y]=val;
        tvsW(n,x,y-1,grid,visited,val+1);
        tvsW(n,x-1,y,grid,visited,val+1);
        tvsW(n,x+1,y,grid,visited,val+1);
        tvsW(n,x,y+1,grid,visited,val+1);
    }
    public static void tvsS(int n,int x,int y,int grid[][],boolean visited[][],int val){
        if(x<0||y<0 || x>=n||y>=n)
            return;
        if(visited[x][y])
            return;
        visited[x][y]=true;
        grid[x][y]=val;
        tvsS(n,x+1,y,grid,visited,val+1);
        tvsS(n,x,y+1,grid,visited,val+1);
        tvsS(n,x,y-1,grid,visited,val+1);
        tvsS(n,x-1,y,grid,visited,val+1);
     }
    
    public static void solve(int n,char d,int x,int y,int grid[][]){
        boolean visited[][]=new boolean[n][n];
        if(d=='n')
          tvsN(n,x,y,grid,visited,1);
        else
            if(d=='e')
               tvsE(n,x,y,grid,visited,1);
        else
            if(d=='s')
               tvsS(n,x,y,grid,visited,1);
        else
            //if(d=='n')
               tvsW(n,x,y,grid,visited,1);
            
    }
    
    public static void print(int grid[][],int n){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++)
                System.out.print(grid[i][j]+" ");
            System.out.println();
        }
     }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        char d = in.next().charAt(0);
        int x = in.nextInt();
        int y = in.nextInt();
        // Write Your Code Here
        int grid[][]=new int[n][n];
        solve(n,d,x,y,grid);
        print(grid,n);
        in.close();
    }
}

```

The Snake vs the Wind | Editorial by aksingh007

Download submission

All caught up!

View submission

Is your resume even shortlisted?