Sounds like a scheme where $\phi$-hiding would work well.
A scheme for a single secret element
Write a publicly-known hash-to-prime function that maps guesses to primes of around, say, 128-bits (e.g. take the first 128-bits of SHA3 output, treat as an integer and look for the next largest prime).
Hash your secret element to a prime $s$ and then construct a, say 1024-bit prime $p$ such that $s|p-1$ and another prime $q$ then multiply $p$ and $q$ to make a public value $N=pq$. Publish $N$ and you hash function. Note that $s|\phi(N)$.
To submit a guess, users hash their guess to a prime $g$, generate a random element $e\in(\mathbb Z/N\mathbb Z)^\times$ and raise it to the power $g$ modulo $N$ to create the response $r=e^g\mod N$. They send $r$ to the checker.
The checker takes responses $r$ and raises them to the power $\phi(N)/s$ modulo $N$. If $r$ is an $s$th (i.e. which is almost certainly not the case unless $g=s$) then they will get the answer 1 confirming a correct guess. Any other answer should be rejected.
Properties
If a user were able to determine that their guess were correct, this would break the $\phi$-hiding assumption.
The server gains zero-knowledge of an incorrect guess as for any guess that hashes to an incorrect prime $h\neq g$, the response $r$ could equally have arisen from the random element choice $e'=r^{1/h}\mod N$.
A multi-secret scheme
For the multi-secret scheme, in ordleer for the server to be unable to distinguish guesses we should have all of the guesses hash to the same prime $s$. This could be arranged for example by hashing guesses to 6000-bit values (e.g. using an XOF such as SHAKE) of which values $h_1,\ldots, h_{5000}$ correspond to secrets elements. We can then construct a 128x6000 binary matrix $M$ with the binary vectors whose entries match $h_1\oplus h_2, h_1\oplus h_3,\ldots, h_1\oplus h_{5000}$ lying in the nullspace of $M$. This ensures that $M\cdot h_i= M\cdot h_j$ for all $1\le i,j\le 5000$ and so treating this 128-bit value as an integer and looking for the next prime will lead to the same $s$ for all secret inputs.
One needs to be cautious though. In this scheme a user can check whether two guesses are both secrets by hashing them, XORing them and multiplying by $M$. If the answer is 0, then both guesses are probably correct. If this no longer satisfies your requirements, a different scheme may be needed.
