[Question]
  [
Let me explain one by one the above terms...
We will call \$\text{Z-Factorial}(n)\$ of a positive integer \$n\$, \$n!\$ (i.e. \$n\$ factorial) without any trailing zeros.
So, \$\text{Z-Factorial}(30)\$ is \$26525285981219105863630848\$ because \$30!=265252859812191058636308480000000\$
We will call `Modified Z-Factorial` of \$n\$, the \$\text{Z-Factorial}(n) \mod n\$.  
So, `Modified Z-Factorial` of \$30\$, is \$\text{Z-Factorial}(30) \mod 30\$ which is \$26525285981219105863630848 \mod 30 = 18\$
We are interested in those \$n\$'s for which the `Modified Z-Factorial of n` is a Prime Number
***Example***
The number \$545\$ is **PMZ** because \$\text{Z-Factorial}(545) \mod 545 = 109\$ which is prime
Here is a list of the first values of \$n\$ that produce `Prime Modified Z-Factorial (PMZ)`
```
5,15,35,85,545,755,815,1135,1165,1355,1535,1585,1745,1895,1985,2005,2195,2495,2525,2545,2615,2705,2825,2855,3035,3085,3155,3205,3265,3545,3595,3695,3985,4135,4315,4385,4415,4685,4705,4985,5105,5465,5965,6085,6155,6185,6385,6415,6595...         
```
**Task**
The above list goes on and your task is to find the \$k\$th ***PMZ***
**Input**
A positive integer \$k\$
**Output**
The \$kth\$ ***PMZ***
**Test Cases**
here are some **1-indexed** test cases.  
Please state which indexing system you use in your answer to avoid confusion.  
Your solutions need only work within the bounds of your language's native integer size.
```
input -> output     
 1        5     
 10       1355       
 21       2615     
 42       5465     
 55       7265      
 100      15935
 500      84815
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the lowest score in bytes wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
```
[N!0ÜN%pi®>©¹Q#N
```
**Input** is **1-based** k.
**Outputs** the k-th PMZ.
Explanation:
```
[N!0ÜN%pi®>©¹Q#N
[                     Start infinite loop
 N!                   Factorial of the index
   0Ü                 Remove trailing zeros
     N%               Mod index
       p              Is prime?
        i             If it is:
         ®>©          Increment the value stored in register c (initially -1)
            ¹Q        Is the value equals the input?
              #N      If it does, push the index (which is the PMZ) and break
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/2k/R4PAcP9WCzEPr7A6tPLQzUNnv/38TAA)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 11 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
!Dt0Ḍ%⁸Ẓµ#Ṫ
```
A full program reading from STDIN which prints the result to STDOUT.
**[Try it online!](https://tio.run/##AR4A4f9qZWxsef//IUR0MOG4jCXigbjhupLCtSPhuar//zY "Jelly – Try It Online")**
### How?
```
!Dt0Ḍ%⁸Ẓµ#Ṫ - Main Link: no arguments
         #  - set n=0 (implicit left arg) and increment getting the first
                (implicit input) values of n which are truthy under:
        µ   -   the monadic chain (f(n)):
!           -     factorial -> n!
 D          -     convert from integer to decimal digits
  t0        -     trim zeros
    Ḍ       -     convert from decimal digits to integer
      ⁸     -     chain's left argument, n
     %      -     modulo
       Ẓ    -     is prime?
          Ṫ - tail
            - implicit print
```
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 58 bytes
```
D,f,@,Rb*BDBGbUdb*!!*BFJiA%P
x:?
Wx,`y,+1,`z,$f>y,`x,-z
Oy
```
[Try it online!](https://tio.run/##S0xJKSj4/99FJ03HQScoScvJxck9KTQlSUtRUcvJzSvTUTWAq8LKniu8QiehUkfbUCehSkclza5SJ6FCR7eKy7/y////RpYA "Add++ – Try It Online")
Times outs for \$k \ge 30\$ on TIO
## How it works
```
D,f,@,			; Define a function, f, taking 1 argument, n
			; Example:		STACK = [30]
	Rb*		; Factorial		STACK = [265252859812191058636308480000000]
	BD		; Convert to digits	STACK = [2 6 5 ... 0 0 0]
	BGbU		; Group adjacents	STACK = [[2] [6] [5] ... [8] [4] [8] [0 0 0 0 0 0 0]]
	db*!!		; If last is all 0s
	*BF		; 	remove it	STACK = [[2] [6] [5] ... [8] [4] [8]]
	Ji		; Join to make integer	STACK = [26525285981219105863630848]
	A%		; Mod n			STACK = [18]
	P		; Is prime?		STACK = [0]
			; Return top value	0
x:?			; Set x to the input
Wx,			; While x > 0
	`y,+1,		;	y = y + 1
	`z,$f>y,	;	z = f(y)
	`x,-z		;	x = x - z
			; We count up with y
			; If y is PMZ, set z to 1 else 0
			; Subtract z from x, to get x PMZs
Oy			; Output y
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
0-indexed. Only works, in practice, for `0` & `1` as once we go over `21!` we exceed JavaScript's `MAX_SAFE_INTEGER`.
```
ÈÊsÔsÔuX j}iU
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=yMpz1HPUdVggan1pVQ&input=MQ)
```
ÈÊsÔsÔuX j}iU     :Implicit input of integer U
È                 :Function taking an integer X as argument
 Ê                :  Factorial
  s               :  String representation
   Ô              :    Reverse
    sÔ            :  Repeat (There has to be a shorter way to remove the trailing 0s!)
      uX          :  Modulo X
         j        :  Is prime?
          }       :End function
           iU     :Pass all integers through that function, returning the Uth one that returns true
```
[Answer]
# [R](https://www.r-project.org/), ~~99~~ 93 bytes
*Edit: -6 bytes (and -4 bytes from arbitrary-precision version) thanks to Giuseppe*
```
k=scan();while(k){F=F+1;z=gamma(F+1);while(!z%%5)z=z/10;x=z%%F;k=k-(x==2|all(x%%(2:x^.5)))};F
```
[Try it online!](https://tio.run/##NYpLDsIgFAD3nuI1hggxfkrSTQkuOYAHMHlBrARKDaURUc9eu3E3k5k4z06OGgNl4nm33lDH3kqqbS2K7LDvkS78b1UhpGFFlkN9FFkupoSTbkezlPyD3tNMCOVtvuwbxthXqJmvVmsIQzItaPR68pjsEEYwWRtzhfNmBNR6ipgMhKk30S4bRAydgdsQAcMLbHhMCU68Aph/ "R – Try It Online")
Uses the straightforward approach, following the steps of the explanation. Unfortunately goes out of limits of [R](https://www.r-project.org/)'s numerical accuracy at factorial(21), so fails for any k>2.
An arbitrary-precision version (which is not limited to small k, but is less golf-competitive) is:  
**[R](https://www.r-project.org/) + gmp, [115 bytes](https://tio.run/##JYtBCsIwEABfs7CLWJtCL8a95hnCVkIMSYqkgjGtb4@UHoeZyS36KUv@oksvaoGXh8xI@vP00WKg1bAs3eRdRXNSpCs7SUkOOKIKMN4UVa5wAdXrsh9@fltn8y4N6cDhjIV52CRGLADDtdy7keinTVN9@wM)**
[Answer]
# [Husk](https://github.com/barbuz/Husk), 11 bytes
```
!foṗS%ȯ↔↔ΠN
```
[Try it online!](https://tio.run/##yygtzv7/XzEt/@HO6cGqJ9Y/apsCROcW@P3//98IAA "Husk – Try It Online")
## Explanation
```
!foṗS%ȯ↔↔ΠN
 f        N filter list of natural numbers by:
         Π  take factorial
       ↔↔   reverse twice, remove trailing zeros
     S%     mod itself
    ṗ       is prime?
!           get element at index n
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~89 ... 79~~ 77 bytes
```
n=>(g=y=>y%10n?(p=k=>y%--k?p(k):~-k||--n?g(x*=++i):i)(y%=i):g(y/10n))(x=i=2n)
```
[Try it online!](https://tio.run/##FYtBDoIwEADvvKIXkq24Cl404MJbCBZSS9qGNoYq@nRrPc0kk7n3j94Ni7QetbmJOFLU1MJEgdqQV6XuwJL6O6LqLChef1BtG6LuJlh3VBSS15JDyCnJBOGYJs5hJUknzeNoFpiFZ5oRq5qEK7FzYlFw9soYG4x2ZhaH2Uyg92yENDfZO36N9TK1iOh8Pyh08inoUpblDw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~145~~ ~~140~~ ~~138~~ 129 bytes
```
def f(n,r=0):
 c=d=2
 while r<n:
  c+=1;d*=c
  while 1>d%10:d//=10
  i=d%c;r+=i==2or i and min(i%j for j in range(2,i))
 return c
```
[Try it online!](https://tio.run/##JY/BCgIxDETv/YpBWNhqxbbqRY0/Ih6WtutGNEpdEb9@bfGUmZdkSJ7fcXjIeppi6tG3YjJZvVMIFMkrfAa@JeSDFISwILePcwpF/xvuGBtnd3G1ImcLZYpN2OcFMZF/ZDA6ibiztNxc0RdyBQtyJ5fUesNaK@Q0vrMgTPK@v0A4OQNnDXypG2@w3VZvz0rV/dSFoUbU4XoT8MwsY1u5wWx5nJnyRnVaTz8 "Python 3 – Try It Online")
# [Python 2](https://docs.python.org/2/), ~~126~~ 125 bytes
```
def f(n,r=0):
 c=d=2
 while r<n:
	c+=1;d*=c
	while d%10<1:d/=10
	i=d%c
	r+=i==2or i and min(i%j for j in range(2,i))
 print c
```
[Try it online!](https://tio.run/##JY5NCsIwEIXXnVM8hEKrEZOgm@p4EXFRktZO0VGiIp6@Nrga3vd@mMf3NdzVT1PsevSVmsS2bgiBI3vCZ5Brh3TQhoqwYrePSw5U/HEsnT24Jm7YWSqEYzlbacXC7O8JglYjbqKVlCP6mYwQRWr10lXeSF0THkn0hTDp@/YE4@QMnDXw8916g90ua3smyvWuDUNeyOH5n383Q4PF@rgwVPRVlvX0Aw "Python 2 – Try It Online")
---
Explanation: Keep dividing by 10 as long as the current factorial is divisible by 10, and then check the factorial modulo current number for primality.
Thanks to *caird coinheringaahing* for -20 bytes and *Dominic van Essen* for -9 bytes!
[Answer]
# [Haskell](https://www.haskell.org/), ~~129~~ 111 bytes
```
g n
 |n`mod`10>0=n
 |0<1=g$div n 10
f=(!!)[n|n<-[1..],let p=mod(g$product[1..n])n,[x|x<-[2..p],mod p x<1]==[p]]
```
[Try it online!](https://tio.run/##TY5NboMwEIX3nGKCWNjKlNoEp6mEc4J21aVlNSgQiALGSpzWSNydmlaVsns/32heW94uddfNcwMmgskc@qE6cLZncrGs4LJJqvMXGOAsOkmyWlFlJlM8KZ6mGrvagZXhhjSJvQ7V/eiWwmhqUPnJBy5LU6sxIGDBF1xLqazWcwseRgkxiWG9BnJrh2/wdNExBbmHhziB038Fz4/F@BeS2tv66OqKxlHUl2cDEvrSvn@CvbsPd30zoH7fTcTjSMMmwlFQJJwh34hFZRyzLRc0DCOCMdzlu@ACEAjxugkyz1Dk24UVAl@yoH4A "Haskell – Try It Online")
`g` removes `0`s from number.
`f` takes `k`th element from an infinite list comprehension where:  
`[x|x<-[2..p],mod p x==0]==[p]` is `prime` condition( compares list of divisors of `p` and a list of just p).
And `p` is `mod(g$foldr(*)1[1..n])n` the modulo of factorial passed through `g`.
Saved 18 thanks to [user](https://codegolf.stackexchange.com/users/95792/user)
]