Step by Step solution about How to resolve the algorithm First perfect square in base n with n unique digits step by step in the C programming language

The provided C code is designed to find and display pairs of numbers (n, s) where s is the square of n and both n and s are expressed in a specific base. The code uses the following functions:

1. toBaseN(buffer, num, base): Converts a long long integer num to its representation in base base and stores the result in the character array buffer.
2. countUnique(inBuf): Counts the number of unique characters in the character array inBuf.
3. find(base): Finds a pair (n, s) where s = n^2 and both n and s have unique digits in the given base.

The main() function calls the find function for each base from 2 to 15, and for each base, it finds and prints a pair (n, s) that meets the specified criteria.

Here's a step-by-step explanation of the code:

1. The toBaseN function converts a long long integer num to its base base representation and stores the result in the character array buffer.

2. The countUnique function counts the number of unique characters in the character array inBuf. This function is used to check if both n and s have unique digits in a given base.

3. The find function does the following:

   • It iterates through positive integers n starting from 2.
   • For each n, it calculates s = n^2.
   • It converts both n and s to their base base representation using the toBaseN function.
   • It checks if the length of the base base representation of s is at least base and if s has unique digits (using the countUnique function).
   • If the conditions are met, it prints the pair (n, s) in the specified format.

4. The main function iterates through bases from 2 to 15 and calls the find function for each base.

Overall, this code demonstrates the use of base conversion and digit uniqueness checks to find pairs of numbers (n, s) where s = n^2 and both n and s have unique digits in a given base.

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

#define BUFF_SIZE 32

void toBaseN(char buffer[], long long num, int base) {
    char *ptr = buffer;
    char *tmp;

    // write it backwards
    while (num >= 1) {
        int rem = num % base;
        num /= base;

        *ptr++ = "0123456789ABCDEF"[rem];
    }
    *ptr-- = 0;

    // now reverse it to be written forwards
    for (tmp = buffer; tmp < ptr; tmp++, ptr--) {
        char c = *tmp;
        *tmp = *ptr;
        *ptr = c;
    }
}

int countUnique(char inBuf[]) {
    char buffer[BUFF_SIZE];
    int count = 0;
    int pos, nxt;

    strcpy_s(buffer, BUFF_SIZE, inBuf);

    for (pos = 0; buffer[pos] != 0; pos++) {
        if (buffer[pos] != 1) {
            count++;
            for (nxt = pos + 1; buffer[nxt] != 0; nxt++) {
                if (buffer[nxt] == buffer[pos]) {
                    buffer[nxt] = 1;
                }
            }
        }
    }

    return count;
}

void find(int base) {
    char nBuf[BUFF_SIZE];
    char sqBuf[BUFF_SIZE];
    long long n, s;

    for (n = 2; /*blank*/; n++) {
        s = n * n;
        toBaseN(sqBuf, s, base);
        if (strlen(sqBuf) >= base && countUnique(sqBuf) == base) {
            toBaseN(nBuf, n, base);
            toBaseN(sqBuf, s, base);
            //printf("Base %d : Num %lld Square %lld\n", base, n, s);
            printf("Base %d : Num %8s Square %16s\n", base, nBuf, sqBuf);
            break;
        }
    }
}

int main() {
    int i;

    for (i = 2; i <= 15; i++) {
        find(i);
    }

    return 0;
}