Ruby, 61 59 bytes

->n{s='AAAA000';eval's.succ!;'*n;[s[0,2],s[4,3],s[2,2]]*?-}

Also 59 bytes:

->n{s='AAAA000';eval's.succ!;'*n;s[1]+=?-+s[4,3]+?-;s[0,9]}

The crux of both of these is the same -- they initialize a counter to AAAA000, increment it n times (by multiplying a string of the code that does so by n and evaling), and then adjust the string to fit the format requested (in two different ways).

Try it online!

JavaScript (Node.js), 82 bytes

n=>'32-654-10'.replace(/d/g,x=>Buffer([x&4?n/10**(x-4)%10+48:n/1e3/26**x%26+65]))

Try it online!

R, 101 bytes

b=0:3;a=scan()%/%c(10^b,1e3*26^b)%%rep(c(10,26),e=4);intToUtf8(c(a[8:7],-20,a[3:1]-17,-20,a[6:5])+65)

Try it online!

Just does the needed arithmetic computations. I saved 5 bytes by including in the vector a a useless value at a[4], allowing me to reuse the helper vector b.

Perl 5 (-ap), 47 bytes

$_=AAAA000;$_++while$F[0]--;s/(..)(d+)/-$2-$1/

Try it online!

PHP, 74 bytes

for($a=AAAA000;$argn--;$a++);echo preg_replace('/(..)(d+)/','-$2-$1',$a);

Try it online!

Python 3, 79 78 77 bytes

lambda n:f"%c%c-{n%1000:03}-%c%c"%(*(65+n//1000//26**i%26for i in[3,2,1,0]),)

Try it online!

I somehow never realised that the f"string" format shortcut exists until seeing Black Owl Kai's answer.

APL+WIN, 61 bytes

Prompts for integer:

m←⎕av[4↑66+n←((4⍴26),1E3)⊤⎕]⋄(2↑m),'-',(¯3↑'00',⍕4↓n),'-',2↓m

Try it online! Courtesy of Dyalog Classic

PHP, 96 bytes

for($l=$r=AA;$x++<(0^$argn/1e3);)$r>ZY?++$l+$r=AA:$r++;echo"$l-".str_pad($argn%1e3,3,0,0)."-$r";

Try it online!

I take advantage of the fact that you can increment letters in PHP! So AA++ would become AB and AZ++ would become BA. I calculate how many times the letters have to be incremented by getting integer part of input/1000. Then then increment right side if it is less than ZZ, else increment left side and reset right side to AA. At the end the middle number is calculated by input%1000 and padded with zeros in the left.

PHP, 98 bytes

for($l=$r=AA;$argn--;)$n>998?($n=0)||$r>ZY?++$l+$r=AA:$r++:$n++;echo"$l-".str_pad($n,3,0,0)."-$r";

Try it online!

This is the original idea, similar to the above solution, but the number part itself is incremented too. So basically the loop runs input times. This isn't an optimal solution and becomes slow for large inputs, but this is code golf, so...!

Haskell, 85 81 79 77 bytes

([h++'-':n++'-':t|h<-q"AZ",t<-q"AZ",n<-q"099"]!!)

q g=mapM(_->[g!!0..g!!1])g

Try it online!

Jelly, 28 bytes

ØA,ØDṗ"4,3Œp⁸ịF+2,7¦”-65œ?

A monadic Link accepting an integer (1-indexed) which yields a list of characters... Crazy-slow since it builds all the plates first!

Try it online! (wont complete)

Or try a reduced alphabet version (only "ABC" for the letters).

For code which completes in a timely manner here's a 32 byte full-program (0-indexed):

dȷ+“©L§“£ż’µḢṃØAṙ1¤ḊŒHW€jDḊ€$j”-

Try this one!

Pure Bash (no external utils), 66

f=({A..Z}{A..Z}-%03d-{A..Z}{A..Z})

printf ${f[$1/1000]} $[$1%1000]

Try it online! - takes about 10s to run over the 7 testcases.

• Line #1 is a brace expansion to build an array of printf format strings, one for all 456,976 possible letter combinations, with the digits not yet specified.


• Line #2 indexes the array to get the appropriate format string and takes the digits portion as its parameter.

Charcoal, 33 bytes

Ｎθ¹✂Ｉ⁺θφ±³≔⪪⍘⁺Ｘ²⁶¦⁵÷θφα²η¹⊟ηＭ⁹←⊟η

Try it online! Link is to verbose version of code. Explanation:

Ｎθ

Input the number.

¹

Print a -.

✂Ｉ⁺θφ±³

Add 1000 to the number, then cast the result to string, and print the last three digits.

≔⪪⍘⁺Ｘ²⁶¦⁵÷θφα²η

Divide the number by 1000, then add 26⁵, so the conversion to custom base using the uppercase alphabet results in a string of length 6, which is then split into pairs of letters.

¹

Print a -.

⊟η

Print the last pair of letters.

Ｍ⁹←

Move to the beginning of the number plate.

⊟η

Print the rest of the desired letters.

Python 2, 88 bytes

lambda n:g(n/676000)+'-%03d-'%(n%1000)+g(n/1000)

g=lambda n:chr(65+n/26%26)+chr(65+n%26)

Try it online!

Python 3, 89 bytes

lambda n:h(n//676)+f"-{n%1000:03}-"+h(n)

h=lambda x:'%c%c'%(x//26000%26+65,x//1000%26+65)

Try it online!

-1 byte thanks to mypetition

J, ⁵⁶ 49 bytes

226950 A.'--',7{._3|.[:,a.{~65 48+/(4 3#26 10)#:]

Try it online!

The whole thing is nothing but 8 nested trains -- if that ain't fun, what is?

  ┌─ 226950                                                       

  ├─ A.                                                           

  │        ┌─ '--'                                                

──┤        ├─ ,                                                   

  │        │      ┌─ 7                                            

  └────────┤      ├─ {.                                           

           │      │    ┌─ _3                                      

           └──────┤    ├─ |.                                      

                  │    │    ┌─ [:                                 

                  └────┤    ├─ ,                                  

                       │    │    ┌─ 'abc...'                      

                       └────┤    ├─ ~ ──────── {                  

                            │    │                                

                            └────┤          ┌─ 65 48              

                                 │          ├─ / ───── +          

                                 └──────────┤                     

                                            │       ┌─ '4 3#26 10'

                                            └───────┼─ #:         

                                                    └─ ]          

Clean, 107 bytes

import StdEnv

A=['A'..'Z']

N=['0'..'9']

$n=[[a,b,'-',x,y,z,'-',c,d]\a<-A,b<-A,c<-A,d<-A,x<-N,y<-N,z<-N]!!n

Try it online!

Defines $ :: Int -> [Char] giving the n-th zero-indexed licence plate.