That\u2019s it! But seriously, what make this challenge a bit tasking is not only that there are obstacles, but we don\u2019t know how many of them.<\/p>\n
For simplicity, I have decided to use the name \u2018pawns\u2019 for \u2018obstacles\u2019.<\/p>\n
To solve this problem, we would need three helper functions:<\/p>\n
- \n
- getCellsQueenCanAttack()<\/strong> \u2013 The queen can attack diagonal and orthogonal. For orthogonal, the number of cells is 2n -2 for diagonals the number of cells is given by 2n \u2013 2 \u2013 |x \u2013 y| \u2013 |x + y \u2013 n \u2013 1|. Just add the two and you\u2019ll already pass tests for cases with no obstacles.<\/li>\n
- getRelativeLocation(queenX, queenY, pawnX, pawnY)<\/strong>: this function returns one of the position of the pawn relative to the queen. U for up, D for down, L for left, R for right, UL for upper left, DL for down left etc<\/li>\n
- getCellsBlockedByPawns()<\/strong> \u2013 this function will use the relative position of the pawn to determine how many cells lies between the pawn and the edge of the board.<\/li>\n<\/ol>\n
The original chess board setup is shown below:<\/p>\n
![\"Original](\"https:\/\/www.kindsonthegenius.com\/wp-content\/uploads\/2021\/08\/Original-Chess-Board.png\")
<\/a>\nOriginal Chess Board Setup<\/figcaption>\n<\/figure>\n <\/p>\n
The board showing the CellsQueenCanAttack (cells the queen can attack). Note that the queen cannot attack herself.<\/p>\n
![\"Board](\"https:\/\/www.kindsonthegenius.com\/wp-content\/uploads\/2021\/08\/Queen-Attack-Cells.png\")
<\/a>\nBoard showing the CellsQueenCanAttack \u2013 A total of 14 cells<\/figcaption>\n<\/figure>\n <\/p>\n
The board showing only the pawns(obstacles) and the cells blocked by them is shown below:<\/p>\n
![\"Pawn](\"https:\/\/www.kindsonthegenius.com\/wp-content\/uploads\/2021\/08\/Pawn-Blocked-Cells.png\")
<\/a>\nPawn Blocked Cells \u2013\u00a0 a total of 4<\/figcaption>\n<\/figure>\n <\/p>\n
You can see from the figures above that the result in this case is 14 \u2013 4 = 10<\/p>\n
<\/p>\n
Helper Function Descriptions<\/strong><\/h2>\n
So let\u2019s just look at the three helper functions:<\/p>\n
getCellsQueenCanAttack(queenX, queenY, boardSize)<\/strong><\/p>\n
This function is given below. I already explained formula to you earlier. Here, n is the board size and the queen is at position (queenX, queenY).<\/p>\n
def<\/span> getCellsQueenCanAttack<\/span>(queenX, queenY, boardSize):\n orthognals =<\/span> 2<\/span> *<\/span> boardSize -<\/span> 2<\/span>\n diagonals =<\/span> 2<\/span> *<\/span> boardSize -<\/span> 2<\/span> -<\/span> abs<\/span>(queenX -<\/span> queenY) -<\/span> abs<\/span>(queenX +<\/span> queenY -<\/span> boardSize -<\/span> 1<\/span>)\n return<\/span> orthognals +<\/span> diagonals\n<\/pre>\n<\/p>\n
getRelativeLocation(queenX, queenY, pawnX, pawnY):<\/strong><\/p>\n
This function for a single pawn, returns a value indicating the relative position of the pawn to the queen.<\/p>\n
if both are in the same column (ie pawnY = queenY), then it could be \u2018U\u2019 or \u2018D\u2019 depending on the which is greater between queenX and pawnX. The same logic applies for all other positions. Watch the video for a detailed explanation:<\/p>\n
def<\/span> getRelativeLocation<\/span>(queenX, queenY, pawnX, pawnY):\n if<\/span> pawnY ==<\/span> queenY and<\/span> pawnX <<\/span> queenX:\n return<\/span> 'L'<\/span>\n if<\/span> pawnY ==<\/span> queenY and<\/span> pawnX ><\/span> queenX:\n return<\/span> 'R'<\/span>\n if<\/span> queenX ==<\/span> pawnX and<\/span> pawnY ><\/span> queenY:\n return<\/span> 'U'<\/span>\n if<\/span> queenX ==<\/span> pawnX and<\/span> pawnY <<\/span> queenY:\n return<\/span> 'D'<\/span>\n if<\/span> abs<\/span>(queenX -<\/span> pawnX) ==<\/span> abs<\/span>(queenY -<\/span> pawnY): #filter out irrelevant pawns\n if<\/span> pawnY ><\/span> queenY and<\/span> pawnX <<\/span> queenX:\n return<\/span> 'UL'<\/span>\n if<\/span> pawnY ><\/span> queenY and<\/span> pawnX ><\/span> queenX:\n return<\/span> 'UR'<\/span>\n if<\/span> pawnY <<\/span> queenY and<\/span> pawnX ><\/span> queenX:\n return<\/span> 'DR'<\/span>\n if<\/span> pawnY <<\/span> queenY and<\/span> pawnX <<\/span> queenX:\n return<\/span> 'DL'<\/span>\n<\/pre>\nNote that some pawns are irrelevant. These are pawns that fall outside the diagonals and orthogonals of the queen.<\/p>\n
<\/p>\n
getCellsBlockedByPawns(queenX,\u00a0queenY,\u00a0pawns<\/span>)<\/strong><\/p>\n
This is the function that does more logic that previous two. So basically what it does is this: for each pawn, get its relative location, then determine how many cells lie between this pawn and the edge of the board. For each cell, add the cell position (x, y) to a set or tuples. This means there will be no repeated counts of the same cell.<\/p>\n
At the end just return the count of\u00a0 the set. This function is given below<\/p>\n
def<\/span> getCellsBlockedByPawns<\/span>(queenX, queenY, pawns):\n blockedCells =<\/span> set<\/span>() \n for<\/span> pawn in<\/span> pawns:\n x =<\/span> pawn[1<\/span>]\n y =<\/span> pawn[0<\/span>]\n position =<\/span> getRelativeLocation(queenX, queenY, x, y)\n if<\/span> position ==<\/span> 'U'<\/span>:\n for<\/span> i in<\/span> range<\/span>(y, n+<\/span>1<\/span>):\n blockedCells.<\/span>add((i, x))\n if<\/span> position ==<\/span> 'D'<\/span>:\n for<\/span> i in<\/span> range<\/span>(y, 0<\/span>, -<\/span>1<\/span>):\n blockedCells.<\/span>add((i, x))\n if<\/span> position ==<\/span> 'L'<\/span>:\n for<\/span> i in<\/span> range<\/span>(x, 0<\/span>, -<\/span>1<\/span>):\n blockedCells.<\/span>add((y, i))\n if<\/span> position ==<\/span> 'R'<\/span>:\n for<\/span> i in<\/span> range<\/span>(x, n+<\/span>1<\/span>):\n blockedCells.<\/span>add((y, i)) \n if<\/span> position ==<\/span> 'UL'<\/span>:\n while<\/span> y <=<\/span> n and<\/span> x ><\/span> 0<\/span>:\n blockedCells.<\/span>add((y, x))\n x -=<\/span> 1<\/span>\n y +=<\/span> 1<\/span> \n if<\/span> position ==<\/span> 'UR'<\/span>:\n while<\/span> y <=<\/span> n and<\/span> x <=<\/span> n:\n blockedCells.<\/span>add((y, x))\n x +=<\/span> 1<\/span>\n y +=<\/span> 1<\/span> \n if<\/span> position ==<\/span> 'DR'<\/span>:\n while<\/span> y ><\/span> 0<\/span> and<\/span> x <=<\/span> n:\n blockedCells.<\/span>add((y, x))\n x +=<\/span> 1<\/span>\n y -=<\/span> 1<\/span> \n if<\/span> position ==<\/span> 'DL'<\/span>:\n while<\/span> y ><\/span> 0<\/span> and<\/span> x ><\/span> 0<\/span>:\n blockedCells.<\/span>add((y, x))\n x -=<\/span> 1<\/span>\n y -=<\/span> 1<\/span> \n return<\/span> len<\/span>(blockedCells)\n<\/pre>\n<\/p>\n
QueenAttack() Function<\/strong><\/h2>\n
Finally we need to complete the QueenAttack\u00a0 as shown below.<\/p>\n
def<\/span> queensAttack<\/span>(boardSize, k, queenY, queenX, pawns):\n # Write your code here<\/span>\n if<\/span> len<\/span>(pawns) ==<\/span> 0<\/span>:\n return<\/span> getCellsQueenCanAttack(queenX, queenY, boardSize)\n else<\/span>:\n queenCells =<\/span> getCellsQueenCanAttack(queenX, queenY, boardSize)\n pawnCells =<\/span> getCellsBlockedByPawns(queenX, queenY, pawns)\n return<\/span> queenCells -<\/span> pawnCells\n<\/pre>\nFrom the code, we first check if there are pawns(obstacles), if not, we simply return the number of cells queen can attack without obstacles. If however, there are obstacles, we calculated cell blocked by the obstacles. The we subtract.<\/p>\n
Hope this has helped you. I also recommend watching the video and feel free to reach me if you need more clarification.<\/p>\n
Queen\u2019s Attack II complete code in Github \u2013 https:\/\/github.com\/KindsonTheGenius\/QueenAttack2<\/a><\/p>\n
Final Thought<\/h2>\n
The Queen’s Attack II<\/strong> challenge is a great example of how breaking a complex problem into smaller, reusable functions can make your solution easier to understand, test, and optimize. Rather than trying to solve everything in a single block of code, identifying the cells the queen can attack, determining which cells are blocked, and combining the results produces a clean and efficient solution that scales well even when the number of obstacles increases.<\/p>\n
As you continue solving coding challenges on HackerRank and similar platforms, focus on developing strong problem-solving habits, understanding algorithms, and writing modular code instead of memorizing solutions. If you’re looking to build these skills through structured learning, Alkademy<\/strong><\/a>, an AI-powered online learning platform, offers expert-led programming courses, AI-assisted learning tools, coding exercises, quizzes, and hands-on projects to help you become a more confident software developer.<\/p>\n
If this guide helped you understand the problem, try implementing the solution from scratch without referring to the code, experiment with different test cases, and then challenge yourself with more algorithm and data structure problems to strengthen your coding skills.<\/p>\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
This is a simple and clear solution to the Queen\u2019s\u00a0 Attack 2 problem in HackerRank. It take just three steps as given below: determine all … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"pagelayer_contact_templates":[],"_pagelayer_content":"","footnotes":""},"categories":[414],"tags":[],"class_list":["post-1989","post","type-post","status-publish","format-standard","hentry","category-programming"],"_links":{"self":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1989","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/comments?post=1989"}],"version-history":[{"count":3,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1989\/revisions"}],"predecessor-version":[{"id":2257,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1989\/revisions\/2257"}],"wp:attachment":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/media?parent=1989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/categories?post=1989"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/tags?post=1989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- getRelativeLocation(queenX, queenY, pawnX, pawnY)<\/strong>: this function returns one of the position of the pawn relative to the queen. U for up, D for down, L for left, R for right, UL for upper left, DL for down left etc<\/li>\n