Bash + bsdgames package, 39

primes 1 $[10**$2]|grep ^$1|egrep .{$2} 

Try it online!

R, 65 bytes

\(n,m,k=10^(n-nchar(m)))for(i in 0:k+m*k)sum(!i%%2:i)<2&&print(i) 

Attempt This Online!

Vyxal, 12 11 bytes

↵:₀/ṡ~æ'⁰øp 

Try it Online!

Takes n then m. Prints the primes in order from largest to smallest.

Explained

↵:₀/ṡ~æ'⁰øp ↵:₀/ # 10 ** n, 10 ** (n - 1) ṡ # range(^, ^) ~æ # filtered to only include primes '⁰øp # and filtered to only keep numbers which start with m 

Vyxal, 10 bytes

Lε↵~*~+ṡ~æ 

Try it Online!

 ↵ # 10 ** ε # Digit count minus L # Length of starting digits ~* # Multiply by starting digits (without popping) ~+ # Add to starting digits (without popping) ṡ # Range from ^^ to ^ ~æ # Filter by isprime 

Charcoal, 28 bytes

≔Ｘχ⁻ＮＬηθＩΦ⁺…⁰θ×Ｎθ∧›ι¹⬤…²ι﹪ιλ 

Try it online! Link is to verbose version of code. Takes n as the first input and m as the second. Explanation:

≔Ｘχ⁻ＮＬηθ 

Subtract the number of digits in m from n and then take 10 to that power.

ＩΦ⁺…⁰θ×Ｎθ∧›ι¹⬤…²ι﹪ιλ 

Take the range from 0 to that number, add on m multiplied by that number, then output only the prime numbers in that range.

Brachylog (v2), 10 bytes

⟨{~l}a₀⟩ṗ≜ 

Try it online!

A generator solution that generates all possible outputs (the TIO header converts the generator to a list for printing, but consensus is that the generator on its own is sufficient to output a list). Input is a list [n,m].

This should be 8 bytes, but I had to add grouping characters {} to work around a bug in Brachylog's parser.

Explanation

⟨{~l}a₀⟩ṗ≜ ~ Checking values whose l length ⟨ is the first input, and a₀ which have a prefix that is ⟩ the second input, ṗ using only the values that are prime numbers, ≜ generate all specific values that meet these criteria. 

The { and } don't do anything but are required to prevent the parser crashing.

One interesting quirk of Brachylog: the l doesn't imply anything about us looking for numbers here, and will also try 4-element lists, but a few of the later restrictions restrict the program to looking for numbers specifically and thus it'll discount 4-element lists as a possibility.

Brachylog's primality testing algorithm is slow but general – it'll work in theory for any number of digits and any size of prefix, but may take a long time on larger numbers.

Python, 83 80 75 bytes

lambda n,m:primerange(x:=m*(y:=10**(n-len(str(m)))),x+y) from sympy import* 

Attempt This Online!

-3 bytes by changing list(x) to [*x]

-5 bytes thanks to @emanresu A

Retina 0.8.2, 117 bytes

.+$ $*# ((.)+)¶(?<-2>#)+ $1 +%1`# 0$'¶$`1$'¶$`2$'¶$`3$'¶$`4$'¶$`5$'¶$`6$'¶$`7$'¶$`8$'¶$`9 .+ $* A`^1?$|^(11+)\1+$ %`1 

Try it online! Takes m as the first input and n as the second. Explanation:

.+$ $*# 

Convert n to unary.

((.)+)¶(?<-2>#)+ $1 

Decrement n for each digit of m.

+%1`# 0$'¶$`1$'¶$`2$'¶$`3$'¶$`4$'¶$`5$'¶$`6$'¶$`7$'¶$`8$'¶$`9 

Extend m to be n digits long, a digit at a time.

.+ $* 

Convert all the values to unary.

A`^1?$|^(11+)\1+$ 

Discard 0, 1 and all composite numbers. (If n was always at least 2, the ^1?$| would not be needed for a saving of 5 bytes.)

%`1 

Convert the remaining primes back to decimal.

05AB1E, 12 bytes

°DT÷Ÿʒp}ʒ²Å? 

Try it online!

Port of lyxal's Vyxal answer. It can probably be a bit shorter, but I can't get it to work with just 1 filter.

Explanation:

°DT÷Ÿʒp}ʒ²Å? # Implicit input, with n first then m ° # 10 ** n DT÷ # 10 ** (n - 1) Ÿ # Range between them ʒp} # Primes only ʒ # Keep only those Å? # which start with ² # the second input, m # Implicit output 

Thunno, \$ 17 \log_{256}(96) \approx \$ 13.99 bytes

10@D10,s:gNkgz1ZV 

(No ATO link since that's on an older version)

Port of lyxal's Vyxal answer.

Explanation

10@D10,s:gNkgz1ZV # Implicit input, with n first then m 10@ # 10 ** n D10, # 10 ** (n - 1) s: # Range between them gNk # Primes only g # Keep only those ZV # which start with z1 # the second input, m # Implicit output 

Screenshot

C (gcc) with -lgmp, 159 147 bytes

• -2 thanks to ceilingcat
• -10 by removing the #import

Takes a number length and prefix (as a string).

Luckily GMP has a "next prime number" function, so I just had to turn the prime numbers into strings and compare the prefix to the stringified values.

*t,p[9];f(m,w,u,v)int*w;{u=strlen(w);__gmpz_init(p);for(v=0;v<=m;(v=__gmp_asprintf(&t,"%Zd",p))==m&!strncmp(w,t,u)&&puts(t))__gmpz_nextprime(p,p);} 

Try it online!

JavaScript (V8), 78 bytes

Expects (n)(m), with m passed as a string.

n=>m=>{for(q=1;!m[n-1];q*=10)m+=0;for(;q--;m++)for(x=m;x-2||print(m),m%--x;);} 

Try it online!

Commented

n => // outer function taking n m => { // inner function taking m for( // initialization loop: q = 1; // q = size of range, initialized to 1 !m[n - 1]; // stop when m is large enough q *= 10 // at each iteration, multiply q by 10 ) m += 0; // and append a trailing 0 to m for( // main outer loop: ; // q--; // stop when q = 0 / decrement it afterwards m++ // increment m after each iteration ) // for( // main inner loop: x = m; // stat with x = m x - 2 || // if we've reached x = 2 without breaking: print(m), // m is prime --> print it m % --x; // decrement x and stop if it's a divisor of m ); // } // 

05AB1E, 9 bytes

°ÅP¹ùʒIÅ? 

Try it online.

Explanation:

° # Push 10 to the power of the first (implicit) input-integer `n` ÅP # Pop and push a list of all primes lower than (or equal to) that 10**n ¹ù # Only keep the primes with a length equal to the first input `n` ʒ # Filter it further by keeping those: IÅ? # That start with the second input-integer `m` # (after which the filtered list of primes is output implicitly as result) 

If we could assume that \$n>L_m\$, where \$L_m\$ is the length of \$m\$, it could be 7 bytes instead:

°Ý«¹ùʒp 

Try it online.

Without that assumption, it would still be 9 bytes with this approach:

°Ý«Iš¹ùʒp 

Try it online.

Explanation:

° # Push 10 to the power of the first (implicit) input-integer `n` Ý # Pop and push a list in the range [0,10**n] « # Append each to the second (implicit) input-integer `m` ¹ù # Only keep the integers with a length equal to the first input `n` ʒ # Filter it further by keeping those: p # That are primes # (after which the filtered list is output implicitly as result) Iš # (prepend the second input-integer `m` to the list; if the length of `m` is # equal to `n`, the final result will be `[m]` iff `m` is a prime, or an # empty list otherwise) 

Python, 105 bytes

lambda n,m:[p for p in primerange(10**n+1)if n==len(d:=str(p))and(s:=str(m))<=d<s+'~'] from sympy import* 

Attempt This Online!