Implement single-player Battleship game.
Game Rules:
Ships:
- Carrier (5 spaces)
- Battleship (4 spaces)
- Cruiser (3 spaces)
- Submarine (3 spaces)
- Destroyer (2 spaces)
Placement Rules:
- Vertical or horizontal only
- No diagonal placement
- Must stay within board
- No overlapping
- No hanging off edges
Gameplay:
- Coordinate-based targeting
- Hit/Miss tracking
- Ship sinking detection
- Game end condition
Implementation Requirements:
Implement calculator with multiple operation types.
Features:
interface Calculator {
// Basic Operations
add(a: number, b: number): number
subtract(a: number, b: number): number
multiply(a: number, b: number): number
divide(a: number, b: number): number
// Advanced Operations
abs(x: number): number
sqrt(x: number): number
// Expression Evaluation
evaluate(expression: string): number
}
Requirements:
- Handle parentheses
- Operator precedence
- Error handling
- Expression parsing
Implement decoder for custom encoding scheme.
Encoding Map:
A: "0"
B: "111"
C: "1100"
D: "1101"
E: "10100"
F: "10010"
Example:
"BAD" => "11101101"
decoder("11101101") => "BAD"
Requirements:
Design system for planetary warfare simulation.
Features:
interface Planet {
x: number;
y: number;
}
interface Weapon {
cost: number;
destroy(target: Planet, planets: Planet[]): Planet[]
}
Requirements:
1. Distance Calculation
- Origin to planet distance
- Planet to planet distance
2. Weapon Types
- Single target
- Area effect (radius)
3. Optimization
- Minimum cost calculation
- Efficient targeting
Generate random competition schedule for teams.
Requirements:
interface Schedule {
team: string;
opponent: string;
round: number;
}
function generateSchedule(teams: string[]): Schedule[]
Rules:
- Each team plays twice against others
- Random scheduling
- No self-matches
- Complete coverage
Implement solution for Chicken, Grain, Fox crossing puzzle.
Requirements:
interface State {
boatman: boolean; // true = right side
chicken: boolean;
grain: boolean;
fox: boolean;
}
interface Solution {
findValidMoves(state: State): State[]
isValidState(state: State): boolean
findSolution(): State[]
}
Rules:
- Boatman takes one item at a time
- Chicken eats grain if unattended
- Fox eats chicken if unattended
Simulate plant growth with branching patterns.
Basil Rules:
Extended Rules:
interface PlantRules {
maturityWeeks: number;
branchingInterval: number;
}
function simulateGrowth(
weeks: number,
rules: PlantRules
): number
Generate unique random pairs from list of people.
Requirements:
function generatePairs(
people: string[]
): [string, string][]
Rules:
- Complete pairing
- No self-pairing
- Different pairs each run
- Random distribution
SQL queries for payment and customer analysis.
Schema:
Payment (
payment_id,
sender_id,
recipient_id,
created_at,
payment_state,
amount
)
Customer (
customer_id,
created_at,
customer_state
)
Queries:
1. 2022 payment metrics
2. Top recipients by amount
3. Failure rates by state
4. Active users (30-day window)
Transform words to Pig Latin format.
Rules:
function toPigLatin(text: string): string
Examples:
"hello" → "ellohay"
"hello world" → "ellohay orldway"
"hello, won't World!" → "ellohay, on'tway Orldway!"
Requirements:
- Preserve case
- Handle punctuation
- Maintain spacing
Design friend recommendation system based on likes.
Data Structure:
interface Like {
personA: string;
personB: string;
aLikesB: string;
bLikesA: string;
}
Requirements:
1. Count mutual likes
2. Find best friends
3. Generate recommendations
Match socks based on color and foot type.
interface Sock {
color: string;
foot: 'left' | 'right';
}
function findPairs(socks: Sock[]): [Sock, Sock][]
Requirements:
- Match same color
- Different feet
- No duplicate usage
- Complete matching
Simulate ball game with error probabilities.
interface GameRules {
maxAttempts: number;
bestOf?: number;
}
function simulateGame(
playerAError: number,
playerBError: number,
rules: GameRules
): string
Features:
- Turn-based play
- Error handling
- Winner determination
- Best-of series support
Generate timeline of overlapping work schedules.
Input Format:
interface Schedule {
name: string;
start: string; // "HH:MM"
end: string; // "HH:MM"
}
Example:
Input: [
{ name: "Oliver", start: "08:00", end: "17:00" },
{ name: "Lily", start: "08:30", end: "16:00" },
{ name: "David", start: "10:00", end: "19:00" }
]
Output:
"08:00-08:30: Oliver
08:30-10:00: Oliver, Lily
10:00-16:00: Oliver, Lily, David
16:00-17:00: Oliver, David
17:00-19:00: David"
Design tournament system with power-based winning logic.
interface Candidate {
name: string;
power: number;
id: number;
}
function generateTournament(
candidates: Candidate[]
): string[]
Rules:
- Higher power wins
- Lower ID wins ties
- Single matches
- Complete coverage