Program that prints prime numbers

The sub-statement of this if statement that is the call of printf:

 if (primeCheck(i,y)==1)
            printf("%d ", i);

gets the control when the function primeCheck returns 1.

But according to the function definition it returns 1 when y is divisible by any number in the range [i, y] and it is not necessary that this number is i:

} else if (j%i==0) {
    return 1;

In all other case the function returns 0.

As the function calls itself recursively then it returns 1 when at least for one number in the range [x, y] y is divisible by that number.

For example for your input the function always will return 1 for each number if the range [3, 5] because 10 is divisible by 5.

Actually your function does not make a sense and has nothing common with prime numbers.

Also pay attention to that to find two biggest prime numbers in a range you should start the loop from the biggest number down to the smallest number of the range.

I think you understand the assignment incorrectly. It seems you need to write non-recursive function that determines whether a give number is a prime number and write a recursive function instead of the for loop that returns two greatest prime numbers.

That is the function that recursively finds two greatest prime numbers can look something like shown in the demonstration program below:

#include <stdio.h>

struct TwoPrimes
{
    unsigned int first_prime;
    unsigned int second_prime;
};

int is_prime( unsigned int n );

struct TwoPrimes find_two_primes( unsigned int first, unsigned int last )
{
    if (first == last)
    {
        struct TwoPrimes two_primes = { ( is_prime( first ) ? last : 0 ), 0 };
        return two_primes;
    }
    else
    {
        struct TwoPrimes two_primes = find_two_primes( first + 1, last );

        if (two_primes.first_prime == 0 || two_primes.second_prime == 0)
        {
            if (is_prime( first ))
            {
                if (two_primes.first_prime == 0)
                {
                    two_primes.first_prime = first;
                }
                else
                {
                    two_primes.second_prime = first;
                }
            }
        }

        return two_primes;
    }
}

int main( void )
{
    struct TwoPrimes two_primes = find_two_primes( 3, 10 );

    if (two_primes.first_prime != 0)
    {
        printf( "%u\n", two_primes.first_prime );

        if (two_primes.second_prime != 0)
        {
            printf( "%u\n", two_primes.second_prime );
        }
    }
}

What you need to do yourself is to define the function is_prime.

There are multiple problems in your code:

• the test for primality if (primeCheck(i, y) == 0) is incorrect: you should pass 2 as the first argument and i as the second.
• the loop should start at i = y and run while i >= x, decrementing i to find the largest primes in the range first.
• you should store the primes and stop when 2 have been found.
• the primality test function should be modified to return 1 if i > j to prevent infinite recursion on some inputs, such as primeCheck(2, 1).
• testing divisors up to and including sqrt(j) is sufficient in primeCheck(). You can stop the recursion when j < i * i, which can be tested without potential overflow as j / i < i.

Here is a modified version of your code:

#include <stdio.h>

int usersInput(int *x, int *y);
void swapping(int *x, int *y);
int primeCheck(int i, int j);

int main() {
    int x, y, i, num1, num2;
    
    if (!usersInput(&x, &y)) {
        return 1;
    }
    if (x > y) {
        swapping(&x, &y);
    }

    printf("The value of x is %d, and the value of y is %d.\n", x, y);

    for (i = y, num1 = num2 = 0; i >= x; i--) {
        if (primeCheck(2, i) == 0) {
            if (num2 == 0) {
                num2 = i;
            } else {
                num1 = i;
                break;
            }
        }
    }
    printf("The two largest prime numbers from %d to %d are: %.0d %.0d\n",
            x, y, num1, num2);
    return 0;
}

// read user input return zero on failure
int usersInput(int *x, int *y) {
    printf("Enter the value of x: ");
    if (scanf("%d", x) != 1)
       return 0;
    printf("Enter the value of y: ");
    return scanf("%d", y) == 1;
}

void swapping(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int primeCheck(int i, int j) {
    if (j < 2) {
        return 1;  // negative, 0 or 1: not prime
    } else if (j / i < i) {
        return 0;  // all factors tested up to sqrt(j): j is prime
    } else if (j % i == 0) {
        return 1;  // composite, not prime
    } else {
        return primeCheck(i + 1, j);
    }
}

Output:

Enter the value of x: 10
Enter the value of y: 3
The value of x is 3, and the value of y is 10.
The two largest prime numbers from 3 to 10 are: 5 7