Design and implement a battleship game to be played between two players until one comes out as the winner.

Requirements:

• The game will be played in a square area of the sea with NxN grids which will be called a battlefield. “N” should be taken as input in your code.
• The battlefield will be divided in half between both the players. So in a NxN battlefield, NxN/2 grids will belong to PlayerA and the other NxN/2 grids will belong to playerB
• The size and location of each ship will be taken as input. Each ship will be assumed to be of Square shape. Both the players should be assigned equal fleet.
• The location of each ship in the NxN grids has to be taken as input (X, Y). X and Y should be integers. For eg. if a ship “SH1” is at (2, 2) and has the size of 4, its corners will be at (0, 0), (0, 4), (4, 0) and (4,4)
• Ships will remain stationary. No two ships should overlap with each other. However they can touch boundaries with each other.
• Each player will fire one missile towards the enemy field during his turn using the “random coordinate fire” strategy, which means the missile will hit at a random coordinate of the opponent’s field. It might hit or miss the opponent ship. In either case the turn is then transferred to the other player.
  • In case of a hit, the opponent’s ship is destroyed.
  • In case of a miss, nothing happens.
• No two missiles should ever be fired at the same coordinates throughout the course of the game.
• When all the ships of a particular player has been destroyed, he loses the game.

The following APIs have to be implemented:

Mandatory:

• initGame(N)
  This will initialize the game with a battlefield of size NxN. Where the left half of N/2xN will be assigned to PlayerA and the right half will be assigned to PlayerB
• addShip(id, size, x position PlayerA, y position PlayerA, x position PlayerB, y position PlayerB)
  This will add a ship of given size at the given coordinates in both the player’s fleet.
• startGame()
  This will begin the game, where PlayerA will always take the first turn. The output of each step should be printed clearly in the console.
  For eg.
  PlayerA’s turn: Missile fired at (2, 4).
“Hit” . PlayerB’s ship with id “SH1” destroyed.
PlayerB’s turn: Missile fired at (6, 1).
“Miss”

Optional:

• viewBattleField()
  This will display the battlefield as a NxN grid and all the ships along with the grids occupied by each ship. PlayerA’s ship with id SH1 will be marked as A-SH1, with id SH2 as A-SH2 and so on. Whereas PlayerB’s ships will be marked as B-SH1, B-SH2 and so on.
  Note: It should mark all the grids occupied by a ship and not just the center coordinate.

Guidelines:

• You should store the data in-memory using a language-specific data-structure.
• You can print the output in the console.
• Design your application in a way that a new fire strategy can be implemented and used instead of the default one (random coordinate).
• Implement clear separation between your data layers and service layers.

Expectations:

• Your code should cover all the mandatory functionalities explained above.
• Your code should be executable and clean.
• Your code should be properly refactored, and exceptions should be gracefully handled.
• Appropriate errors should be displayed on console when user input violates the rules of the game.

How will you be evaluated?

• Code Should be working
• Code readability and testability
• Separation Of Concerns
• Abstraction
• Object-Oriented concepts.
• Language proficiency.
• Scalability
• Test Coverage (Bonus Points)

Sample Execution:

>> initGame(6)
>> addShip(“SH1”, size = 2, 1, 5, 4, 4)
>> viewBattleField()
>> viewBattleField()

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.

There is an integer array nums sorted in ascending order (with distinct values). Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2]. Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's. Do it in-place.

Given an unsorted integer array nums, return the smallest missing positive integer. You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space.

You are given n balloons, indexed from 0 to n - 1. Each balloon is painted with a number on it represented by nums[i]. You are asked to burst all the balloons. If you burst the i-th balloon, you will get nums[left] * nums[i] * nums[right] coins. left and right are adjacent indices of i. After the burst, the left and right then become adjacent. Find the maximum coins you can collect by bursting the balloons wisely.

Given an m x n integers matrix, return the length of the longest increasing path in matrix. From each cell, you can either move in four directions: left, right, up, or down. You may not move diagonally or move outside the boundary (i.e., no wrap-around is allowed).

Design a Hospital Management System. Requirements:

1. Patients are first registered at Reception, who assigns them a priority level (Critical, High, Medium, Low).
2. Patients wait in a priority queue.
3. An Initial Consultation Doctor picks the next patient from the queue.
4. After consultation, patient is assigned to a Specialist Doctor.
5. System should maintain treatment records.

Given a sorted array that has been rotated at some pivot, find a target element within it efficiently.

Design a comprehensive system to manage inventory. This includes functionalities like adding new products, updating stock levels, tracking sales, handling returns, and generating reports.

The interviewer posed high-level design questions, specifically asking how one would ensure data consistency in a distributed system when some of its nodes fail.