• Home
  • Top Posts
  • Code Solutions
  • How to
  • News
  • Trending
  • Anime
  • Health
  • Education
Friday, January 27, 2023
  • Login
Zeroplusfour
No Result
View All Result
  • Home
  • Top Posts
  • Code Solutions
  • How to
  • News
  • Trending
  • Anime
  • Health
  • Education
  • Home
  • Top Posts
  • Code Solutions
  • How to
  • News
  • Trending
  • Anime
  • Health
  • Education
No Result
View All Result
Zeroplusfour
No Result
View All Result
Home Code Solutions Hackerrank Algorithms

Simplified Chess Engine II – HackerRank Solution

Simplified Chess Engine II - HackerRank Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.

admin by admin
August 24, 2022
Reading Time: 1 min read
0
15 Days to learn SQL Hard SQL(Advanced)-Solution

15 Days to learn SQL Hard SQL(Advanced)-Solution alt text

Spread the love

Table of Contents

  • Simplified Chess Engine II – HackerRank Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.
  • Solutions of Algorithms Data Structures Hard HackerRank:
    • Here are all the Solutions of Hard , Advanced , Expert Algorithms of Data Structure of Hacker Rank , Leave a comment for similar posts
  • C++ replace HackerRank Solution
  • Java rep HackerRank Solution
  • Python 3 rep HackerRank Solution
  • Python 2 rep HackerRank Solution
  • C rep HackerRank Solution
    • Warmup Implementation Strings Sorting Search Graph Theory Greedy Dynamic Programming Constructive Algorithms Bit Manipulation Recursion Game Theory NP Complete Debugging
    • Leave a comment below
      • Related posts:

Simplified Chess Engine II – HackerRank Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.

Solutions of Algorithms Data Structures Hard HackerRank:

Here are all the Solutions of Hard , Advanced , Expert Algorithms of Data Structure of Hacker Rank , Leave a comment for similar posts

C++ replace HackerRank Solution


Copy Code Copied Use a different Browser

#include <cmath>
#include <cstdio>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <utility>
using namespace std;

#define CLEAN_BOARD "................"
#define Z(x, i, j) x[(i)+(j)*4]

void debug(const string B) {
    cout << B[0] << B[1] << B[2] << B[3] << endl;
    cout << B[4] << B[5] << B[6] << B[7] << endl;
    cout << B[8] << B[9] << B[10]<< B[11] << endl;
    cout << B[12]<< B[13]<< B[14]<< B[15] << endl;
}

bool has_figure(const string &b, char c) {
    return b.find(c) != std::string::npos;
}

vector<string> knight_moves(const string &B, int color, int i, int j) {
    vector<string> res;
    int sign = color == 1 ? 0 : 32;
    
    if (i+2 < 4 && j+1 < 4)
        if ((Z(B,i+2,j+1)&32) != sign || Z(B,i+2,j+1) == '.') { string M(B); Z(M,i+2,j+1) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i+2 < 4 && j-1 >= 0)
        if ((Z(B,i+2,j-1)&32) != sign || Z(B,i+2,j-1) == '.') { string M(B); Z(M,i+2,j-1) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i+1 < 4 && j+2 < 4)
        if ((Z(B,i+1,j+2)&32) != sign || Z(B,i+1,j+2) == '.') { string M(B); Z(M,i+1,j+2) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i+1 < 4 && j-2 >= 0)
        if ((Z(B,i+1,j-2)&32) != sign || Z(B,i+1,j-2) == '.') { string M(B); Z(M,i+1,j-2) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i-2 >= 0 && j+1 < 4)
        if ((Z(B,i-2,j+1)&32) != sign || Z(B,i-2,j+1) == '.') { string M(B); Z(M,i-2,j+1) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i-2 >= 0 && j-1 >= 0)
        if ((Z(B,i-2,j-1)&32) != sign || Z(B,i-2,j-1) == '.') { string M(B); Z(M,i-2,j-1) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i-1 >= 0 && j+2 < 4)
        if ((Z(B,i-1,j+2)&32) != sign || Z(B,i-1,j+2) == '.') { string M(B); Z(M,i-1,j+2) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    if (i-1 >= 0 && j-2 >= 0)
        if ((Z(B,i-1,j-2)&32) != sign || Z(B,i-1,j-2) == '.') { string M(B); Z(M,i-1,j-2) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M); }
    return res;
}

vector<string> bishop_moves(const string &B, int color, int i, int j) {
    vector<string> res;
    int sign = color == 1 ? 0 : 32;
    
    int ii=i-1, jj=j-1;
    while (ii>=0 && jj>=0) {
        if (Z(B,ii,jj) == '.') {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,jj)&32) != sign) {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        --ii;--jj;
    }
    
    ii=i+1, jj=j-1;
    while (ii<4 && jj>=0) {
        if (Z(B,ii,jj) == '.') {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,jj)&32) != sign) {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        ++ii;--jj;
    }
    
    ii=i+1, jj=j+1;
    while (ii<4 && jj<4) {
        if (Z(B,ii,jj) == '.') {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,jj)&32) != sign) {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        ++ii;++jj;
    }
    
    ii=i-1, jj=j+1;
    while (ii>=0 && jj<4) {
        if (Z(B,ii,jj) == '.') {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,jj)&32) != sign) {
            string M(B); Z(M,ii,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        --ii;++jj;
    }
    
    return res;
}

vector<string> rook_moves(const string &B, int color, int i, int j) {
    vector<string> res;
    int sign = color == 1 ? 0 : 32;
    
    int ii=i-1;
    while (ii>=0) {
        if (Z(B,ii,j) == '.') {
            string M(B); Z(M,ii,j) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,j)&32) != sign) {
            string M(B); Z(M,ii,j) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        --ii;
    }

    ii=i+1;
    while (ii<4) {
        if (Z(B,ii,j) == '.') {
            string M(B); Z(M,ii,j) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,ii,j)&32) != sign) {
            string M(B); Z(M,ii,j) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        ++ii;
    }
    
    int jj=j-1;
    while (jj>=0) {
        if (Z(B,i,jj) == '.') {
            string M(B); Z(M,i,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,i,jj)&32) != sign) {
            string M(B); Z(M,i,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        --jj;
    }
    
    jj=j+1;
    while (jj<4) {
        if (Z(B,i,jj) == '.') {
            string M(B); Z(M,i,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
        }
        else if ((Z(B,i,jj)&32) != sign) {
            string M(B); Z(M,i,jj) = Z(M,i,j); Z(M,i,j) = '.'; res.push_back(M);
            break;
        }
        else { break; }
        ++jj;
    }
    
    return res;
}

vector<string> pawn_moves(const string &B, int color, int i, int j) {
    vector<string> res;

    if (color == 1) {
        if (Z(B,i,j+1) == '.') {
            string M(B); Z(M,i,j) = '.';
            if (j == 2) {
                Z(M,i,j+1) = 'B'; res.push_back(M);
                Z(M,i,j+1) = 'R'; res.push_back(M);
                Z(M,i,j+1) = 'N'; res.push_back(M);
            }
            else {
                Z(M,i,j+1) = 'P'; res.push_back(M);
            }            
        }
        if (i!=3 && (Z(B,i+1,j+1) == 'q' || Z(B,i+1,j+1) == 'b' || Z(B,i+1,j+1) == 'r' || Z(B,i+1,j+1) == 'n' || Z(B,i+1,j+1) == 'p')) {
            string M(B); Z(M,i,j) = '.';
            if (j == 2) {
                Z(M,i+1,j+1) = 'B'; res.push_back(M);
                Z(M,i+1,j+1) = 'R'; res.push_back(M);
                Z(M,i+1,j+1) = 'N'; res.push_back(M);
            }
            else {
                Z(M,i+1,j+1) = 'P'; res.push_back(M);
            }            
        }
        if (i!=0 && (Z(B,i-1,j+1) == 'q' || Z(B,i-1,j+1) == 'b' || Z(B,i-1,j+1) == 'r' || Z(B,i-1,j+1) == 'n' || Z(B,i-1,j+1) == 'p')) {
            string M(B); Z(M,i,j) = '.';
            if (j == 2) {
                Z(M,i-1,j+1) = 'B'; res.push_back(M);
                Z(M,i-1,j+1) = 'R'; res.push_back(M);
                Z(M,i-1,j+1) = 'N'; res.push_back(M);
            }
            else {
                Z(M,i-1,j+1) = 'P'; res.push_back(M);
            }            
        }
    }
    else {
        if (Z(B,i,j-1) == '.') {
            string M(B); Z(M,i,j) = '.';
            if (j == 1) {
                Z(M,i,j-1) = 'b'; res.push_back(M);
                Z(M,i,j-1) = 'r'; res.push_back(M);
                Z(M,i,j-1) = 'n'; res.push_back(M);
            }
            else {
                Z(M,i,j-1) = 'p'; res.push_back(M);
            }            
        }
        if (i!=3 && (Z(B,i+1,j-1) == 'Q' || Z(B,i+1,j-1) == 'B' || Z(B,i+1,j-1) == 'R' || Z(B,i+1,j-1) == 'N' || Z(B,i+1,j-1) == 'P')) {
            string M(B); Z(M,i,j) = '.';
            if (j == 1) {
                Z(M,i+1,j-1) = 'b'; res.push_back(M);
                Z(M,i+1,j-1) = 'r'; res.push_back(M);
                Z(M,i+1,j-1) = 'n'; res.push_back(M);
            }
            else {
                Z(M,i+1,j-1) = 'p'; res.push_back(M);
            }            
        }
        if (i!=0 && (Z(B,i-1,j-1) == 'Q' || Z(B,i-1,j-1) == 'B' || Z(B,i-1,j-1) == 'R' || Z(B,i-1,j-1) == 'N' || Z(B,i-1,j-1) == 'P')) {
            string M(B); Z(M,i,j) = '.';
            if (j == 1) {
                Z(M,i-1,j-1) = 'b'; res.push_back(M);
                Z(M,i-1,j-1) = 'r'; res.push_back(M);
                Z(M,i-1,j-1) = 'n'; res.push_back(M);
            }
            else {
                Z(M,i-1,j-1) = 'p'; res.push_back(M);
            }            
        }
    }
    
    return res;
}

vector<string> queen_moves(const string &B, int color, int i, int j) {
    vector<string> res;
    
    vector<string> A1 = bishop_moves(B, color, i, j);
    vector<string> A2 = rook_moves(B, color, i, j);
    
    res.insert(res.end(), A1.begin(), A1.end());
    res.insert(res.end(), A2.begin(), A2.end());
    
    return res;
}

int moves_to_win(const string &B, int depth, int max_depth) {
    if (depth >= max_depth) return 1000000;

    vector<string> moves;
    for(int j=0; j<4; ++j) {
        for(int i=0; i<4; ++i) {
            switch(Z(B, i, j)) {
                case 'Q':
                {
                    vector<string> Q = queen_moves(B, 1, i, j);
                    moves.insert(moves.end(), Q.begin(), Q.end());
                    break;
                }
                case 'N':
                {
                    vector<string> N = knight_moves(B, 1, i, j);
                    moves.insert(moves.end(), N.begin(), N.end());
                    break;
                }
                case 'B':
                {
                    vector<string> Bi = bishop_moves(B, 1, i, j);
                    moves.insert(moves.end(), Bi.begin(), Bi.end());
                    break;
                }
                case 'R':
                {
                    vector<string> R = rook_moves(B, 1, i, j);
                    moves.insert(moves.end(), R.begin(), R.end());
                    break;
                }
                case 'P':
                {
                    vector<string> P = pawn_moves(B, 1, i, j);
                    moves.insert(moves.end(), P.begin(), P.end());
                    break;
                }
            }
        }
    }
    
    int ans = 1000000;
    vector<string> good_moves;
    
    for(string m: moves)
        if (!has_figure(m, 'q'))
            return depth+1;
        
    if (depth+2 > max_depth)
        return ans;
        
    for(string m: moves) {
        vector<string> op_moves;
        for(int j=0; j<4; ++j) {
            for(int i=0; i<4; ++i) {
                switch(Z(m, i, j)) {
                    case 'q':
                    {
                        vector<string> Q = queen_moves(m, 2, i, j);
                        op_moves.insert(op_moves.end(), Q.begin(), Q.end());
                        break;
                    }
                    case 'n':
                    {
                        vector<string> N = knight_moves(m, 2, i, j);
                        op_moves.insert(op_moves.end(), N.begin(), N.end());
                        break;
                    }
                    case 'b':
                    {
                        vector<string> Bi = bishop_moves(m, 2, i, j);
                        op_moves.insert(op_moves.end(), Bi.begin(), Bi.end());
                        break;
                    }
                    case 'r':
                    {
                        vector<string> R = rook_moves(m, 2, i, j);
                        op_moves.insert(op_moves.end(), R.begin(), R.end());
                        break;
                    }
                    case 'p':
                    {
                        vector<string> P = pawn_moves(m, 2, i, j);
                        op_moves.insert(op_moves.end(), P.begin(), P.end());
                        break;
                    }
                }
            }
        }
        
        bool is_good = true;
        for(auto o: op_moves) {
            if (!has_figure(o, 'Q')) {
                is_good = false;
                break;
            }
        }
        
        if (is_good) {
            int ans_next = 0;
            for(auto o: op_moves) {
                ans_next = max(ans_next, moves_to_win(o, depth+2, max_depth));
                if (ans_next > max_depth) break;
            }
            ans = min(ans, ans_next);
        }
    }

    return ans;
}

int main() {
    int T; cin >> T;
    for(int t=0; t<T; ++t) {
        string B(CLEAN_BOARD);
        
        int w,b,m; cin >> w >> b >> m;
        
        for(int i=0; i<w; ++i) {
            char f, col; cin >> f >> col;
            int row; cin >> row;
            B[col-'A' + (row-1)*4] = f;
        }
        for(int i=0; i<b; ++i) {
            char f, col; cin >> f >> col;
            int row; cin >> row;
            B[col-'A' + (row-1)*4] = f + ('a' - 'A');
        }

        cout << (moves_to_win(B, 0, m%2==0 ? m-1 : m) <= m ? "YES" : "NO") << endl;
    }
    return 0;
}

Java rep HackerRank Solution


Copy Code Copied Use a different Browser

 

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

public class Solution {
    static class Piece {
        public char type;
        public boolean isWhite;

        public Piece (char type, boolean isWhite) {
            this.type = type;
            this.isWhite = isWhite;
        }
        
        public Piece (Piece p) {
            this.type = p.type;
            this.isWhite = p.isWhite;
        }
    }
    
    static class Board {
        public Piece[][] pieces = new Piece[4][4];
        
        public Board(ArrayList<String> w, ArrayList<String> b) {
            for (String p : w) {
                String[] p3 = p.split(" ");
                char type = p3[0].charAt(0);
                int x = p3[1].charAt(0)-'A';
                int y = p3[2].charAt(0)-'1';
                pieces[x][y] = new Piece(type, true);
            }
            for (String p : b) {
                String[] p3 = p.split(" ");
                char type = p3[0].charAt(0);
                int x = p3[1].charAt(0)-'A';
                int y = p3[2].charAt(0)-'1';
                pieces[x][y] = new Piece(type, false);
            }
        }
        
        public Board(Board b) {
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (b.pieces[i][j] != null)
                        this.pieces[i][j] = new Piece(b.pieces[i][j]);
                }
            }
        }
        
        public ArrayList<Board> legalMoves(boolean whiteToMove) {
            ArrayList<Board> moves = new ArrayList<Board>();
            for (int a = 0; a < 4; a++) {
                for (int b = 0; b < 4; b++) {
                    if (pieces[a][b] != null && pieces[a][b].isWhite == whiteToMove) {
                        if (pieces[a][b].type == 'P') {
                            int d = whiteToMove?b+1:b-1;
                            if (pieces[a][d] == null) {
                                if (d==0||d==3) {
                                    Board newBoard = new Board(this);
                                    newBoard.pieces[a][d] = newBoard.pieces[a][b];
                                    newBoard.pieces[a][b] = null;
                                    newBoard.pieces[a][d].type = 'R';
                                    moves.add(newBoard);
                                    newBoard = new Board(this);
                                    newBoard.pieces[a][d] = newBoard.pieces[a][b];
                                    newBoard.pieces[a][b] = null;
                                    newBoard.pieces[a][d].type = 'B';
                                    moves.add(newBoard);
                                    newBoard = new Board(this);
                                    newBoard.pieces[a][d] = newBoard.pieces[a][b];
                                    newBoard.pieces[a][b] = null;
                                    newBoard.pieces[a][d].type = 'N';
                                    moves.add(newBoard);
                                }
                                else {
                                    Board newBoard = new Board(this);
                                    newBoard.pieces[a][d] = newBoard.pieces[a][b];
                                    newBoard.pieces[a][b] = null;
                                    moves.add(newBoard);
                                }
                            }
                            for (int c = a-1; c <= a+1; c+=2) {
                                if (c>=0&&c<4) {
                                    if (pieces[c][d] != null && pieces[c][d].isWhite != whiteToMove) {
                                        if (d==0||d==3) {
                                            Board newBoard = new Board(this);
                                            newBoard.pieces[c][d] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            newBoard.pieces[c][d].type = 'R';
                                            moves.add(newBoard);
                                            newBoard = new Board(this);
                                            newBoard.pieces[c][d] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            newBoard.pieces[c][d].type = 'B';
                                            moves.add(newBoard);
                                            newBoard = new Board(this);
                                            newBoard.pieces[c][d] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            newBoard.pieces[c][d].type = 'N';
                                            moves.add(newBoard);
                                        }
                                        else {
                                            Board newBoard = new Board(this);
                                            newBoard.pieces[c][d] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            moves.add(newBoard);
                                        }
                                    }
                                }
                            }
                        }
                        if (pieces[a][b].type == 'N') {
                            for (int c = -2; c <= 2; c+=4) {
                                for (int d = -1; d <= 1; d+=2) {
                                    int e = a+c;
                                    int f = b+d;
                                    int g = a+d;
                                    int h = b+c;
                                    if (e >= 0 && e < 4 && f >= 0 && f < 4) {
                                        if (pieces[e][f] == null || pieces[e][f].isWhite != whiteToMove) {
                                            Board newBoard = new Board(this);
                                            newBoard.pieces[e][f] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            moves.add(newBoard);
                                        }
                                    }
                                    if (g >= 0 && g < 4 && h >= 0 && h < 4) {
                                        if (pieces[g][h] == null || pieces[g][h].isWhite != whiteToMove) {
                                            Board newBoard = new Board(this);
                                            newBoard.pieces[g][h] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            moves.add(newBoard);
                                        }
                                    }
                                }
                            }
                        }
                        if (pieces[a][b].type == 'R' || pieces[a][b].type == 'Q') {
                            for (int c = -1; c <= 1; c += 2) {
                                for (int d = a+c; d >= 0 && d < 4; d += c) {
                                    if (pieces[d][b] == null || pieces[d][b].isWhite != whiteToMove) {
                                        Board newBoard = new Board(this);
                                        newBoard.pieces[d][b] = newBoard.pieces[a][b];
                                        newBoard.pieces[a][b] = null;
                                        moves.add(newBoard);
                                    }
                                    if (pieces[d][b] != null)
                                        break;
                                }
                                for (int d = b+c; d >= 0 && d < 4; d += c) {
                                    if (pieces[a][d] == null || pieces[a][d].isWhite != whiteToMove) {
                                        Board newBoard = new Board(this);
                                        newBoard.pieces[a][d] = newBoard.pieces[a][b];
                                        newBoard.pieces[a][b] = null;
                                        moves.add(newBoard);
                                    }
                                    if (pieces[a][d] != null)
                                        break;
                                }
                            }
                        }
                        if (pieces[a][b].type == 'B' || pieces[a][b].type == 'Q') {
                            for (int c = -1; c <= 1; c += 2) {
                                for (int d = -1; d <= 1; d += 2) {
                                    for (int e = 1; a+e*c >= 0 && a+e*c < 4 && b+e*d >= 0 && b+e*d < 4; e++) {
                                        int f = a+e*c;
                                        int g = b+e*d;
                                        
                                        if (pieces[f][g] == null || pieces[f][g].isWhite != whiteToMove) {
                                            Board newBoard = new Board(this);
                                            newBoard.pieces[f][g] = newBoard.pieces[a][b];
                                            newBoard.pieces[a][b] = null;
                                            moves.add(newBoard);
                                        }
                                        if (pieces[f][g] != null)
                                            break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return moves;
        }
        
        public boolean doesQueenExist(boolean whiteQueen) {
            for (int a = 0; a < 4; a++) {
                for (int b = 0; b < 4; b++) {
                    if (pieces[a][b] != null && pieces[a][b].type == 'Q' && pieces[a][b].isWhite == whiteQueen)
                        return true;
                }
            }
            return false;
        }
        
        public boolean canCaptureQueen(boolean whiteToMove) {
            ArrayList<Board> moves = legalMoves(whiteToMove);
            for (Board b : moves) {
                if (!b.doesQueenExist(!whiteToMove))
                    return true;
            }
            return false;
        }
        
        public boolean canReachGoalWhite(int rem) {
            if (canCaptureQueen(true))
                return true;
            if (rem==1)
                return false;
            ArrayList<Board> moves = legalMoves(true);
            for (Board b : moves) {
                if (!b.canStopGoalBlack(rem))
                    return true;
            }
            return false;
        }
        
        public boolean canStopGoalBlack(int rem) {
            if (canCaptureQueen(false))
                return true;
            ArrayList<Board> moves = legalMoves(false);
            for (Board b : moves) {
                if (!b.canReachGoalWhite(rem-1))
                    return true;
            }
            return false;
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int g = sc.nextInt();
        for (int z = 0; z < g; z++) {
            int w = sc.nextInt();
            int b = sc.nextInt();
            int m = (sc.nextInt()+1)/2;
            ArrayList<String> wl = new ArrayList<String>();
            ArrayList<String> bl = new ArrayList<String>();
            sc.nextLine();
            for (int i = 0; i < w; i++) {
                wl.add(sc.nextLine());
            }
            for (int i = 0; i < b; i++) {
                bl.add(sc.nextLine());
            }
            Board start = new Board(wl, bl);
            System.out.println(start.canReachGoalWhite(m)?"YES":"NO");
        }
    }
}



Python 3 rep HackerRank Solution


Copy Code Copied Use a different Browser

# coding: utf-8

from __future__ import print_function, unicode_literals


class Piece(object):

    def __init__(self, color, ptype, row, col):
        self.color = color
        self.ptype = ptype
        self.row = row
        self.col = col
        self.captured = False

    def valid_moves(self, board):
        pass

    def can_move_to(self, r, c):
        if r == self.row and c == self.col:
            return False

        if r < 0 or r > 3:
            return False
        if c < 0 or c > 3:
            return False

        if board.mat[r][c] is None:
            return True
        elif board.mat[r][c].color != self.color:
            return True

        return False

    def _straight_moves(self, board):
        possible = []
        # straight up
        for row in range(1, 4):
            r, c = self.row - row, self.col
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight down
        for row in range(1, 4):
            r, c = self.row + row, self.col
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight left
        for col in range(1, 4):
            r, c = self.row, self.col - col
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight right
        for col in range(1, 4):
            r, c = self.row, self.col + col
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        return possible

    def _diagonal_moves(self, board):
        possible = []
        # straight left up
        for rc in range(1, 4):
            r, c = self.row - rc, self.col - rc
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight left down
        for rc in range(1, 4):
            r, c = self.row + rc, self.col - rc
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight right up
        for rc in range(1, 4):
            r, c = self.row - rc, self.col + rc
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        # straight right down
        for rc in range(1, 4):
            r, c = self.row + rc, self.col + rc
            if self.can_move_to(r, c):
                possible.append((r, c))
            if not board.is_open(r, c):
                break

        return possible


class Rook(Piece):

    def valid_moves(self, board):
        possible = self._straight_moves(board)
        return possible


class Queen(Piece):

    def valid_moves(self, board):
        possible = self._straight_moves(board) + self._diagonal_moves(board)
        return possible


class Knight(Piece):

    def valid_moves(self, board):
        r, c = self.row, self.col
        possible = [
            (r - 2, c - 1), (r - 2, c + 1),
            (r - 1, c + 2), (r - 1, c - 2),
            (r + 1, c + 2), (r + 1, c - 2),
            (r + 2, c - 1), (r + 2, c + 1),
        ]
        return [(rw, cl) for rw, cl in possible if self.can_move_to(rw, cl)]


class Bishop(Piece):

    def valid_moves(self, board):
        possible = self._diagonal_moves(board)
        return possible


type_dict = {
    "B": Bishop,
    "R": Rook,
    "Q": Queen,
    "N": Knight,
}


class Pawn(Piece):

    def valid_moves(self, board):
        if self.ptype != "P":
            return type_dict[self.ptype].valid_moves(self, board)

        r, c = self.row, self.col
        if self.color == "B":
            possible = [
                (r - 1, c), (r - 1, c - 1), (r - 1, c + 1),
            ]
        else:
            possible = [
                (r + 1, c), (r + 1, c - 1), (r + 1, c + 1),
            ]
        v = [(rw, cl) for rw, cl in possible if self.can_move_to(rw, cl)]
        return v

    def can_move_to(self, r, c):
        if self.ptype != "P":
            return type_dict[self.ptype].can_move_to(self, r, c)

        if r == self.row and c == self.col:
            return False

        if r < 0 or r > 3:
            return False
        if c < 0 or c > 3:
            return False

        if board.mat[r][c] is None and c == self.col:
            return True
        elif board.mat[r][c] is not None and board.mat[r][c].color != self.color and c != self.col:
            return True

        return False


class Board(object):

    def __init__(self):
        self.mat = [[None for i in range(4)] for u in range(4)]
        self.white = []
        self.black = []

    def add_piece(self, color, ptype, row, col):
        if ptype == "Q":
            piece = Queen(color, ptype, row, col)
        elif ptype == "N":
            piece = Knight(color, ptype, row, col)
        elif ptype == "B":
            piece = Bishop(color, ptype, row, col)
        elif ptype == "R":
            piece = Rook(color, ptype, row, col)
        elif ptype == "P":
            piece = Pawn(color, ptype, row, col)
        else:
            raise Exception("Invalid type")

        self.mat[row][col] = piece
        if color == "W":
            self.white.append(piece)
        elif color == "B":
            self.black.append(piece)

    def move_to(self, piece, row, col):
        self.mat[piece.row][piece.col] = None
        if self.mat[row][col] is not None:
            captured = self.mat[row][col]
            captured.captured = True
        self.mat[row][col] = piece

        piece.row = row
        piece.col = col
        if piece.ptype == "P":
            # promotion
            if piece.color == "W" and piece.row == 3:
                return True
            elif piece.color == "B" and piece.row == 0:
                return True

        return False

    def undo_move(self, captured, piece, prev_r, prev_c, was_pawn):
        self.move_to(piece, prev_r, prev_c)
        if was_pawn:
            piece.ptype = "P"
        if captured:
            cr, cc = captured.row, captured.col
            self.mat[cr][cc] = captured
            captured.captured = False

    def is_open(self, r, c):
        if r < 0 or r > 3:
            return False
        if c < 0 or c > 3:
            return False
        if self.mat[r][c] is None:
            return True
        return False

    def white_can_win(self, turns_left):
        if turns_left <= 0:
            return False

        white_pieces = self.white

        q = []
        for piece in white_pieces:
            if piece.captured is True:
                continue

            valid_moves = piece.valid_moves(self)
            for r, c in valid_moves:
                captured = self.mat[r][c]
                if captured is not None and captured.ptype == "Q":
                    return True

                q.insert(0, (piece, r, c))

        for piece, r, c in q:
            prev_r, prev_c = piece.row, piece.col
            captured = self.mat[r][c]
            was_pawn = self.move_to(piece, r, c)

            ptypes = [piece.ptype]
            before = piece
            if was_pawn:
                ptypes = ["B", "R", "N"]
            for ptype in ptypes:
                piece.ptype = ptype

                # if for all follow-up opponent moves, we can find a winning move within the limit, return True
                if self.black_cannot_avoid_loss(turns_left - 1):
                    self.undo_move(captured, piece, prev_r, prev_c, was_pawn)
                    return True

            self.undo_move(captured, piece, prev_r, prev_c, was_pawn)

        return False

    def black_cannot_avoid_loss(self, turns_left):
        if turns_left <= 0:
            return False

        black_pieces = self.black

        for piece in black_pieces:
            if piece.captured is True:
                continue

            valid_moves = piece.valid_moves(self)
            for r, c in valid_moves:
                prev_r, prev_c = piece.row, piece.col
                captured = self.mat[r][c]

                if captured is not None and captured.ptype == "Q":
                    return False

                was_pawn = self.move_to(piece, r, c)
                ptypes = [piece.ptype]
                before = piece
                if was_pawn:
                    ptypes = ["B", "R", "N"]
                for ptype in ptypes:
                    piece.ptype = ptype

                    if not self.white_can_win(turns_left - 1):
                        self.undo_move(captured, piece, prev_r, prev_c, was_pawn)
                        return False

                self.undo_move(captured, piece, prev_r, prev_c, was_pawn)

        return True

    def __repr__(self):
        s = []

        for i, row in enumerate(self.mat[::-1]):
            s.append("{} ".format(4 - i))
            for col in row:
                if col is None or col.captured is True:
                    s.append(".")
                elif col.color == "W":
                    s.append(col.ptype.upper())
                elif col.color == "B":
                    s.append(col.ptype.lower())
            s.append("\n")
        s.append("  ABCD")
        return "".join(s)

if __name__ == '__main__':
    games = int(input())
    for g in range(games):
        board = Board()

        cols = "ABCD"

        w, b, m = map(int, input().split(" "))
        for i in range(w):
            ptype, col, row = input().split(" ")
            col = cols.index(col)
            row = int(row) - 1
            board.add_piece("W", ptype, row, col)

        for i in range(b):
            ptype, col, row = input().split(" ")
            col = cols.index(col)
            row = int(row) - 1
            board.add_piece("B", ptype, row, col)

        print("YES" if board.white_can_win(m) else "NO")



Python 2 rep HackerRank Solution


Copy Code Copied Use a different Browser

BLACK=2
WHITE=1
OTHER=[0,2,1] # index table to find other player id quickly
DEBUG=0

def promote(x,y):
  return set(
    [('R',x,y),
    ('B',x,y),
    ('N',x,y),
    ])
 
# Queen, kNight, Rook, Bishop, Pawn
def amoves(t,c,x,y,board,pawn_capture=False): # available moves to type, color, coordinates
  movez=set()
  if t == 'P':
    if c==WHITE and y<3:        
      if not pawn_capture and board[x][y+1] is None: # WHITE UP
          if y==2: # Promotion
            movez.update(promote(x,3))
          else:
            movez.add((t,x,y+1))
      if x>0: # WHITE UP LEFT if it can capture a piece
        if board[x-1][y+1] and (pawn_capture or board[x-1][y+1][1]==OTHER[c]):
          if y==2: # Promotion
            movez.update(promote(x-1,3))
          else:
            movez.add((t,x-1,y+1))
      if x<3: # WHITE UP RIGHT if it can capture a piece
        if board[x+1][y+1] and (pawn_capture or board[x+1][y+1][1]==OTHER[c]):
          if y==2: # Promotion
            movez.update(promote(x+1,3))
          else:
            movez.add((t,x+1,y+1))
    if c==BLACK and y>0:       
      if not pawn_capture and board[x][y-1] is None: # BLACK DOWN
          if y==1: # Promotion
            movez.update(promote(x,0))
          else:
            movez.add((t,x,y-1))
      if x>0: # BLACK DOWN LEFT
        if board[x-1][y-1] and (pawn_capture or board[x-1][y-1][1] == OTHER[c]):
          if y==1: # Promotion
            movez.update(promote(x-1,0))           
          else:
            movez.add((t,x-1,y-1))            
      if x<3: # BLACK DOWN RIGHT
        if board[x+1][y-1] and (pawn_capture or board[x+1][y-1][1] == OTHER[c]):
          if y==1: # Promotion
            movez.update(promote(x+1,0))
          else:
            movez.add((t,x+1,y-1))            
  if t in 'QR':  
    for ix in xrange(x+1,4): # RIGHT
      if board[ix][y]:
        if board[ix][y][1] != c:
          movez.add((t,ix,y))
        break
      else:
        movez.add((t,ix,y))
    for ix in xrange(x-1,-1,-1): # LEFT
      if board[ix][y]:
        if board[ix][y][1] != c:
          movez.add((t,ix,y))
        break
      else:
        movez.add((t,ix,y))
    for iy in xrange(y+1,4): # DOWN
      if board[x][iy]:
        if board[x][iy][1] != c:
          movez.add((t,x,iy))
        break
      else:
        movez.add((t,x,iy))
    for iy in xrange(y-1,-1,-1): # UP
      if board[x][iy]:
        if board[x][iy][1] != c:
          movez.add((t,x,iy))
        break
      else:
        movez.add((t,x,iy))
  if t in 'QB':
    for d in xrange(1,min(4-x,4-y)): # DOWN+RIGHT
      if board[x+d][y+d]:
        if board[x+d][y+d][1] != c:
          movez.add((t,x+d,y+d))
        break
      else:
        movez.add((t,x+d,y+d))
    for d in xrange(1,min(x+1,y+1)): # UP+LEFT
      if board[x-d][y-d]:
        if board[x-d][y-d][1] != c:
          movez.add((t,x-d,y-d))
        break
      else:
        movez.add((t,x-d,y-d))
    for d in xrange(1,min(x+1,4-y)): # DOWN+LEFT
      if board[x-d][y+d]:
        if board[x-d][y+d][1] != c:
          movez.add((t,x-d,y+d))
        break
      else:
        movez.add((t,x-d,y+d))
    for d in xrange(1,min(4-x,y+1)): # UP+RIGHT
      if board[x+d][y-d]:
        if board[x+d][y-d][1] != c:
          movez.add((t,x+d,y-d))
        break
      else:
        movez.add((t,x+d,y-d))
  if t == 'N':
    possible=[(a,b) for (a,b) in 
                 [(x-1,y-2),(x+1,y-2),(x-2,y-1),(x+2,y-1),(x-2,y+1),(x+2,y+1),(x-1,y+2),(x+1,y+2)]
              if a>=0 and b>=0 and a<4 and b<4 
             ]
    for (a,b) in possible:
      if not board[a][b] or (board[a][b] and board[a][b][1]!=c):
        movez.add((t,a,b))
  return movez

def getallmoves(c,whites,blacks,board,pawn_capture=False):
    # get all moves that color c can make based on list of figures and board status
    # pawn_capture: whether to include pawn diagonal moves or not (for checking suicidal moves)
    s=[0,whites,blacks]
    movez=set()
    for t,x,y in s[c]:
        movez.update(amoves(t,c,x,y,board,pawn_capture))
        #if DEBUG: print 'all moves', t,c,x,y,'-->',movez
    return movez

def whitewins(col,board,level,maxlevel):    
    # col=color of player, level=current move, maxlevel=max moves
    blacks=[]
    whites=[]    
    s=[0,whites,blacks]
    for x in xrange(4):
     for y in xrange(4):
       if board[x][y]:
         t,c=board[x][y]
         s[c].append((t,x,y))
    WQ=tuple([w for w in whites if w[0]=='Q'][0][1:])
    BQ=tuple([b for b in blacks if b[0]=='Q'][0][1:])

    if col==WHITE:
        if DEBUG:print "   "*level,"Checking whites", level, whites
        allm=getallmoves(WHITE,whites,blacks,board)
        allcoords=[tuple(mov[1:]) for mov in allm]

        if not allm:
          raise ValueError("no possible moves for white.")
        if BQ in allcoords:
          if DEBUG:print "   "*level, 'WIN!','BQ',BQ,'can be captured by white', allm
          return True
        if level>=maxlevel-1: # we reached max moves and white did not win          
          return False                  
        blackm=getallmoves(BLACK,whites,blacks,board,pawn_capture=True) # get danger zones
        blackcoords=[tuple(mov[1:]) for mov in blackm]
        # ALL possible white moves
        for t,x,y in whites:
          for nt,nx,ny in amoves(t,WHITE,x,y,board):
            if t=='Q' and (nx,ny) in blackcoords: # no suicidal move
              continue
            if DEBUG:print "   "*level,'  Checking white move', t,x,y,"->",nt,nx,ny
            saved=board[nx][ny]
            board[nx][ny]=(nt,WHITE)
            board[x][y]=None
            ww=whitewins(BLACK,board,level+1,maxlevel)                
            board[x][y]=(t,WHITE)
            board[nx][ny]=saved
            if ww:
              if DEBUG:print "   "*level, 'WIN!'
              return True
        return False #none of all possible white moves won for sure

    elif col==BLACK:
        if DEBUG:print "   "*level, "Checking blacks", level, blacks
        if level==maxlevel:
            return False # reached max level and it's black's turn so white cannot possibly win
        allm=getallmoves(BLACK,whites,blacks,board)
        if not allm:
          raise ValueError("no possible moves for black.")
        allcoords=[tuple(mov[1:]) for mov in allm]
        if WQ in allcoords:
          return False
        whitem=getallmoves(WHITE,whites,blacks,board,pawn_capture=True) # get danger zones
        whitecoords=[tuple(mov[1:]) for mov in whitem]
        # ALL possible black moves        
        for t,x,y in blacks:
          for nt,nx,ny in amoves(t,BLACK,x,y,board):
            if t=='Q' and (nx,ny) in whitecoords: # no suicidal move
              continue
            if DEBUG:print "   "*level,'  Checking black move', t,x,y,"->",nt,nx,ny
            saved=board[nx][ny]            
            board[nx][ny]=(nt,BLACK)
            board[x][y]=None
            ww=whitewins(WHITE,board,level+1,maxlevel) # There is a possible black move for white not to win                
            board[x][y]=(t,BLACK)
            board[nx][ny]=saved
            if not ww: # There is a possible black move for white not to win                
              return False
        if DEBUG:print "   "*level, 'WIN!','All black moves lead to white winning'
        return True #all black moves lead to white winning

for _ in xrange(input()):
  board = [[None for _ in xrange(4)] for _ in xrange(4)]
  w,b,m=map(int,raw_input().strip().split())
  for _ in xrange(w):
    t,x,y = raw_input().strip().split()
    x={'A':0,'B':1,'C':2,'D':3}[x]
    y=int(y)-1
    board[x][y]=(t,WHITE)
  for _ in xrange(b):
    t,x,y = raw_input().strip().split()
    x={'A':0,'B':1,'C':2,'D':3}[x]
    y=int(y)-1
    board[x][y]=(t,BLACK) 
  print {True:'YES',False:'NO'}[whitewins(WHITE,board,1,m)]



C rep HackerRank Solution


Copy Code Copied Use a different Browser

#include <stdio.h>
#include <string.h>

#define QUEEN   1
#define KNIGHT  2
#define BISHOP  3
#define ROOK    4
#define PAWN    5

#define BOUND   8

int m;
unsigned char __board[8][8];
unsigned char *_board[8]={__board[0]+2, __board[1]+2, __board[2]+2, __board[3]+2,
                          __board[4]+2, __board[5]+2, __board[6]+2, __board[7]+2};
unsigned char **board=_board+2;

unsigned char black[4][4];

int pl[2]={1, -1};

int moves[6][10][3]={
  {},
  { {-1, -1, 3}, {-1, 0}, {-1, 1},
    {0, -1}, /*QUEEN*/ {0, 1},
    {1, -1},  {1, 0},  {1, 1} },
  { {-2, -1, 1},       {-2, 1},
    {-1, -2},          {-1, 2},
             /*KNIGHT*/
    {1, -2},           {1, 2},
    {2, -1},           {2, 1} },
  { {-1, -1, 3},       {-1, 1},
             /*BISHOP*/
    {1, -1},           {1, 1} },
  {           {-1, 0, 3},
    {0, -1}, /*ROOK*/  {0, 1},
              {1, 0} },
  { {-1, 0, 1}, {-1, -1}, {-1, 1}, /* white */
    {0, 0},  /*PAWN*/ 
    {1, 0},   {1, 1}, {1, -1} } /* for black */
};

static int min(int a, int b) {
  return a<b?a:b;
}

static int max(int a, int b) {
  return a>b?a:b;
}

void init_game(void) {
  int i, j;
  for (i=0; i<8; i++)
    for (j=0; j<8; j++)
      __board[i][j]=(BOUND+1)*(!(1<i && i<6 && 1<j && j<6));
  memset(black, 0, sizeof(black));
}

void print_board(void) {
  int i, j;
  char fc[6]={'=', 'Q', 'N', 'B', 'R', 'P'};
  for (i=0; i<4; i++, printf("\n"))
    for (j=0; j<4; j++)
      printf("%c ", fc[board[i][j]]+('a'-'A')*black[i][j]);
  printf("\n");
}

int solve(int mv) {
  int i, j, k, d, b=mv&1;
  int ni, nj, t, tb, r, mm=pl[!b], prom[5]={0, 0, 0, 0, 0}, p;
  for (i=0; i<4; i++) {
    for (j=0; j<4; j++) {
      if (board[i][j] && black[i][j]==b) {
        for (k=0; moves[board[i][j]][k][0] || moves[board[i][j]][k][1]; k++) {
          for (d=1; d<=moves[board[i][j]][0][2]; d++) {
            if (board[i][j]!=PAWN || k) {
              if (board[i][j]==PAWN)
                t=board[ni=(i+moves[board[i][j]][k+b*4][0])][nj=(j+moves[board[i][j]][k+b*4][1])];
              else
                t=board[ni=(i+moves[board[i][j]][k][0]*d)][nj=(j+moves[board[i][j]][k][1]*d)];
              if (t) {
                if (t>BOUND)
                  break;
                else if (t==QUEEN && black[ni][nj]!=b)
                  return pl[b];
                break;
              }
            }
          }
        }
      }
    }
  }
  if ((mv+1)==m)
    return 0;
  for (i=0; i<4; i++) {
    for (j=0; j<4; j++) {
      if (board[i][j] && black[i][j]==b) {
        for (k=0; moves[board[i][j]][k][0] || moves[board[i][j]][k][1]; k++) {
          for (d=1, t=0; d<=moves[board[i][j]][0][2] && !t; d++) {
            prom[0]=board[i][j]; prom[1]=board[i][j]; prom[2]=0;
            if (board[i][j]==PAWN) {
              t=board[ni=(i+moves[board[i][j]][k+b*4][0])][nj=(j+moves[board[i][j]][k+b*4][1])];
              if (k) {                
                if (t==0 || t>BOUND || black[ni][nj]==b)
                  break;
              } else if (t)
                  break;
              if ((ni==0 && !b) || (ni==3 && b)) {
                prom[1]=KNIGHT; prom[2]=BISHOP; prom[3]=ROOK; prom[4]=0;
              }
            } else {
              t=board[ni=(i+moves[board[i][j]][k][0]*d)][nj=(j+moves[board[i][j]][k][1]*d)];
              if (t>BOUND || (t && black[ni][nj]==b))
                break;
            }
            for (p=1; prom[p]; p++) {
              tb=black[ni][nj];
              board[ni][nj]=prom[p];
              black[ni][nj]=b;
              board[i][j]=0;
              black[i][j]=0;
              r=solve(mv+1);
              board[i][j]=prom[0];
              board[ni][nj]=t;
              black[i][j]=b;
              black[ni][nj]=tb;
              if (r==pl[b])
                return r;
              else if (b)
                mm=min(mm, r);
              else
                mm=max(mm, r);
            }
          }
        }
      }
    }
  }
  return mm;
}

int main(void) {
  int i, j, g, r, b, w;
  char figuremap[26]={['Q'-'A']=QUEEN, ['N'-'A']=KNIGHT, ['B'-'A']=BISHOP,
                      ['R'-'A']=ROOK, ['P'-'A']=PAWN};
  char t, c;
  scanf("%d", &g);
  for (i=0; i<g; i++) {
    init_game();
    scanf("%d%d%d\n", &w, &b, &m);
    for (j=0; j<w; j++) {
      scanf("%c %c %d\n", &t, &c, &r);
      board[4-r][c-'A']=figuremap[t-'A'];
    }
    for (j=0; j<b; j++) {
      scanf("%c %c %d\n", &t, &c, &r);
      r=4-r; c-='A';
      board[r][c]=figuremap[t-'A'];
      black[r][c]=1;
    }
    printf("%s\n", solve(0)==1?"YES":"NO");
  }
  
  return 0;
}

 

Warmup
Implementation
Strings
Sorting
Search
Graph Theory
Greedy
Dynamic Programming
Constructive Algorithms
Bit Manipulation
Recursion
Game Theory
NP Complete
Debugging

Leave a comment below

 

Related posts:

15 Days to learn SQL Hard SQL(Advanced)-SolutionFairy Chess – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionSimilar Pair – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionDijkstra: Shortest Reach 2 – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionJim and his LAN Party – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionChoosing White Balls – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionFlipping bits – HackerRank Solution
Tags: Cc++14full solutionGoHackerRank Solutionjavajava 15java 7java 8java8javascriptpypy 3Python 2python 3Simplified Chess Engine II
ShareTweetPin
admin

admin

Related Posts

Leetcode All Problems Solutions
Code Solutions

Exclusive Time of Functions – LeetCode Solution

by admin
October 5, 2022
0
29

Exclusive Time of Functions - LeetCode Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions...

Read more
Leetcode All Problems Solutions

Smallest Range Covering Elements from K Lists – LeetCode Solution

October 5, 2022
32
Leetcode All Problems Solutions

Course Schedule III – LeetCode Solution

October 5, 2022
25
Leetcode All Problems Solutions

Maximum Product of Three Numbers – LeetCode Solution

September 11, 2022
52
Leetcode All Problems Solutions

Task Scheduler – LeetCode Solution

September 11, 2022
119
Leetcode All Problems Solutions

Valid Triangle Number – LeetCode Solution

September 11, 2022
28
Next Post
15 Days to learn SQL Hard SQL(Advanced)-Solution

Repetitive K-Sums - HackerRank Solution

15 Days to learn SQL Hard SQL(Advanced)-Solution

Stone Division - HackerRank Solution

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

You may also like

15 Days to learn SQL Hard SQL(Advanced)-SolutionFairy Chess – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionSimilar Pair – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionDijkstra: Shortest Reach 2 – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionJim and his LAN Party – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionChoosing White Balls – HackerRank Solution 15 Days to learn SQL Hard SQL(Advanced)-SolutionFlipping bits – HackerRank Solution

Categories

  • Algorithms
  • Anime
  • Biography
  • Business
  • Code Solutions
  • Cosmos
  • Countdowns
  • Culture
  • Economy
  • Education
  • Entertainment
  • Finance
  • Games
  • Hackerrank
  • Health
  • How to
  • Investment
  • LeetCode
  • Lifestyle
  • LINUX SHELL
  • Manga
  • News
  • Opinion
  • Politics
  • Sports
  • SQL
  • Tech
  • Travel
  • Uncategorized
  • Updates
  • World
  • DMCA
  • Home
  • My account
  • Privacy Policy
  • Top Posts

Recent Blogs

Leetcode All Problems Solutions

Exclusive Time of Functions – LeetCode Solution

October 5, 2022
Leetcode All Problems Solutions

Smallest Range Covering Elements from K Lists – LeetCode Solution

October 5, 2022
15 Days to learn SQL Hard SQL(Advanced)-Solution
Algorithms

Zurikela’s Graph- HackerRank Solution

August 23, 2022
5
Biography

Naveen Kumar Gowda Net Worth, Age, Height , Achivements and more

September 8, 2022
1
15 Days to learn SQL Hard SQL(Advanced)-Solution
Code Solutions

Contest Leaderboard MediumSQL (Intermediate) – SQL – HackerRank Solution

May 30, 2022
7
13 foods for healthy skin
Education

The 13 Best Foods for Healthy Skin

May 10, 2022
8

© 2022 ZeroPlusFour - Latest News & Blog.

No Result
View All Result
  • Home
  • Category
    • Business
    • Culture
    • Economy
    • Lifestyle
    • Health
    • Travel
    • Opinion
    • Politics
    • Tech
  • Landing Page
  • Support Forum
  • Contact Us

© 2022 ZeroPlusFour - Latest News & Blog.

Welcome Back!

Login to your account below

Forgotten Password?

Retrieve your password

Please enter your username or email address to reset your password.

Log In
We use cookies on our website to give you the most relevant experience by remembering your preferences and repeat visits. By clicking “Accept All”, you consent to the use of ALL the cookies. However, you may visit "Cookie Settings" to provide a controlled consent.
Cookie SettingsAccept All
Manage consent

Privacy Overview

This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary
Always Enabled
Necessary cookies are absolutely essential for the website to function properly. These cookies ensure basic functionalities and security features of the website, anonymously.
CookieDurationDescription
cookielawinfo-checkbox-analytics11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional11 monthsThe cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance11 monthsThis cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy11 monthsThe cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.
Functional
Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
Performance
Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
Analytics
Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
Advertisement
Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.
Others
Other uncategorized cookies are those that are being analyzed and have not been classified into a category as yet.
SAVE & ACCEPT
Are you sure want to unlock this post?
Unlock left : 0
Are you sure want to cancel subscription?