Design Snake Game - Practice Coding Problems

Design Snake Game - Problem

🐍 Design Snake Game

Design and implement the classic Snake Game that runs on a device with screen dimensions height × width. If you're not familiar with Snake, it's a simple but addictive game where a snake moves around the screen eating food and growing longer!

Game Rules:

🏁 The snake starts at position (0, 0) (top-left corner) with length 1
🍎 Food appears one piece at a time at predetermined locations
📈 When the snake eats food, both its length and score increase by 1
💀 Game ends if the snake hits a wall or collides with itself
🎯 Return the current score after each move, or -1 if game over

Your task: Implement the SnakeGame class with:

SnakeGame(int width, int height, int[][] food) - Initialize the game
int move(String direction) - Move snake and return score (or -1 if game over)

Directions: "U" (up), "D" (down), "L" (left), "R" (right)

Input & Output

example_1.py — Basic Snake Movement

$ Input: SnakeGame(3, 2, [[1,2],[0,1]]) snake.move("R") # Move right snake.move("D") # Move down snake.move("R") # Move right (eat food) snake.move("U") # Move up (eat food) snake.move("L") # Move left snake.move("U") # Move up (hit wall)

› Output: 0 0 1 2 2 -1

💡 Note: Snake moves through the 3x2 grid. Score increases when food is eaten at (1,2) and (0,1). Game ends when snake tries to move up from row 0 (out of bounds).

example_2.py — Self Collision

$ Input: SnakeGame(3, 3, [[2,0]]) snake.move("D") # Move down snake.move("D") # Move down (eat food) snake.move("U") # Move up snake.move("U") # Move up (hit itself)

› Output: 0 1 1 -1

💡 Note: Snake grows after eating food at (2,0). When it tries to move back up, it collides with its own body segment, ending the game.

example_3.py — Empty Food Array

$ Input: SnakeGame(2, 2, []) snake.move("R") # Move right snake.move("D") # Move down snake.move("L") # Move left snake.move("U") # Move up (back to start)

› Output: 0 0 0 0

💡 Note: No food available, so snake maintains length 1 and score stays 0. Snake moves in a square pattern without growing.

Visualization

Tap to expand

Understanding the Visualization

Initialize Game

Start with snake head at (0,0), empty food queue, score = 0

Process Move

Calculate new head position based on direction

Validate Move

Check bounds and collision using hash set O(1) lookup

Update Snake

Add new head, conditionally remove tail, sync data structures

Return Score

Return current score or -1 if game over

Key Takeaway

🎯 Key Insight: Combining deque for efficient queue operations with hash set for instant collision detection creates an optimal O(1) solution that scales perfectly for competitive gaming scenarios.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each move operation is O(1) - hash set lookup, deque operations are all constant time

✓ Linear Growth

Space Complexity

O(n)

Store snake coordinates in both deque and hash set, where n is snake length

⚡ Linearithmic Space

Constraints

1 ≤ width, height ≤ 10⁴
0 ≤ food.length ≤ 50
food[i].length == 2
0 ≤ r_i < height
0 ≤ c_i < width
direction.length == 1
direction is one of {'U', 'D', 'L', 'R'}
At most 10⁴ calls will be made to move

Asked in

G Google 45 a Amazon 38 f Meta 32 🍎 Apple 28 ⊞ Microsoft 25

The optimal solution uses a deque (double-ended queue) to efficiently manage the snake's body with O(1) head insertion and tail removal, combined with a hash set for O(1) collision detection. This approach ensures each move operation runs in constant time, making it suitable for real-time gaming applications where performance is critical.

Common Approaches

Approach	Time	Space	Notes
✓ Queue + Hash Set (Optimal)	O(1)	O(n)	Use queue for snake body management and hash set for O(1) collision detection
Brute Force (Linear Search)	O(n)	O(n)	Use a list to store snake body and linear search for collision detection

Queue + Hash Set (Optimal) — Algorithm Steps

Use a deque to store snake body coordinates
Maintain a hash set of occupied positions for O(1) collision detection
For each move, calculate new head position
Check bounds and collision using hash set lookup
If food eaten: add to deque and hash set, increment score
If no food: add new head, remove tail from both deque and set
Return current score

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate new head

Determine next position based on direction

Hash set lookup

O(1) collision detection using hash set

Queue operations

O(1) add head/remove tail using deque

Update hash set

Sync hash set with queue changes

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char key[20];
    struct HashNode* next;
} HashNode;

typedef struct {
    int width, height;
    int** food;
    int foodSize;
    int foodIndex;
    int score;
    int** snake;
    int snakeSize;
    int capacity;
    HashNode* hash[HASH_SIZE];
} SnakeGame;

int hashFunction(const char* key) {
    int hash = 0;
    while (*key) {
        hash = (hash * 31 + *key) % HASH_SIZE;
        key++;
    }
    return hash;
}

void addToHash(SnakeGame* obj, const char* key) {
    int idx = hashFunction(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->next = obj->hash[idx];
    obj->hash[idx] = node;
}

int existsInHash(SnakeGame* obj, const char* key) {
    int idx = hashFunction(key);
    HashNode* curr = obj->hash[idx];
    while (curr) {
        if (strcmp(curr->key, key) == 0) return 1;
        curr = curr->next;
    }
    return 0;
}

void removeFromHash(SnakeGame* obj, const char* key) {
    int idx = hashFunction(key);
    HashNode* curr = obj->hash[idx];
    HashNode* prev = NULL;
    
    while (curr) {
        if (strcmp(curr->key, key) == 0) {
            if (prev) prev->next = curr->next;
            else obj->hash[idx] = curr->next;
            free(curr);
            return;
        }
        prev = curr;
        curr = curr->next;
    }
}

SnakeGame* snakeGameCreate(int width, int height, int** food, int foodSize, int* foodColSize) {
    SnakeGame* obj = (SnakeGame*)malloc(sizeof(SnakeGame));
    obj->width = width;
    obj->height = height;
    obj->food = food;
    obj->foodSize = foodSize;
    obj->foodIndex = 0;
    obj->score = 0;
    obj->snakeSize = 1;
    obj->capacity = 10000;
    obj->snake = (int**)malloc(sizeof(int*) * obj->capacity);
    obj->snake[0] = (int*)malloc(sizeof(int) * 2);
    obj->snake[0][0] = 0;
    obj->snake[0][1] = 0;
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        obj->hash[i] = NULL;
    }
    addToHash(obj, "0,0");
    
    return obj;
}

int snakeGameMove(SnakeGame* obj, char* direction) {
    int newHead[2];
    int* head = obj->snake[0];
    
    if (direction[0] == 'U') {
        newHead[0] = head[0] - 1;
        newHead[1] = head[1];
    } else if (direction[0] == 'D') {
        newHead[0] = head[0] + 1;
        newHead[1] = head[1];
    } else if (direction[0] == 'L') {
        newHead[0] = head[0];
        newHead[1] = head[1] - 1;
    } else { // 'R'
        newHead[0] = head[0];
        newHead[1] = head[1] + 1;
    }
    
    // Check bounds
    if (newHead[0] < 0 || newHead[0] >= obj->height ||
        newHead[1] < 0 || newHead[1] >= obj->width) {
        return -1;
    }
    
    char newHeadKey[20];
    sprintf(newHeadKey, "%d,%d", newHead[0], newHead[1]);
    
    // Check food
    int ateFood = obj->foodIndex < obj->foodSize &&
                  newHead[0] == obj->food[obj->foodIndex][0] &&
                  newHead[1] == obj->food[obj->foodIndex][1];
    
    if (ateFood) {
        obj->score++;
        obj->foodIndex++;
    } else {
        // Remove tail
        int* tail = obj->snake[obj->snakeSize - 1];
        char tailKey[20];
        sprintf(tailKey, "%d,%d", tail[0], tail[1]);
        removeFromHash(obj, tailKey);
        free(tail);
        obj->snakeSize--;
    }
    
    // Check collision (O(1) average)
    if (existsInHash(obj, newHeadKey)) {
        return -1;
    }
    
    // Add new head
    for (int i = obj->snakeSize; i > 0; i--) {
        obj->snake[i] = obj->snake[i-1];
    }
    obj->snake[0] = (int*)malloc(sizeof(int) * 2);
    obj->snake[0][0] = newHead[0];
    obj->snake[0][1] = newHead[1];
    obj->snakeSize++;
    addToHash(obj, newHeadKey);
    
    return obj->score;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each move operation is O(1) - hash set lookup, deque operations are all constant time

✓ Linear Growth

Space Complexity

O(n)

Store snake coordinates in both deque and hash set, where n is snake length

⚡ Linearithmic Space

Constraints

1 ≤ width, height ≤ 10⁴
0 ≤ food.length ≤ 50
food[i].length == 2
0 ≤ r_i < height
0 ≤ c_i < width
direction.length == 1
direction is one of {'U', 'D', 'L', 'R'}
At most 10⁴ calls will be made to move

67.2K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🐍 Design Snake Game

Game Rules:

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Queue + Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler