# How to Find Square Free Numbers in C?

## Introduction

Square-free number program is a typical interview and academic question in C Programming. In this section, we will define square-free integers, construct algorithms and C program to print the nth square-free number and find all the Square-Free Numbers in a Range. Further, we will also analyze their complexities.

## What is Square Free Number?

*A square-free number is an integer that is not divisible by the square of any prime number. In other words, a square-free number has no repeated prime factors.*

For example, consider the prime numbers **2, 3, 5, and 7. **These numbers are square-free because they are prime numbers and have no factors other than one and themselves. The number 15 is also square-free because it can be written as the product of prime numbers 3 and 5, and neither 3 nor 5 is a perfect square. The number 12, on the other hand, is not square-free because it can be written as the product of the prime numbers 2 and 3, and 2 is repeated.

**Other examples include:**

**4**: This number can be written as 2*2, and 2 is repeated prime. Therefore, 4 is not square-free.

**9**: This number can be written as 3*3, and 3 is a repeated prime. Therefore, 9 is not square-free.

27: This number can be written as 3**3**3, and 3 is repeated prime. Therefore, 27 is not square-free.

28: This number can be written as 2**2**7, and neither 2 nor 7 is a perfect square. Therefore, 28 is square-free.

30: This number can be written as 2**3**5, and neither 2, 3, nor 5 is a perfect square. Therefore, 30 is square-free.

Square-free numbers have unique factorization, which means that every positive integer can write as a product of prime numbers in only one way. This property is not shared by all integers, as some numbers (12) can be written as a product of prime numbers in multiple ways. For example, 12 can be written as 2**2**3 or 3*4; these two factorizations are not equivalent.

Square-free numbers are essential in mathematics because they have unique factorization, which makes them easier to work with in many contexts. They also have some unique properties that make them useful in number theory and other areas of mathematics. For example, the number of divisors of a square-free number is equal to the product of the exponents of its prime factors plus 1.

**For example,** the number 15 has 2 prime factors (3 and 5), 3 has 2 (30 and 31) number of exponent, 5 also has 2 (50 and 51) number of exponent, and the number of divisors of 15 is (2 )( 2 ) = 4.

Similarly, the number 28 has 2 prime factors (2 and 7), 2 has 2 (20 and 21 ) exponent, and 7 also has 2 (70 and 71 ) exponent, and the number of divisors of 28 is ( 2 )( 2 ) = 4.

The number of divisors of a non-square-free number is not necessarily equal to the product of the exponents of its prime factors plus 1. For example, the number 12 has 2 prime factors (2 and 3), and the number of divisors of 12 is (2+1)(1+1) = 6.

Square-free numbers are less common than non-square-free numbers, but they have important applications in number theory and other areas of mathematics. For example, the Möbius function, which is a function that assigns a value of -1, 0, or 1 to each positive integer based on its prime factorization, is closely related to square-free numbers. The Möbius function is often used in combinatorial and probabilistic calculations, and it can be computed efficiently using square-free numbers.

## C Program to Find Square Free Number

## Algorithm

Here is an algorithm for finding square-free numbers in C step-by-step-

- Write a function that takes an integer as input and returns a Boolean indicating whether the number is square-free.
- Initialize a loop variable i to 2, which is the smallest prime number. The loop will iterate through all the integers from 2 to the square root of the input number or input number.
- Inside the loop, check if the input number n is divisible by i. If it is, check if n is divisible by the square of i. If it is, return false (not square-free).
- If the loop completes without returning false, return true (square-free).

## Complexity

## 1. Time Complexity:

**The time complexity of an algorithm refers to how long it takes for the algorithm to run as the size of the input increases.** In the case of finding square-free numbers in C, the time complexity depends on the algorithm used to determine whether a given number is square-free or not.

One algorithm for finding square-free numbers involves checking whether a number is divisible by the squares of all the prime numbers less than or equal to the square root of the number. This algorithm has a time complexity of O(sqrt(n)), where n is the size of the input (the number being tested for square-freeness). It means that the time taken by the algorithm increases as the square root of the input size.

Another algorithm for finding square-free numbers involves checking whether a number is divisible by the squares of all the prime numbers less than or equal to the number. This algorithm has a time complexity of O(n), meaning that the time taken by the algorithm increases linearly with the input size.

Overall, the time complexity of finding square-free numbers in C depends on the specific algorithm used, but it is generally on the order of O(sqrt(n)) or O(n).

## 2. Space Complexity:

The space complexity of the algorithm refers to how much memory the algorithm needs to run as the input size increases. In the case of finding square-free numbers in C, the space complexity is typically determined by the amount of memory needed to store the input and any intermediate variables or data structures used by the algorithm.

For example, the space complexity of an algorithm that finds square-free numbers by checking whether a number is divisible by the squares of all the prime numbers less than or equal to the square root of the number is O(1) since it only requires a constant amount of memory to store the input and the loop variable.

On the other hand, an algorithm that finds square-free numbers by checking whether a number is divisible by the squares of all the prime numbers less than or equal to the number may have a higher space complexity, depending on how the list of prime numbers is stored. If the list of prime numbers is stored in an array, the space complexity would be **O(n)** since the array size would increase linearly with the input size.

Overall, the space complexity of finding square-free numbers in C depends on the specific algorithm used and how it handles the input and intermediate data.

## Check if the Number is a Square-Free Number or Not in C:

```
#include <math.h>
#include <stdbool.h>
bool is_square_free(int n) {
// Iterate through all integers from 2 to the square root of n
for (int i = 2; i <= sqrt(n); i++) {
// Check if n is divisible by i
if (n % i == 0) {
// Check if n is divisible by the square of i
if (n % (i * i) == 0) {
return false; // Not square-free
}
}
}
return true; // Square-free
}
int main() {
// Test the function with some sample inputs
printf("%d\n", is_square_free(2)); // Output: 1 (square-free)
printf("%d\n", is_square_free(4)); // Output: 0 (not square-free)
printf("%d\n", is_square_free(9)); // Output: 0 (not square-free)
printf("%d\n", is_square_free(27)); // Output: 0 (not square-free)
printf("%d\n", is_square_free(28)); // Output: 1 (square-free)
return 0;
}
```

**Output:-**

```
1
0
0
0
0
```

## Find nth Square Free Number in C

## Algorithm:

Here is an algorithm for finding the nth square-free number in C in step-by-step detail with an example:

- Write a function that takes an integer as input and returns a boolean indicating whether the number is square-free.
- Initialize a loop variable i to 2, which is the smallest prime number. The loop will iterate through all the integers from 2 to the square root of the input number.
- Inside the loop, check if the input number n is divisible by i. If it is, check if n is divisible by the square of i. If it is, return false (not square-free).
- If the loop completes without returning false, return true (square-free).
- Write a main function that takes an integer n as input and returns the nth square-free number.
- Initialize a counter variable i to 1 and a variable result to 2, which is the first square-free number.
- While i is less than n, increment i and add result by 1. Check if the result is square-free using the
*is_square_free*function. If it is not, continue incrementing the result until it is square-free. - Return the result as the nth square-free number.

## Complexity:

## 1. Time Complexity:-

In the case of finding the nth square-free number, the size of the input is n, the number of the square-free number we want to find.

One way to find the nth square-free number is to generate all of the positive integers in order and check each one to see if it is square-free. It can be done using a simple loop, starting at 1 and incrementing by 1 until we reach the nth square-free number.

The time complexity of this algorithm is **O(n)** since the number of operations we need to perform is directly proportional to n. The algorithm's running time will grow linearly with the input size.

It is a relatively straightforward approach, but there may be more efficient ways to find the nth square-free number. Other algorithms may have a lower time complexity, such as using a sieve to pre-compute the square-free numbers and then looking up the nth square-free number in the sieve. The time complexity of this approach will depend on the specific sieve algorithm used.

## 2. Space Complexity:

The space complexity of this algorithm is a measure of how much memory requires to run as a function of input size. In the case of finding the nth square-free number, the size of the input is n, the number of the square-free number we want to find.

One way to find the nth square-free number is to generate all of the positive integers in order and check each one to see if it is square-free. It can be done using a simple loop, starting at 1 and incrementing by 1 until we reach the nth square-free number.

The space complexity of this algorithm is O(1) since we only need to store a few variables (e.g., a counter and the current number we are checking) in memory, regardless of the input size. It means that the amount of memory required by the algorithm is constant and does not depend on the input size.

It is a relatively simple and straightforward approach, but there may be more efficient ways to find the nth square-free number. Other algorithms may have a lower space complexity, such as using a sieve to pre-compute the square-free numbers and then looking up the nth square-free number in the sieve. The space complexity of this approach will depend on the specific sieve algorithm used.

## Print nth Square Free Numbers in C:-

```
#include <math.h>
#include <stdio.h>
#include <stdbool.h>
int main()
{
int n;
printf("Enter a number: ");
scanf("%d", &n);
// Find the nth square-free number
int i = 1;
int result = 2; // The first square-free number is 2
while (i < n) {
i++;
result++;
bool square_free = true;
// Check if result is divisible by any number from 2 to sqrt(result)
for (int j = 2; j <= sqrt(result); j++) {
if (result % j == 0) {
square_free = false;
break;
}
}
// If result is not square-free, continue incrementing until it is
while (!square_free) {
result++;
square_free = true;
for (int j = 2; j <= sqrt(result); j++) {
if (result % j == 0) {
square_free = false;
break;
}
}
}
}
printf("The %dth square-free number is %d\n", n, result);
return 0;
}
```

**Output:-**

```
Enter a number: 100
The 100th square-free number is 541
```

## Finding All the Square-Free Numbers Within Given Range

## Algorithm:

To write an algorithm for finding all the square-free numbers within a given range in detail, you can follow these steps:

- Initialize a loop variable i to the lower bound of the range. The loop will iterate through all the integers from a lower bound to an upper bound.
- Inside the loop, check if i is square-free by iterating through all the integers from 2 to the square root of i, checking if i is divisible by each of them. If i is divisible by any of them, it means that i is not square-free, and you can continue to the next iteration of the loop.
- If i is not divisible by any of the integers from 2 to the square root of i, it means that i is square-free, and you can print it as a result.
- Repeat steps 2 and 3 until the loop reaches the range's upper bound.

## Complexity

## 1. Time Complexity:

In this case, the input is the range of integers being checked for square-freeness.

The algorithm for finding all the square-free numbers within a given range has a time complexity of **O(n*sqrt(n)),** where n is the size of the input (the range of integers being checked). It is because the algorithm involves a loop that iterates through all the integers in the range (n iterations), and for each integer, it checks whether it is divisible by any of the integers from 2 to the square root of the integer (sqrt(n) iterations).

In other words, the time taken by the algorithm increases as the product of the size of the input (n) and the square root of the size of the input (sqrt(n)). The algorithm's time complexity is slower than linear but not quite quadratic.

## 2. Space Complexity:

The space complexity of this algorithm refers to how much memory the algorithm uses as a function of input size. In this case, the input is the range of integers being checked for square-freeness.

The algorithm for finding all square-free numbers within a given range has a space complexity of O(1), and the algorithm's memory usage is constant no matter the input size.

The algorithm does not store data or create new variables beyond a few simple variables for looping and storing intermediate results.

In this case, the space complexity of the algorithm is independent of the size of the input and remains constant regardless of the size of the range checked. It makes the algorithm very efficient in terms of memory usage.

## C Program of Finding All the Square-Free Numbers Within a Given Range:-

```
#include <math.h>
#include <stdio.h>
#include <stdbool.h>
int main()
{
int lower, upper;
printf("Enter the lower bound of the range: ");
scanf("%d", &lower);
printf("Enter the upper bound of the range: ");
scanf("%d", &upper);
// Iterate through all integers from lower to upper
for (int i = lower; i <= upper; i++) {
// Initialize a flag to indicate whether i is square-free or not
bool square_free = true;
// Iterate through all integers from 2 to sqrt(i)
for (int j = 2; j <= sqrt(i); j++) {
// If i is divisible by j, it is not square-free
if (i % j == 0) {
square_free = false;
// Break out of the inner loop, as there is no need to check further
break;
}
}
// If i is square-free, print it
if (square_free) {
printf("%d\n", i);
}
}
return 0;
}
```

**Output:-**

```
Enter the lower bound of the range: 1
Enter the upper bound of the range: 100
1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
```

## Conclusion

In conclusion, finding square-free numbers in C involves checking whether a number is divisible by the squares of all the prime numbers less than or equal to the square root of the number. It can do it by iterating through all the integers from 2 to the square root of the number, checking if the number is divisible by each of them. If the number is divisible by any of them, it is not square-free. Moreover, to find the square-free numbers within the given range; you can use the loop to iterate through all the integers in the range and apply this check to each of them. To find the nth square-free number, you can use a similar algorithm but stop once you have found the desired number of square-free numbers. The time complexity of these algorithms depends on the size of the input range and the number of prime numbers within it.