Count Pairs of Points With Distance k - Problem

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

#define MAX_COORDS 10000
#define HASH_SIZE 100003

typedef struct HashNode {
    char key[50];
    int count;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++))
        hash = ((hash << 5) + hash) + c;
    return hash % HASH_SIZE;
}

void putHash(const char* key, int count) {
    unsigned int index = hash(key);
    HashNode* node = hashTable[index];
    
    while (node) {
        if (strcmp(node->key, key) == 0) {
            node->count = count;
            return;
        }
        node = node->next;
    }
    
    node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->count = count;
    node->next = hashTable[index];
    hashTable[index] = node;
}

int getHash(const char* key) {
    unsigned int index = hash(key);
    HashNode* node = hashTable[index];
    
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->count;
        }
        node = node->next;
    }
    return 0;
}

bool containsKey(const char* key) {
    return getHash(key) > 0;
}

int solution(int coordinates[][2], int coordsSize, int k) {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // Store all coordinates with their frequencies
    for (int i = 0; i < coordsSize; i++) {
        char key[50];
        sprintf(key, "%d,%d", coordinates[i][0], coordinates[i][1]);
        int currentCount = getHash(key);
        putHash(key, currentCount + 1);
    }
    
    int count = 0;
    
    // For each unique coordinate, find complementary coordinates
    for (int i = 0; i < coordsSize; i++) {
        int x = coordinates[i][0];
        int y = coordinates[i][1];
        char currentKey[50];
        sprintf(currentKey, "%d,%d", x, y);
        
        for (int dx = 0; dx <= k; dx++) {
            int dy = k - dx;
            int targetX = x ^ dx;
            int targetY = y ^ dy;
            
            char targetKey[50];
            sprintf(targetKey, "%d,%d", targetX, targetY);
            
            if (containsKey(targetKey)) {
                if (targetX == x && targetY == y) {
                    // Same point - count pairs within this group
                    int freq = getHash(targetKey);
                    count += freq - 1;
                } else if (targetX > x || (targetX == x && targetY > y)) {
                    // Only count once per unique pair by ordering
                    count += getHash(targetKey);
                }
            }
        }
    }
    
    return count / 2;
}

void parseCoordinates(const char* str, int coordinates[][2], int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != '\0') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        if (*p == ']') break;
        
        // Parse [x,y] pair
        if (*p == '[') {
            p++; // skip opening bracket
            
            // Parse x
            char* endptr;
            coordinates[*size][0] = (int)strtol(p, &endptr, 10);
            p = endptr;
            
            // Skip comma
            while (*p == ',' || *p == ' ') p++;
            
            // Parse y
            coordinates[*size][1] = (int)strtol(p, &endptr, 10);
            p = endptr;
            
            // Skip closing bracket
            while (*p == ']' || *p == ' ') p++;
            
            (*size)++;
        } else {
            break;
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int coordinates[MAX_COORDS][2];
    int coordsSize = 0;
    
    parseCoordinates(line, coordinates, &coordsSize);
    
    int k;
    scanf("%d", &k);
    
    int result = solution(coordinates, coordsSize, k);
    printf("%d\n", result);
    
    return 0;
}