You could place each possible operator in a provided string buffer (or return a dynamically allocated buffer).
#include <stdio.h>
int in_range(int l, int v, int u) {
    return l < v && v < u;
}
size_t func(char *ops, int given_pos, int given_ran, int limit) {
    size_t n = 0;
    if (in_range(0, given_pos + given_ran, limit))
        ops[n++] = '+';
    if (in_range(0, given_pos - given_ran, limit))
        ops[n++] = '-';
    if (in_range(0, given_pos * given_ran, limit))
        ops[n++] = '*';
    if (in_range(0, given_pos / given_ran, limit))
        ops[n++] = '/';
    ops[n] = 0;
    return n;
}
int main(void) {
    char buf[32];
    size_t number_of_ops = func(buf, 32, 16, 64);
    printf("%zu ops: [%s]\n", number_of_ops, buf);
}
stdout:
3 ops: [+-/]
Or you could return a structure, if you prefer the code verbosity. This is more meaningful when the "return values" differ in type.
#include <stdbool.h>
#include <stdio.h>
struct ops {
    bool add;
    bool sub;
    bool mul;
    bool div;
};
bool in_range(int l, int v, int u) {
    return l < v && v < u;
}
struct ops func(int given_pos, int given_ran, int limit) {
    struct ops o = {0};
    o.add = in_range(0, given_pos + given_ran, limit);
    o.sub = in_range(0, given_pos - given_ran, limit);
    o.mul = in_range(0, given_pos * given_ran, limit);
    o.div = in_range(0, given_pos / given_ran, limit);
    return o;
}
int main(void) {
    struct ops o = func(32, 16, 64);
    printf("add? %d sub? %d mul? %d div? %d\n", o.add, o.sub, o.mul, o.div);
}
stdout:
add? 1 sub? 1 mul? 0 div? 1
Or you could use bitwise operations to create a basic set of bitmasks, allowing use of an integral type to represent the options available.
#include <stdio.h>
#define CAN_ADD (1 << 0)
#define CAN_SUB (1 << 1)
#define CAN_MUL (1 << 2)
#define CAN_DIV (1 << 3)
int in_range(int l, int v, int u) {
    return l < v && v < u;
}
unsigned func(int given_pos, int given_ran, int limit) {
    unsigned o = 0;
    if (in_range(0, given_pos + given_ran, limit))
        o |= CAN_ADD;
    if (in_range(0, given_pos - given_ran, limit))
        o |= CAN_SUB;
    if (in_range(0, given_pos * given_ran, limit))
        o |= CAN_MUL;
    if (in_range(0, given_pos / given_ran, limit))
        o |= CAN_DIV;
    return o;
}
int main(void) {
    unsigned o = func(32, 16, 64);
    printf("add? %d sub? %d mul? %d div? %d\n", o & CAN_ADD, o & CAN_SUB,
           o & CAN_MUL, o & CAN_DIV);
}
stdout:
add? 1 sub? 2 mul? 0 div? 8