Hash function — mid-square method

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

stdio.h supplies terminal input/output. stdlib.h declares conversion and allocation functions. string.h supplies string and memory utilities. ctype.h supplies isspace, and errno.h supplies conversion error reporting. Headers declare facilities; including them does not execute an operation.

/* Read one entire token; reject malformed, oversized and out-of-range input. */
int readToken(char text[], size_t capacity) {
    int ch; size_t used = 0; int fits = 1;

readToken receives a writable buffer and its capacity. ch is int so it can represent EOF as well as input characters. used counts stored characters, and fits starts as a success flag. One slot must remain for the null terminator.

    while ((ch = getchar()) != EOF && isspace((unsigned char)ch)) { }
    if (ch == EOF) return 0;

Read until a non-whitespace character appears. The unsigned-char cast supplies an allowed value to isspace. Return 0 if EOF arrives before a token begins.

    do {
        if (ch == 0) fits = 0;
        if (used + 1 < capacity) text[used++] = (char)ch;
        else fits = 0;

The do body handles the character already read. An embedded zero byte marks the token invalid. Store a character only while there is room for it and a null terminator; otherwise clear fits. Continue reading even after the buffer fills.

        ch = getchar();
    } while (ch != EOF && !isspace((unsigned char)ch));
    text[used] = '\0';
    return fits;
}

Read through the next whitespace or EOF, add a null character after the stored prefix, then return fits. A too-long token returns 0 rather than pretending that its stored prefix is the complete token.

int readInt(int *value) {
    char token[64], *end;
    if (!readToken(token, sizeof token)) return 0;

value is an output address. A 64-slot local buffer receives the token; a failed token read returns 0 before attempting conversion.

    errno = 0; long result = strtol(token, &end, 10);
    if (errno || end == token || *end || result < -1000000 || result > 1000000) return 0;

Reset errno before strtol. &end receives the stopping address. Reject conversion errors, no converted digits, leftover characters, or values outside -1,000,000 to 1,000,000. Thus 12x is not accepted as the integer 12.

    *value = (int)result; return 1;
}
int invalid(void) { puts("Invalid or incomplete input."); return 1; }

Store a validated integer through *value and return 1 from readInt. invalid is a separate helper that prints the error and returns 1 as main’s failure status; the same number has different roles in these two function contracts.

int hash(int key, int size) {
    long long square = (long long)key * key;
    char digits[32]; snprintf(digits,sizeof digits,"%lld",square);

Cast before multiplication so the square uses long long. snprintf writes its decimal representation into the bounded digits buffer, including a null terminator.

    int width = 1; for (int maxIndex = size - 1; maxIndex >= 10; maxIndex /= 10) ++width;
    int length = (int)strlen(digits);
    if (length < width) return (int)(square % size);

width is the decimal digit count needed for the maximum index size - 1, with a minimum of one. If the square has fewer digits, fall back to square % size rather than reading beyond its string.

    int start = (length - width) / 2, middle = 0;
    for (int i = 0; i < width; ++i) middle = middle * 10 + digits[start + i] - '0';

start uses (length - width) / 2, which picks the left-centred choice when the difference is odd. Build middle one digit at a time; subtracting '0' converts a decimal digit character into its value.

    return middle % size;
}

Return middle % size. This program uses this specific decimal-width and centring convention; other mid-square examples may choose a different fixed width.

/* Nonnegative key (0..1,000,000), table size (1..1000). Index only, no table insertion. */
int main(void) {

The input is a nonnegative key followed by a table size. The program calculates an index only; it does not store keys or resolve collisions.

    int key, size;
    if (!readInt(&key) || !readInt(&size) || key < 0 || size < 1 || size > 1000) return invalid();

readInt already limits integer magnitude. Require key >= 0 and size from 1 to 1000, preventing zero-divisor calculations and negative table indexes.

    printf("Hash index: %d\n",hash(key,size)); return 0;
}

Call hash(key,size), display the returned index and return success. A valid hash index need not be unique: different keys can still collide.