Esto es esencialmente lo contrario de Generar una matrícula de EE. UU.

Desafío: dada una cadena que coincide con uno de los formatos de matrícula siguientes, genera todos los estados posibles que coinciden con ese formato. En la tabla a continuación 0representa un solo dígito 0hasta el 9inclusivo y Arepresenta una sola letra Ahasta el Zinclusivo Para los propósitos de este desafío, ignoramos los estados con reglas de formato complejas (como Delaware, que tiene un número variable de dígitos) e ignoramos la eliminación de letras similares (por ejemplo, Iy 1).

AAA 000: AK, IA, MS, MP, VT
0000: AS
AAA0000: AZ, GA, WA
000 AAA: AR, KS, KY, LA, ND, OR
0AAA000: CA
AA-00000: CT
AA-0000: DC
AAA A00: FL
AA 00000: IL
000A,000AA,000AAA,AAA000: IN
0AA0000: MD
AAA 0000,0AA A00,AAA 000: MI
000-AAA: MN
00A-000: NV
000 0000: NH
A00-AAA: NJ
000-AAA,AAA-000: NM
AAA-0000: NY, NC, PA, TX, VA, WI
AAA 0000: OH
000AAA: OK
AAA-000: PR
000-000: RI
AAA 000,000 0AA: SC
A00-00A: TN
A00 0AA: UT

Ejemplos:

B32 9AG
[UT]

1YUC037
[CA]

285 LOR
[AR, KS, KY, LA, ND, OR] (in any order)

285-LOR
[MN, NM] (in any order)

285LOR
[IN, OK] (in any order)

Reglas y aclaraciones

• La cadena de entrada está garantizada como no vacía y se garantiza que sea de uno de los formatos anteriores
• El comportamiento si se le da un formato diferente al anterior no está definido
• La entrada y salida se pueden dar por cualquier método conveniente
• Puede imprimir el resultado en STDOUT o devolverlo como resultado de una función
• Un programa completo o una función son aceptables
• Las lagunas estándar están prohibidas
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes)

JavaScript (ES6),  203 202 201  200 bytes

Guardado 1 byte gracias a @NahuelFouilleul

s=>'xMiAZGAWaMIOhNvInxMNNmARKSKYLANDOrNMPrAKIAMIMSMPSCVtAsMdxScRiNhUtDcCtxFlxNYNCPATXVAWiInIlINOkNjCaTn'.match(/[A-Z]*./g)[s.replace(/./g,c=>c<'!'?0:1/c?9:6-~(c+1))*3%47%30].toUpperCase().match(/../g)

Pruébalo en línea!

¿Cómo?

Conversión de entrada

$n$

• $0$
• $9$
• $7$
• $6$

Como código JS:

c < '!' ?        // if c is a space:
  0              //   replace it with 0
:                // else:
  1 / c ?        //   if c is a digit:
    9            //     replace it with 9
  :              //   else:
    6 - ~(c + 1) //     if c is a hyphen, this gives:
                 //       6 - ~('-1') --> 6 - 0 --> 6
                 //     if c is a letter (e.g. 'A'), this gives:
                 //       6 - ~('A1') --> 6 - ~NaN --> 6 - (-1) --> 7

Función hash

Luego aplicamos la siguiente función hash:

$[1..29]$000AAAAA000$24$

 format     | n        | * 3       | mod 47 | mod 30 | states
------------+----------+-----------+--------+--------+----------------------
  'AAA 000' |  7770999 |  23312997 |   10   |   10   | AK,IA,MI,MS,MP,SC,VT
     '0000' |     9999 |     29997 |   11   |   11   | AS
  'AAA0000' |  7779999 |  23339997 |   32   |    2   | AZ,GA,WA
  '000 AAA' |  9990777 |  29972331 |    8   |    8   | AR,KS,KY,LA,ND,OR
  '0AAA000' |  9777999 |  29333997 |   28   |   28   | CA
 'AA-00000' | 77699999 | 233099997 |   19   |   19   | CT
  'AA-0000' |  7769999 |  23309997 |   18   |   18   | DC
  'AAA A00' |  7770799 |  23312397 |   21   |   21   | FL
 'AA 00000' | 77099999 | 231299997 |   25   |   25   | IL
     '000A' |     9997 |     29991 |    5   |    5   | IN
    '000AA' |    99977 |    299931 |   24   |   24   | IN
   '000AAA' |   999777 |   2999331 |   26   |   26   | IN,OK
   'AAA000' |   777999 |   2333997 |   24   |   24   | IN
  '0AA0000' |  9779999 |  29339997 |   12   |   12   | MD
 'AAA 0000' | 77709999 | 233129997 |   33   |    3   | MI,OH
  '0AA A00' |  9770799 |  29312397 |    1   |    1   | MI
  '000-AAA' |  9996777 |  29990331 |    7   |    7   | MN,NM
  '00A-000' |  9976999 |  29930997 |   34   |    4   | NV
 '000 0000' | 99909999 | 299729997 |   46   |   16   | NH
  'A00-AAA' |  7996777 |  23990331 |   27   |   27   | NJ
  'AAA-000' |  7776999 |  23330997 |    9   |    9   | NM,PR
 'AAA-0000' | 77769999 | 233309997 |   23   |   23   | NY,NC,PA,TX,VA,WI
  '000-000' |  9996999 |  29990997 |   15   |   15   | RI
  '000 0AA' |  9990977 |  29972931 |   44   |   14   | SC
  'A00-00A' |  7996997 |  23990991 |   29   |   29   | TN
  'A00 0AA' |  7990977 |  23972931 |   17   |   17   | UT

Codificación de estado

Todos los patrones de estado se unen en una sola cadena, y cada patrón termina con una letra minúscula. Las ranuras vacías se llenan con un arbitrario x.

[ [], [ 'MI' ], [ 'AZ', 'GA', 'WA' ], [ 'MI', 'OH' ], ... ] --> 'xMiAZGAWaMIOh...'

match(/[A-Z]*./g)$f(n)$

Finalmente, el patrón en sí mismo se convierte en mayúsculas y se divide en grupos de 2 caracteres.

T-SQL, 475 bytes

SELECT STUFF(value,1,8,'')
FROM STRING_SPLIT('000 0000NH|000 055 SC|000 555 AR,KS,KY,LA,ND,OR|0000    AS|000-000 RI|0005    IN|00055   IN|000555  IN,OK|000-555 MN,NM|005-000 NV|055 500 MI|0550000 MD|0555000 CA|500 055 UT|500-005 TN|500-555 NJ|55 00000IL|55-0000 DC|55-00000CT|555 000 AK,IA,MI,MS,MP,SC,VT|555 0000MI,OH|555 500 FL|555000  IN|555-000 NM,PR|5550000 AZ,GA,WA|555-0000NY,NC,PA,TX,VA,WI','|')
,i WHERE v LIKE TRIM(REPLACE(REPLACE(LEFT(value,8),5,'[A-Z]'),0,'[0-9]'))

Los saltos de línea son solo para legibilidad.

Limitado a SQL 2017 o superior mediante el uso de la TRIMfunción. SQL 2016 (requerido para STRING_SPLIT), es posiblemente sustituyendo RTRIMal costo de 1 byte.

$i$$v$

Básicamente estoy haciendo una LIKEcoincidencia inversa : expando el patrón de cada placa a una cadena de coincidencia de patrón comodín completa como '[A-Z][0-9][0-9] [0-9][A-Z][A-Z]', luego comparo con el valor de entrada y devuelvo los estados coincidentes (que se combinan en un solo campo).

Podría ahorrar algo más de espacio GZIP'ing la larga cadena; Veré si eso ayuda ...

Perl 5 (-p) , 165 bytes

La respuesta Javascript del puerto de @ Arnauld, también lo votó.

y/0-8/9/;y/- A-Z/607/;$_=('xMiAZGAWaMIOhNvInxMNNmARKSKYLANDOrNMPrAKIAMIMSMPSCVtAsMdxScRiNhUtDcCtxFlxNYNCPATXVAWiInIlINOkNjCaTn'=~/[A-Z]*./g)[$_*3%47%30];s/../\U$& /g

Pruébalo en línea!

Carbón , 177 bytes

§⪪”}∧▶⧴βμÞ∕×peＨ✂d‽n➙ＭR⁶↙↷◨5⁶;πＮM﹪θＷ:¡✂⧴O^(P↷kⅉχＲ⁺≔º↶∨§º⊞Ｂ⎚×p↔Ｌ\`²‖6'⁶⁹‴XüR⦃N4U⊙ＹＦ⁻ＺＭχLＳ⁸ＣX\hγ”;⌕⪪”{⊟“◨⦄»Ｕ>⌕⁻9“]±R▷Ｑ↔θü&$▷l⁹Ｚ⁼¡⁷×À›¶aA*βＺ³δ¡⟲²Y«№⌕TμN»πX·ＳΣ"εl⊙=3✂S?Ｋ”;⭆Ｓ⎇№αιA⎇Σι⁰ι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

                 Ｓ              Input string
                ⭆               Map over characters and join
                  ⎇             If
                     ι          Current character
                   №α           Is an uppercase letter
                      A         Then literal string `A`
                       ⎇        Else if
                         ι      Current character
                        Σ       Is non-zero
                          ⁰     Then digit `0`
                           ι    Else original character
        ⌕                       Find index in
          ”...”                 Compressed string of plates
         ⪪     ;                Split on semicolons
§                               Index into
  ”...”                         Compressed string of states
 ⪪     ;                        Split on semicolons
                                Implicitly print

¡Pruebe todos los casos de prueba!El enlace es a la versión detallada del código. (Se necesita un código ligeramente diferente para procesar múltiples casos).

Como era de esperar, un puerto de la solución de @ Arnauld es mucho más corto con solo 121 bytes:

§⪪”}∧↨¦↑↧‴q⁰mπi3ＪE⪫³yＳ⪪c)？0≦·ê⊞Þ«ⅉ⁺&±<pAＲιaγ1A↑1L¶⟧/)Vº;Π∧,b✂≦¤ⅉαX⊕|″IνB[w∕¦Ｈ´Gγ§ν⟲^π!⪪¶ςbFü⊟»2”;﹪׳Ｉ⭆Ｓ⎇№αι⁷⎇⁼ι ⁰⎇⁼ι-⁶9⁴⁷

Pruébalo en línea! El enlace es a la versión detallada del código. El segundo módulo por 30 está implícito en la indexación en la matriz.

Python 3 , 382 378 bytes

import re;f=lambda p,l='[A-Z]',r=re.sub,f=re.findall:f(l+'{2}',f(r(l,'1',r('[0-9]','0',p))+l+'+','0000AS0001IN00011IN000111INOK111000IN000 011SC000 111ARKSKYLANDOR000-000RI000-111MNNM001-000NV011 100MI0110000MD0111000CA100-001TN100-111NJ11-0000DC111 100FL111 000AKIAMIMSMPSCVT111-000NMPR1110000AZGAWA11 00000IL11-00000CT111 0000MIOH111-0000NYNCPATXVAWI1100 011UT000 0000NH')[0])

Pruébalo en línea!

Reemplaza números con 0y letras con1 , luego busca en la cadena el plato seguido de una cadena de letras. Luego, simplemente devuelve cada par de letras que no se superponen en esa cadena.

No es el byte más eficiente, pero es un buen comienzo (tal vez).

Disfruto de los desafíos basados ​​en información que no se puede generar.

05AB1E , 176 bytes

•1–ºʒÉQ÷¦PαN]lā?¨ìÎ₆™@ΔîÅλEŸʒ»ú<ŧa–½ã…ôkƒ¼½Ü%-ò∊aÍÙ•44374в4вε©gIgQi…'-Q'd'a„ðQ)VIεY®Nèè.V}Pë0].•=#îYn«ÈO4êʒIWj∊bÛˆ_ãZÑ"yŠótм‰иÔN–HδÖc°ìSJ9Ç\}ζÎäǝÑïÒ∞V.÷ζkÚ"¿Õнα£!ɪB…žä•#sÏ`2ô

Pruébalo en línea!

•1–ºʒÉQ÷¦PαN]lā?¨ìÎ₆™@ΔîÅλEŸʒ»ú<ŧa–½ã…ôkƒ¼½Ü%-ò∊aÍÙ•44374в4в
                        push all patterns as base 4 integers (0="-", 1=number, 2=letter, 3=" ")

ε                       for each pattern
  ©                       copy it for later use inside another for for-loop
  gIgQi                   if it has the same length, as input
    …'-Q'd'a„ðQ)V           store ["'-Q", "d", "a", "ðQ"] in Y (05AB1E codes for "equals '-', is positive, is letter and equals ' ')
    Iε                      for each letter of input
      Y®Nèè                   get the 05AB1E code corresponding to the current index of the pattern
      .V                      run it
    }
    P                       check if all positions of that pattern were true
  ë                       else
    0                       push false
]

.•=#îYn«ÈO4êʒIWj∊bÛˆ_ãZÑ"yŠótм‰иÔN–HδÖc°ìSJ9Ç\}ζÎäǝÑïÒ∞V.÷ζkÚ"¿Õнα£!ɪB…žä•#
                        push list of states matching the pattern

sÏ                      get the entry of that list, that is true in the other list
`2ô                        split into groups of 2 letters and print