The assignment in myPtr = &(x[100]); is incorrect: you make myPtr point to the end of the array, causing undefined behavior when you write there and beyond.

Change the assignment to myPtr = x; or myPtr = &x[0]; and change the last statement to printf("%d", *x);

Here is a modified version:

#include <stdio.h>

int main(void) {
    int x[100];
    int *myPtr;
    int j;

    myPtr = x;

    for (j = 0; j < 100; j++) {
        *myPtr = j;
        myPtr++;
    }

    printf("x contains numbers from %d to %d\n", x[0], x[99]);

    return 0;
}

Fetching x[100] is undefined behavior.

myPtr = x;
for (j=0; j<100; j++)
  *myPtr++ = j;

To get the address of an array it's enough to evaluate x, which is the same as &x, the same as &x[0], the same as &0[x], the same as &*(x+0).

x[100] is a nonexistent element of the array x because the valid range of indices is [0, 100).

So this statement

myPtr = &(x[100]);

sets the pointer myPtr to the address of the memory after the last element of the array. Dereferencing such a pointer invokes undefined behavior.

In the for loop that fills elements of the array you need a pointer that will pointer to the first element of the array x.

You can write

myPtr = &x[0];

Though it is simpler to write

myPtr = x;

because the array designator x used as an initializer is implicitly converted to a pointer to its first element.

Your program can look the following way

#include <stdio.h>

int main(void) 
{
    enum { N = 100 };
    int x[N];
  
    int value = 0;
    
    //  fill the array
    for ( int *myPtr = x; myPtr != x + N; ++myPtr )
    {
        *myPtr = value++;
    }
    
    //  output the array in the ascending order
    for ( const int *myPtr = x; myPtr != x + N; ++myPtr )
    {
        printf( "%d ", *myPtr );
    }
    putchar( '\n' );
    
    //  print the array in the descending order
    for ( const int *myPtr = x + N; myPtr != x;  )
    {
        printf( "%d ", *--myPtr );
    }
    putchar( '\n' );
    
    return 0;
}

In the last two for loops there is used a pointer of the type const int * because within the loops elements of the array pointed to by the pointer are not being changed.