{"id":1989,"date":"2021-08-19T12:00:00","date_gmt":"2021-08-19T10:00:00","guid":{"rendered":"https:\/\/kindsonthegenius.com\/blog\/queen-attack-ii-simple-solution-hackerrank\/"},"modified":"2026-07-05T03:26:08","modified_gmt":"2026-07-05T01:26:08","slug":"queen-attack-ii-simple-solution-hackerrank","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/blog\/queen-attack-ii-simple-solution-hackerrank\/","title":{"rendered":"Queen\u2019s Attack II Simple Solution \u2013 HackerRank"},"content":{"rendered":"

This is a simple and clear solution to the Queen’s\u00a0 Attack 2 problem in HackerRank. It take just three steps as given below:<\/p>\n

    \n
  1. determine all the cells the queen can attack without obstacles – queenCells<\/strong><\/li>\n
  2. determine all the cells blocked by the obstacles – pawnCells<\/strong><\/li>\n
  3. return queenCells – pawnCells<\/strong><\/li>\n<\/ol>\n

    That’s it! But seriously, what make this challenge a bit tasking is not only that there are obstacles, but we don’t know how many of them.<\/p>\n

    For simplicity, I have decided to use the name ‘pawns’ for ‘obstacles’.<\/p>\n

    To solve this problem, we would need three helper functions:<\/p>\n

      \n
    1. getCellsQueenCanAttack()<\/strong> – 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 – 2 – |x – y| – |x + y – n – 1|. Just add the two and you’ll already pass tests for cases with no obstacles.<\/li>\n
    2. 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
    3. getCellsBlockedByPawns()<\/strong> – 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<\/a>
      Original Chess Board Setup<\/figcaption><\/figure>\n

       <\/p>\n

      The board showing the CellsQueenCanAttack (cells the queen can attack). Note that the queen cannot attack herself.<\/p>\n

      \"Board<\/a>
      Board showing the CellsQueenCanAttack – A total of 14 cells<\/figcaption><\/figure>\n

       <\/p>\n

      The board showing only the pawns(obstacles) and the cells blocked by them is shown below:<\/p>\n

      \"Pawn<\/a>
      Pawn Blocked Cells –\u00a0 a total of 4<\/figcaption><\/figure>\n

       <\/p>\n

      You can see from the figures above that the result in this case is 14 – 4 = 10<\/p>\n

       <\/p>\n

      Helper Function Descriptions<\/strong><\/h4>\n

      So let’s 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):\r\n    orthognals =<\/span>  2<\/span> *<\/span> boardSize -<\/span> 2<\/span>\r\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>)\r\n    return<\/span> orthognals +<\/span> diagonals\r\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 ‘U’ or ‘D’ 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):\r\n    if<\/span> pawnY ==<\/span> queenY and<\/span> pawnX <<\/span> queenX:\r\n        return<\/span> 'L'<\/span>\r\n    if<\/span> pawnY ==<\/span> queenY and<\/span> pawnX ><\/span> queenX:\r\n        return<\/span> 'R'<\/span>\r\n    if<\/span> queenX ==<\/span> pawnX and<\/span> pawnY ><\/span> queenY:\r\n        return<\/span> 'U'<\/span>\r\n    if<\/span> queenX ==<\/span> pawnX and<\/span> pawnY <<\/span> queenY:\r\n        return<\/span> 'D'<\/span>\r\n    if<\/span> abs<\/span>(queenX -<\/span> pawnX) ==<\/span> abs<\/span>(queenY -<\/span> pawnY): #filter out irrelevant pawns\r\n        if<\/span> pawnY ><\/span> queenY and<\/span> pawnX <<\/span> queenX:\r\n            return<\/span> 'UL'<\/span>\r\n        if<\/span> pawnY ><\/span> queenY and<\/span> pawnX ><\/span> queenX:\r\n            return<\/span> 'UR'<\/span>\r\n        if<\/span> pawnY <<\/span> queenY and<\/span> pawnX ><\/span> queenX:\r\n            return<\/span> 'DR'<\/span>\r\n        if<\/span> pawnY <<\/span> queenY and<\/span> pawnX <<\/span> queenX:\r\n            return<\/span> 'DL'<\/span>\r\n<\/pre>\n
      Note 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):\r\n    blockedCells =<\/span> set<\/span>()   \r\n    for<\/span> pawn in<\/span> pawns:\r\n        x =<\/span> pawn[1<\/span>]\r\n        y =<\/span> pawn[0<\/span>]\r\n        position =<\/span> getRelativeLocation(queenX, queenY, x, y)\r\n        if<\/span> position ==<\/span> 'U'<\/span>:\r\n            for<\/span> i in<\/span> range<\/span>(y, n+<\/span>1<\/span>):\r\n                blockedCells.<\/span>add((i, x))\r\n        if<\/span> position ==<\/span> 'D'<\/span>:\r\n            for<\/span> i in<\/span> range<\/span>(y, 0<\/span>, -<\/span>1<\/span>):\r\n                blockedCells.<\/span>add((i, x))\r\n        if<\/span> position ==<\/span> 'L'<\/span>:\r\n            for<\/span> i in<\/span> range<\/span>(x, 0<\/span>, -<\/span>1<\/span>):\r\n                blockedCells.<\/span>add((y, i))\r\n        if<\/span> position ==<\/span> 'R'<\/span>:\r\n            for<\/span> i in<\/span> range<\/span>(x, n+<\/span>1<\/span>):\r\n                blockedCells.<\/span>add((y, i))   \r\n        if<\/span> position ==<\/span> 'UL'<\/span>:\r\n            while<\/span> y <=<\/span> n and<\/span> x ><\/span> 0<\/span>:\r\n                blockedCells.<\/span>add((y, x))\r\n                x -=<\/span> 1<\/span>\r\n                y +=<\/span> 1<\/span>   \r\n        if<\/span> position ==<\/span> 'UR'<\/span>:\r\n            while<\/span> y <=<\/span> n and<\/span> x <=<\/span> n:\r\n                blockedCells.<\/span>add((y, x))\r\n                x +=<\/span> 1<\/span>\r\n                y +=<\/span> 1<\/span> \r\n        if<\/span> position ==<\/span> 'DR'<\/span>:\r\n            while<\/span> y ><\/span> 0<\/span> and<\/span> x <=<\/span> n:\r\n                blockedCells.<\/span>add((y, x))\r\n                x +=<\/span> 1<\/span>\r\n                y -=<\/span> 1<\/span>   \r\n        if<\/span> position ==<\/span> 'DL'<\/span>:\r\n            while<\/span> y ><\/span> 0<\/span> and<\/span> x ><\/span> 0<\/span>:\r\n                blockedCells.<\/span>add((y, x))\r\n                x -=<\/span> 1<\/span>\r\n                y -=<\/span> 1<\/span> \r\n    return<\/span> len<\/span>(blockedCells)\r\n<\/pre>\n
       <\/p>\n
      QueenAttack() Function<\/strong><\/h4>\n
      Finally we need to complete the QueenAttack\u00a0 as shown below.<\/p>\n
      def<\/span> queensAttack<\/span>(boardSize, k, queenY, queenX, pawns):\r\n    # Write your code here<\/span>\r\n    if<\/span> len<\/span>(pawns) ==<\/span> 0<\/span>:\r\n        return<\/span> getCellsQueenCanAttack(queenX, queenY, boardSize)\r\n    else<\/span>:\r\n        queenCells =<\/span> getCellsQueenCanAttack(queenX, queenY, boardSize)\r\n        pawnCells =<\/span> getCellsBlockedByPawns(queenX, queenY, pawns)\r\n        return<\/span> queenCells -<\/span> pawnCells\r\n<\/pre>\n
      From 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’s Attack II complete code in Github – https:\/\/github.com\/KindsonTheGenius\/QueenAttack2<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      This is a simple and clear solution to the Queen’s\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":1,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1989\/revisions"}],"predecessor-version":[{"id":2157,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1989\/revisions\/2157"}],"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}]}}