¡Abrevia ese estado de EE. UU.!

50

Dado uno de los 50 nombres de estado de EE. UU. A la izquierda como entrada, envíe su código postal de dos letras como se muestra a la derecha:

Alabama         AL
Alaska          AK
Arizona         AZ
Arkansas        AR
California      CA
Colorado        CO
Connecticut     CT
Delaware        DE
Florida         FL
Georgia         GA
Hawaii          HI
Idaho           ID
Illinois        IL
Indiana         IN
Iowa            IA
Kansas          KS
Kentucky        KY
Louisiana       LA
Maine           ME
Maryland        MD
Massachusetts   MA
Michigan        MI
Minnesota       MN
Mississippi     MS
Missouri        MO
Montana         MT
Nebraska        NE
Nevada          NV
New Hampshire   NH
New Jersey      NJ
New Mexico      NM
New York        NY
North Carolina  NC
North Dakota    ND
Ohio            OH
Oklahoma        OK
Oregon          OR
Pennsylvania    PA
Rhode Island    RI
South Carolina  SC
South Dakota    SD
Tennessee       TN
Texas           TX
Utah            UT
Vermont         VT
Virginia        VA
Washington      WA
West Virginia   WV
Wisconsin       WI
Wyoming         WY

Reglas

  • La entrada y la salida son sensibles a mayúsculas y minúsculas. Puede que no salgas, por ejemplo, Alpara Alabama.
  • Puede suponer que la entrada es uno de los 50 nombres de estado que se muestran arriba.
  • No puede acceder a Internet ni utilizar datos de estado integrados (mirándolo, Mathematica).

Se pueden encontrar listas separadas de entradas y salidas en este fragmento (no lo ejecute, es solo para comprimir la publicación):

Mostrar fragmento de código

(Sin puntuación) Puntos Brownie si también puede tomar District of Columbiacomo entrada y producir DC, Islas Vírgenes, etc.

Puntuación

Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma .

(Originalmente propuesto por ETHProductions)

code-golf string kolmogorov-complexity state-abbreviation Steve Bennett
fuente
11
Para aquellos curiosos por conocer el enfoque de Mathematica:Entity[a="AdministrativeDivision",{#,"UnitedStates"}]@EntityProperty[a,"StateAbbreviation"]&
DavidC
12
@BetaDecay Las preguntas que están cerradas como fuera de tema no son objetivos de engaño útiles.
Mego
77
@DavidC Puede guardar 20bytes: Entity["AdministrativeDivision",{#,"UnitedStates"}]@"StateAbbreviation"&:)
ngenisis
2
Ofrecer crédito adicional por incluir los otros 12 códigos de dos caracteres en la lista oficial completa de abreviaturas postales de EE. UU .: AA (FUERZAS ARMADAS AMERICAS), AE (FUERZAS ARMADAS EUROPA), AP (FUERZAS ARMADAS PACÍFICAS), AS (SAMOA AMERICANA), DC (DISTRITO DE COLUMBIA), FM (ESTADOS FEDERADOS DE MICRONESIA), GU (GUAM), MH (MARSHALL ISLANDS), MP (NORTHERN MARIANA ISLANDS), PR (PUERTO RICO), PW (PALAU), VI (VIRGIN ISLANDS).
Joe Snyder
2
Sí, esto no es un tonto.
Christopher

Respuestas:

25

Javascript, 124117 bytes

(guardado 7 bytes gracias a hvd)

x=>/.+[A-Z]|A..[sz]k?|M.ss.s?|M[io]n?t?|Nev?|[AFIOUW][^o]|T..|.+/.exec(x)[0].replace(/(.).*(.)/,'$1$2').toUpperCase()

Explicación:

  • La expresión regular encuentra una coincidencia con la primera y la última letra de las dos letras de la abreviatura
  • La primera parte coincide con estados con más de dos palabras (incluido el Distrito de Columbia)
  • Segunda parte coincide con Alaska y Arizona
  • La tercera parte coincide con Massachusets, Mississippi y Missouri
  • Cuarta parte coincide con Michigan, Minnesota y Montana
  • La quinta parte coincide con Nebraska y Nevada
  • La sexta parte coincide con todos los estados restantes abreviados a sus dos primeras letras, con un caso especial para excluir a Iowa
  • La séptima parte coincide con todos los estados restantes abreviados a sus letras primera y tercera
  • La octava parte coincide con todo lo demás, que se abrevian con su primera y última letra
  • Entonces es solo un caso de despojo de esas letras y mayúsculas
  • También coincide con Puerto Rico y Samoa Americana, pero no con Guam, las Islas Marianas o las Islas Vírgenes de EE. UU.
HP Williams
fuente
¡Wow esto es genial! +1!
NoOneIsHere
3
¡Agradable! Algunas oportunidades más: la inicial [A-Z]no es necesaria ya que se sabe que la entrada es válida. El caso especial de Iowa puede acortarse [AFIOUW][^o]para excluirlo y dejarlo para la final .+.
hvd
1
Su maquinaria de expresiones regulares es tan eficiente en comparación con la mía ... desearía que hubiera una manera de hacer que funcione con mi expresión regular más corta. Pero están construidos sobre principios tan diferentes.
Steve Bennett
1
Bueno, hay bastantes que son raros a su manera. Hay una buena colección que coincide con las reglas "primero y último" y "dos primeros" (Colorado, Delaware, California ...), pero luego Mississippi (MS) la arruina.
Steve Bennett
1
101: s=>s[0]+/.+[A-Zz]|Nev?|.*sk|M.ss.s?|M[io]n?t?|[AFIOUW][^o]|Te.|.+/.exec(s)[0].slice(-1).toUpperCase()¿Podemos llegar a 100? :)
Steve Bennett
22

Javascript, 137 135 134 132 113 110 108 101 99 94 93 92 bytes

Esto se basa en la solución HP Williams, con algunas mejoras fuera de la expresión regular y un par de ajustes dentro de ella.

s=>s[0]+
/.*( .|z)|...s.s?|T..|M[i-t]+|[AFINOUW][^o]v?|.*/
.exec(s)[0].slice(-1).toUpperCase()

(Saltos de línea solo para legibilidad)

Comentario para la expresión regular:

.*( .|z)|      // Two-or-three word states, plus Arizona
...s.s?|       // Mississippi, Missouri, Massachussetts, Alaska, and (non-harmfully) Kansas
M[i-t]+|       // Montana, Minnesota, Michigan
[AFINOUW][^o]v?|  // All the other first-two-letter states, avoiding Iowa, plus Nevada
T‌​..|           // Tennessee, Texas
.+             // Everything else is first-and-last

Regex alternativo sin sentido (misma longitud):

/...(a$|z|s.s?|.* .)|M[i-t]+|T..|[AFINOUW].v?|.*/

Historia

94

s=>s[0]+/.*( .|z)|...s.s?|M[io]n?t?|[AFIOUWN][^o]v?|T..|.*/
.exec(s)[0].slice(-1).toUpperCase()

99

s=>s[0]+/.*( .|z|l.*k)|T..|M.ss.s?|M[io]n?t?|[AFIOUWN][^o]v?|.*/
.exec(s)[0].slice(-1).toUpperCase()

101

s=>s[0]+/.+[A-Zz]|Nev?|.*sk|M.ss.s?|M[io]n?t?|[AFIOUW][^o]|T‌​e.|.+/
.exec(s)[0].sl‌​ice(-1).toUpperCase(‌​)

108

 s=>s[0]+/MI(N|SSO|S)|[CDGHKLPV].*|.* .|.*[XZV]|.*?N[NTE]|.*(SK|D$|WA)|../
.exec(s.toUpperCase())[0].slice(-1)

110

s=>s[0]+/MI(N|SSO|S)|[CGHKLPV].*|.* .|.*[XZV]|.*?N[NTE]|.*(SK|[ED]$|WA)|../
.exec(s.toUpperCase())[0].slice(-1)

113

s=>s[0]+/^MI(N|SSO|S)|^[CGHKLPV].*|.*?( .|[XZV])|.*?N[NTE]|.*(SK|[ED]$|WA)|../
.exec(s.toUpperCase())[0].slice(-1)

132

s=>(S=s.toUpperCase(),' ._SSO_^MI[NS]_^[CGHKLPV].*_.V_N[TNE]_SK_[ED]$_WA_Z_X_..'
.split`_`.some(p=>s=S.match(p)),S[0]+s[0].slice(-1))

134

s=>' ._SSO_^MI[NS]_^[CGHKLPV].*_.V_N[TNE]_SK_E$_D$_WA_Z_X_..'.split`_`
.map(p=>s=(z=s.toUpperCase().match(p))?s[0]+z[0].slice(-1):s)&&s

135

s=>' ._SSO_^MI[NS]_LASK_^[CGHKLPV].*_NT_EN_[DE]$_WA_.[XVZ]_..'.split`_`
.map(p=>s=(z=s.toUpperCase().match(p))?s[0]+z[0].slice(-1):s)&&s

137

s=>' ._OWA_SSO_ONT_^MI[NS]_LASK_^[CGHKLPV].*_EN_[DE]$_.[XVZ]_..'.split`_`.
map(p=>s=(z=s.toUpperCase().match(p))?s[0]+z[0].slice(-1):s)&&s
Steve Bennett
fuente
Esto es una locura, desearía poder votar de nuevo.
ETHproductions 01 de
¡No mires ahora! 99!
Steve Bennett
94. Totalmente loco. Descubrí esta optimización ( ...s.s?captura Mississippi, Missouri, Massachussetts y Alaska) por accidente. En realidad, estaba en el proceso de mover el .*skfragmento a otro lugar, y las pruebas simplemente pasaron y pasaron, mientras que el fragmento no estaba presente en ninguna parte. ¡La ganancia de 5 personajes más fácil!
Steve Bennett
Wow, y me acabo de dar cuenta de que ...s.s?también coincide inadvertidamente con Kansas y, por milagro, sigue dando el resultado correcto.
Steve Bennett
Y un personaje más con M[onti]+. Tan extraño: si el estado comienza con M, entonces la segunda letra es la última en una secuencia de al menos una o, n, t, o i. Una forma muy extraña de capturar Michican, Minnesota o Montana.
Steve Bennett
20

JavaScript (ES6), 156 136 bytes

s=>s[0]+'.KT..N.VEA.XVL.H.TZ.AA..I.EADATO.JTISRDIYOI.DALA.Y.KE.C.D.R.YAS.NM...C.L...N'[parseInt(s.split` `.join``,36)%359%248*8%99*3%83]

Manifestación

Mostrar fragmento de código

Arnauld
fuente
1
¿Se aplica esta fuerza bruta para que sea óptima con este método?
Solo ASCII
2
@ Solo ASCII Esto se aplica de forma bruta en rangos arbitrales, por lo que solo se garantiza que sea óptimo para X MOD[50-1000] MOD[50-1000] MOD[50-100]. Pero .slice(1)fue un error. Actualmente se ejecuta nuevamente en toda la cadena.
Arnauld
2
¿Podrías explicarle a un newb qué hace esto?
Hankrecords
1
@ Hankrecords Claro, lo haré. (Pero estoy en un tren con acceso limitado a Internet en este momento.)
Arnauld
1
ahora el mio es 135!
Steve Bennett,
17

Jalea , 75 bytes

³Oḅ⁹%⁽qġ%14ị⁽"wB¤Ḥ
“¿ØƈṢḍw÷S=)µZṂ÷ĿæÆɱ»Ḳiµ%2+3¢⁸?
e“\B“½ƈN»ȧ5ȯÇ’
i⁶ȯÇ‘ịṭḢŒu

Pruébalo en línea!

... o vea un conjunto de pruebas : tenga en cuenta que se tuvo que hacer un pequeño cambio para ejecutar el programa completo para múltiples entradas de una sola vez (cambié el átomo de entrada del programa ³, para recuperarlo del registro ®, uno y configuré el registro a cada nombre de estado a su vez).

¿Cómo?

Calcula el índice que se utilizará para el segundo carácter del código postal, lo agrega al primer carácter y pone en mayúscula el resultado.

Primero encuentra el índice de un carácter de espacio (o 0 si no se encuentra);

Else comprueba si es Alaska o Missouri (con un rendimiento de 5 por ko o);

Else encuentra el índice del estado de entrada en la lista Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(o 0 si no se encuentra); de ser así, toma ese índice mod 2 más 3 (para z n s v t x n);

De lo contrario, convierte la cadena en ordinales, convierte eso de la base 256, encuentra el resto de eso después de dividir por 29487, encuentra el resto de eso después de dividir por 14 y lo usa para indexar en la representación binaria de 9620 y duplica el resultado, produciendo 0 para los estados que usan su letra final y 2 para aquellos que usan su segunda letra.

Todos menos el primer caso se incrementan, y el valor resultante se reduce (aumentando el índice de espacio encontrado por uno).

i⁶ȯÇ‘ịṭḢŒu - Main link: state string
 ⁶         - space character
i          - first index (of a space character in the state) or 0 if not found  (n-1 or 0)
   Ç       - call link 3 as a monad  (get n-1 in other cases)
  ȯ        - logical or  (yielding n-1)
    ‘      - increment   (yielding n)
     ị     - index into the state string (get the nth character)
       Ḣ   - head the state string (get the first character)
      ṭ    - tack
        Œu - convert to uppercase
           - implicit print

e“\B“½ƈN»ȧ5ȯÇ’ - Link 3: n-5 or ... : state string
 “\B“½ƈN»      - ["Alaska","Missouri"]
e              - exists in? (1 if so, 0 if not)
          5    - 5
         ȧ     - logical and
            Ç  - call link 2 as a monad
           ȯ   - logical or
             ’ - decrement

“¿ØƈṢḍw÷S=)µZṂ÷ĿæÆɱ»Ḳiµ%2+3¢⁸? - Link 2: n = 3 or n = 4 or ... : state string
“¿ØƈṢḍw÷S=)µZṂ÷ĿæÆɱ»           - "Arizona Minnesota Mississippi Nevada Montana Texas Tennessee"
                    Ḳ          - split at spaces
                     i         - first index of state string in that list or 0
                      µ        - monadic chain separation (call that i)
                             ? - if: 
                            ⁸  -   link's left argument, i
                               - then:
                       %2      -   mod 2
                         +3    -   plus 3  - odd entries to 4: AriZona, MisSissippi, MonTana, TenNessee
                               -            even entries to 3: MiNnesota, NeVada, TeXas
                               - else:
                           ¢   -   call link 1 as a nilad

³Oḅ⁹%⁽qġ%14ị⁽"wB¤Ḥ - Link 1 ...n=2 or n=0: no arguments
³                  - program's 1st input    e.g. Iowa          or Ohio
 O                 - cast to ordinals            [73,111,119,97]  [79, 104, 105, 111]
   ⁹               - 256
  ḅ                - convert from base           1232041825       1332242799
     ⁽qġ           - 29487
    %              - modulo                      15991            20139
        %14        - modulo 14                   3                7
                ¤  - nilad followed by link(s) as a nilad:
            ⁽"w    -   9620                     V       V
               B   -   convert to binary = [1,0,0,1,0,1,1,0,0,1,0,1,0,0]
           ị       - index into                  0                1
                 Ḥ - double                      0                2
                   -   ...0th index of Iowa is 'a', 2nd of Ohio is 'h'
Jonathan Allan
fuente
1
Esta es la gelatina más larga que he visto =)
caird coinheringaahing
11

Python 2 , 191 bytes

lambda s:s[0]+("KZD"*5+"HNTD"*5+"AYY"*4+"__L_O_VTA_I__A_T_RS_KA__S_"+"MOO"*5+"I_C_"+"AE"*6+"_I_D__A_"+"EDL"*5+"HV_A"+"IR"*7+"XC"*6+"E____N__YJ_YT___L")[reduce(lambda a,x:a+ord(x)^24,s,0)%174]

Pruébalo en línea!

Utiliza una función hash simple para encontrar el segundo carácter de la abreviatura.

Solo ASCII
fuente
11

Python 2, 94 90 bytes

lambda s:s[0]+s[(19**9*0x4710b8f6019c1b61deca10eef13b1>>hash(s)%8199472%52*3&7)+1].upper()

Pruébalo en línea

(Solo Python 2 porque los hashes de Python 3 no son estables y tampoco puedes hacer un hash de una cadena sin convertirla en bytes).

Funciona con los 50 estados, además de un bono del Distrito de Columbia y Puerto Rico.

Sería posible guardar un byte escribiendo el número en base 36: int("5clu7x0aixb0pelmpugv5iiibphrpf",36). Estoy esperando para ver si puedo pensar en una solución más creativa.

Actualizar:

Como hay 12 posiciones de dígitos no utilizados en el hash, hay 2 36 números posibles que funcionarán. Parecía razonable creer que uno de ellos tendría un factor primo con un gran exponente. Para cualquier primo y exponente dado, encontrar un valor es bastante rápido; Logré encontrar uno con un factor de 19 9 , reduciendo el tamaño de la expresión necesaria para representar el número en cuatro bytes.

Este es básicamente el mismo procedimiento que mi respuesta C pero usando Python. Como la función hash básica es diferente, tuve que encontrar una función de reducción diferente, que resulta ser mod 52 en lugar de mod 54. Pero los mayores ahorros sobre C provienen de la posibilidad de usar bignums para codificar el vector, y por supuesto El hecho de que el estándar para Python parece ser que está bien usar un literal lambda en lugar de un programa completo.

rici
fuente
9

Retina , 113 81 80 77 70 68 bytes

M1!`.+[A-Zz]|...s.s?|M[io]n?t?|[AFIOUWN][^o]v?|T..|.*
\B.*(?=.)

T`l`L

Pruébalo en línea! Incluye los 51 casos de prueba. Se ahorraron 32 bytes al apropiarse de la expresión regular de @ JörgHülsermann que encuentra la segunda letra (con un ajuste para admitir DC; editar: guardado 1 byte gracias a @ JörgHülsermann). Ahorró 3 bytes al cambiar a la expresión regular de @ SteveBennett de su comentario a la respuesta de @ HPWilliam. Guardado 7 9 bytes gracias de nuevo a @SteveBennett. Las otras letras se eliminan y la cadena se pone en mayúscula.

Neil
fuente
Muy bien, no habría pensado que podría obtener un conjunto de cadenas totalmente extraíbles.
colsw
@ConnorLSW efue el más problemático, de verdad.
Neil
@ JörgHülsermann Gracias por el favor de devolución!
Neil
@ JörgHülsermann Oh, ¿entonces podré guardar otro byte?
Neil
1
Espera, Indiana se convierte en ID. Probablemente pueda solucionarlo simplemente agregando $ después de d. (Es posible que desee utilizar las pruebas automáticas. Tengo un script que comprueba constantemente los 50 casos)
Steve Bennett,
8

PHP> = 7.1, 113 bytes

<?=($a=$argn)[0],ucfirst(preg_match('#[vxz]| .|owa|lask|[CGHKLPV].*|ssi?.|n(n|t|[de]$)#',$a,$t)?$t[0][-1]:$a[1]);

Versión en línea

Las huelgas se igualan a través de un comienzo anterior antes

([vxz])coincide con Arizona, Nevada, Nuevo México, Pensilvania, Texas,

(.) (un espacio antes) coincide con New Hampshire, Nueva Jersey, Nuevo México, Nueva York, Carolina del Norte, Dakota del Norte, Rhode Island, Carolina del Sur, Dakota del Sur, Virginia Occidental

[CGHKLPV].*(.)coincide con California, Colorado, Connecticut, Georgia, Hawái, Kansas, Kentucky, Luisiana, Nuevo Hampshire , Carolina del Norte, Pensilvania, Carolina del Sur , Vermont, Virginia, Virginia Occidental

ow(a) coincidir con Iowa

las(k) partido Alaska

ssi?(.)coincide con Massachusetts, Mississippi, Missouri, Tennessee

n(n|t|[de]$)coincide con Connecticut, Kentucky, Maine, Maryland, Minnesota, Montana, Pennsylvania, Rhode Island, Tennessee, Vermont

No hay coincidencia para estos estados, así que tomamos las dos primeras letras: Alabama, Arkansas, Delaware, Florida, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregón, Utah, Washington, Wisconsin, Wyoming

La primera vez que uso este subpatter Regex ?| con permite almacenar las referencias en uno.

Apoye al Distrito de Columbia

Reemplazar (.)con ([^o])+3 bytes

Pruébalo en línea!

PHP, 150 bytes

<?=($t=preg_replace("#.\K\w+ |las|ri|nec|eorgi|awa|ow|[aio]ni?|e(?=n|v|x)|ntuck|ouisi|a?in|arylan|issi?|nnsylv|erm|irg#","",$argn))[0],ucfirst($t[1]);

Pruébalo en línea! Casos de prueba

Jörg Hülsermann
fuente
3
¿No es n|t|un byte más corto que [nt]|?
Neil
@Neil Sí, lo es. No me he dado cuenta. Gracias
Jörg Hülsermann
7

PHP, 887 854 bytes

<?=array_combine(['Alabama','Alaska','Arizona','Arkansas','California','Colorado','Connecticut','Delaware','Florida','Georgia','Hawaii','Idaho','Illinois','Indiana','Iowa','Kansas','Kentucky','Louisiana','Maine','Maryland','Massachusetts','Michigan','Minnesota','Mississippi','Missouri','Montana','Nebraska','Nevada','New Hampshire','New Jersey','New Mexico','New York','North Carolina','North Dakota','Ohio','Oklahoma','Oregon','Pennsylvania','Rhode Island','South Carolina','South Dakota','Tennessee','Texas','Utah','Vermont','Virginia','Washington','West Virginia','Wisconsin','Wyoming'],['AL','AK','AZ','AR','CA','CO','CT','DE','FL','GA','HI','ID','IL','IN','IA','KS','KY','LA','ME','MD','MA','MI','MN','MS','MO','MT','NE','NV','NH','NJ','NM','NY','NC','ND','OH','OK','OR','PA','RI','SC','SD','TN','TX','UT','VT','VA','WA','WV','WI','WY'])[$argv[1]];

Pruébalo en línea!

Primer temporizador, ¡hurra!

Ivanka Todorova
fuente
1
De esta manera, un poco de golf en la matriz son los valores con espacio o donde se quita la segunda letra correcta. Y $argv[1]se reemplaza con $argn sandbox.onlinephpfunctions.com/code/…
Jörg Hülsermann
@ JörgHülsermann muchas gracias! ¡Realmente disfruto tus respuestas aquí en codegolf php!
Ivanka Todorova
Solo soy un poco de luz contra otras personas aquí. El esfuerzo de aprendizaje es bueno si alguien encuentra una mejora. Espero que respondan más preguntas en el futuro
Jörg Hülsermann
7

C, 945 937 718 711 660 616 bytes

Guardado 219 bytes gracias a ASCII-only.

struct{int*a,b;}m[]={"laba",76,"lask",75,"rizo",90,"rkan",82,"alif",65,"olor",79,"onne",84,"elaw",69,"lori",76,"eorg",65,"awai",73,"daho",68,"llin",76,"ndia",78,"owa",65,"ansa",83,"entu",89,"ouis",65,"aine",69,"aryl",68,"assa",65,"ichi",73,"inne",78,"issi",83,"isso",79,"onta",84,"ebra",69,"evad",86,"ew H",72,"ew J",74,"ew M",77,"ew Y",89,"orth",67,"orth",68,"hio",72,"klah",75,"rego",82,"enns",65,"hode",73,"outh",67,"outh",68,"enne",78,"exas",88,"tah",84,"ermo",84,"irgi",65,"ashi",65,"est ",86,"isco",73,"yomi",89};
i;char b[99];main(){gets(b);putchar(*b);for(;m[i].a;i++)if(!strncmp(m[i].a,b+1,4))puts(&m[i].b);}

Nueva línea innecesaria, solo para fines de visualización. Toma el estado como entrada. Pruébalo en línea!

Cómo funciona:

  • struct{int*a,b;}m[]=...declara un mapa mcon dos valores: una cadena de cuatro bytes y un carácter. Esto se usa en el ciclo de comparación, que compara los índices segundo a quinto con char*aen el mapa.
  • gets(b)Lee una cadena b. Este será el estado para abreviar.
  • putchar(*b) imprime el primer carácter de esa cadena, ya que cada abreviatura comienza con la primera letra del estado.
  • for(;m[i].a;i++)recorre cada valor del mapa. (Esto podría acortarse).
  • if(!strncmp(m[i].a,b+1,4))compara el valor del mapa actual con los caracteres segundo a quinto de b(el estado para abreviar). Esto se debe a que las únicas diferencias están en los primeros cinco caracteres, pero ya hemos impreso el primer carácter.
  • puts(&m[i].b); imprime la segunda letra de la abreviatura (si el nombre del estado coincide con el valor del mapa actual) y una nueva línea.
MD XF
fuente
Esto parece producir resultados incorrectos para los estados Norte * / Sur *.
Felix Dombek
6

C, 148 141 bytes

main(){char s[99];gets(s);printf("%c%c\n",*s,s["-2-1--561-1-62--642138364---4142--1416--67-7131-111-7-246"[*(int*)(s+1)%663694%57]-48]&95);}

*(int*)(s+1)considera el segundo al quinto carácter de la entrada como un número entero; ese entero se divide en 0-56 usando el hash i%663694%57. El valor hash luego se busca en un vector de desplazamientos que representan la ubicación de la segunda letra de la abreviatura. Elegí esos cuatro bytes en particular porque (1) Missouri y Mississippi primero difieren en el quinto carácter y (2) algunos estados tienen solo cuatro caracteres. En C puede usar el byte terminador NUL, pero nada más que eso es confiable. (Esto hace que los dos valores del Norte tengan el mismo valor, así como los dos del Sur. Pero eso no importa porque el desplazamiento asociado es 6 para todos estos).

De hecho, ese hash en particular produce la posición correcta para las segundas letras de las abreviaturas del Distrito de Columbia, Puerto Rico y las "Islas Vírgenes" (escritas de esa manera, no como "Islas Vírgenes de los Estados Unidos", porque el algoritmo insiste en que la primera el carácter de la abreviatura sea el primer carácter del nombre).

Las constantes 663694 y 57 se encontraron con una prueba automatizada; 57 fue el rango de hash más pequeño que encontré. (La primera versión usaba 380085 y 63, pero cuando extendí el rango de prueba encontré la nueva.) Parece que existe un hash ligeramente más pequeño si se agrega un código para "usar el último carácter en el nombre"; desafortunadamente, la sintaxis de C para seleccionar el último carácter es demasiado prolija para que eso sea útil.

Solo hay 8 desplazamientos diferentes, por lo que podrían haberse almacenado en una tabla de búsqueda de 171 bits (3 * 57) con tres bits por entrada. Pero no se me ocurrió una manera de insertar esos bits de manera eficiente en el programa. La codificación hexadecimal requeriría aproximadamente un carácter por cada cuatro bits, más los 0xprefijos. No podría hacerlo mejor que 151 bytes, que es mucho más largo que la versión de cadena. Si los 171 bits pudieran insertarse de alguna manera como octetos sin procesar, ocuparían 22 bytes, por lo que podría haber una solución, pero leer un archivo es torpe.

rici
fuente
4

En realidad , 181 bytes

2"OHCALAGAMAWVFLNVILMNMOMIRINCDEMTMEINWANYTXORNEOKIDAZNMUTNDMDVAKYSDPAARWYNHIAMSALNJAKTNHIKSVTWICOSCCT"╪"âäà♠îÉæô↨→←∟♣áíå*,▓/12│┤94▼╛?DE╞G╚╠╬ST╒WXßb;Θoq╙|⌂"♂┘Z⌠i≈┐⌡MXO;rR5♀ⁿ*:236@%└

Esta solución espera una entrada como una cadena entre comillas.

Pruébalo en línea!

Explicación

Esta solución utiliza la misma estrategia de hashing que mi solución Python 3 . Por brevedad, voy a omitir la explicación de cómo se calcula el hash y por qué se eligió (lea la otra respuesta si desea ese bit).

También por brevedad, voy a dejar de lado el contenido de las cadenas muy largas, ya que de lo contrario la explicación sería ilegible.

2"..."╪"..."♂┘Z⌠i≈┐⌡MXO;rR5♀ⁿ*:236@%└
2"..."╪                                state abbreviations (push the long string, split into length-2 chunks)
       "..."♂┘                         hash values for the state names (a string of CP437-encoded characters, converted to their CP437 ordinals)
              Z                        zip the two lists
               ⌠i≈┐⌡M                  for each pair:
                i                        flatten the pair
                 ≈                       convert hash value to int
                  ┐                      store abbreviation at the register numbered by the hash value
                     X                 discard the now-empty list
                      O                convert input string to list of ASCII ordinals
                       ;rR             range(len(ordinal_list)), reversed
                          5♀ⁿ          5**i mapped over that range
                             *         dot product of powers of 5 and ordinal list
                              :236@%   mod by 236
                                    └  push value in that register
Mego
fuente
3

Python 3 , 230 bytes

lambda s:chr(s[0])+'IA%%L!NOI!M%!E.N!Y.XR.Z$D.I!.D$DA.D%!.HA!LJ%.N%‌​$T.I%!C!T!.HAAT$.A!.‌​VL.V%$CE%%AEK%.T$!.Y‌​.A!.R.Y$O.S%!.K$!.S'‌​.replace('%','$$').r‌​eplace('$','!!').rep‌​lace('!','..')[sum(c‌​*5**i for i,c in enumerate(s[::-1]))%236-5]

Pruébalo en línea!

La entrada se espera como un objeto de bytes (una cadena de bytes, en lugar de una cadena Unicode).

Gracias a Johnathon Allan por una cantidad absurda de bytes.

Explicación

Cada nombre de estado se convierte en un número entero aaplicando el hash a = sum(o*5**i) % 236(donde oes el ordinal ASCII de un carácter y ies su índice en la cadena, contando desde el final). El módulo 236se eligió porque es el módulo más pequeño que hace que todos los valores hash sean distintos para los 50 nombres de estado de EE. UU. Estos hash se asignan a las abreviaturas de estado, y el diccionario resultante (comprimido mediante la sustitución de cadenas) se utiliza para buscar la abreviatura dada un nombre de estado (hash para obtener la clave correspondiente).

Mego
fuente
Ahorre 179 bytes conlambda s:chr(s[0])+'.....IA................L..NOI..M..........E.N..Y.XR.Z....D.I...D....DA.D...........HA..LJ.........N............T.I..........C..T...HAAT.....A...VL.V............CE................AEK.........T.......Y.A...R.Y....O.S...........K.......S'[sum(c*5**i for i,c in enumerate(s[::-1]))%236]
Jonathan Allan
... y otros 51 además de esolambda s:chr(s[0])+'IA%%L!NOI!M%!E.N!Y.XR.Z$D.I!.D$DA.D%!.HA!LJ%.N%$T.I%!C!T!.HAAT$.A!.VL.V%$CE%%AEK%.T$!.Y.A!.R.Y$O.S%!.K$!.S'.replace('%','$$').replace('$','!!').replace('!','..')[sum(c*5**i for i,c in enumerate(s[::-1]))%236-5]
Jonathan Allan
Me sorprende que contar hacia atrás cuesta menos bytes que una función hash que cuenta hacia adelante, pero no puedo encontrar una con un poco de juego
Chris H
1
@ChrisH Pensé que había encontrado uno, pero la cadena comprimida es más cara.
Mego
2

Ruby, 106103 bytes

->s{s[0]+(s=~/ /?$'[0]:s[(j="()6>P_ac;?.O}AFLKMrS".index((s.sum%136%95+32).chr))?j>7?j/4:-1:1]).upcase}

Si la entrada contiene un espacio, la segunda letra de salida es la que está después del espacio. Más...

Hash la suma de todos los caracteres en la entrada para obtener un carácter cuyo índice en la cadena mágica indica el índice de la segunda letra de salida en la cadena de entrada, de acuerdo con la fórmula j>8?j/4:-1(-1 significa el final). Si el hash da un carácter que no está en la cadena mágica, la segunda letra es la segunda letra de entrada.

Como explicación de la cadena mágica, los caracteres hash y los índices de letras que codifican están a continuación. Tenga en cuenta que Delaware aparece a pesar de que la segunda letra lo haría, esto se debe a que su código hash choca con Kentucky. Afortunadamente, la última carta de Delaware es la misma que la segunda.

Letter(index)
Last  (-1)  (-MD    )-VA    6-GA-LA  >-DE-KY    P-PA    _-CT    a-KS    c-VT
3rd    (2)  ;-TN    ?-MN    .-TX     O-NV
4th    (3)  }-MS    A-IA    F-MT     L-AZ
5th    (4)  K-MO    M-AK    r-ME     S-HI

Sin golf en el programa de prueba

a="Alabama
Alaska
Arizona
Arkansas
California
Colorado
Connecticut
Delaware
Florida
Georgia
Hawaii
Idaho
Illinois
Indiana
Iowa
Kansas
Kentucky
Louisiana
Maine
Maryland
Massachusetts
Michigan
Minnesota
Mississippi
Missouri
Montana
Nebraska
Nevada
New Hampshire
New Jersey
New Mexico
New York
North Carolina
North Dakota
Ohio
Oklahoma
Oregon
Pennsylvania
Rhode Island
South Carolina
South Dakota
Tennessee
Texas
Utah
Vermont
Virginia
Washington
West Virginia
Wisconsin
Wyoming".split($/)

f=->s{                                                            #String argument s.
  s[0]+(                                                          #Return character s[0] +
    s=~/ /?$'[0]:                                                 #if s contains a space, 1st character after space, ELSE
      s[(j="()6>P_ac;?.O}AFLKMrS".index((s.sum%136%95+32).chr))?  #if (sum of ascii codes, mod 136 mod 95 +32).chr in the magic string
        j>7?j/4:-1:                                                 #return s[j/4] if j>7 else return s[-1] ELSE
      1]                                                          #if not in the magic string, return s[1].
  ).upcase                                                        #Convert the second character to uppercase if needed.
}


a.map{|i|p [i,f[i]]}
Level River St
fuente
2

/// , 619 608 bytes

/2/~M//@/~South //1/~North //!/~New //~/\/\///Alabama/AL~Alaska/AK~Arizona/AZ~Arkansas/AR~California/CA~Connecticut/CT~Delaware/DE~Florida/FL~Georgia/GA~Hawaii/HI~Idaho/ID~Illinois/IL~Indiana/IN~Iowa/IA~Kansas/KS~Kentucky/KY~Louisiana/LA2aine/ME2aryland/MD2assachusetts/MA2ichigan/MI2innesota/MN2ississippi/MS2issouri/MO2ontana/MT~Nebraska/NE~Nevada/NV!Hampshire/NH!Jersey/NJ!Mexico/NM!York/NY1Carolina/NC1Dakota/ND~Ohio/OH~Oklahoma/OK~Oregon/OR~Pennsylvania/PA~Rhode Island/RI@Carolina/SC@Dakota/SD~Tennessee/TN~Texas/TX~Utah/UT~Vermont/VT~Virginia/VA~Washington/WA~West Virginia/WV~Wisconsin/WI~Wyoming/WY/

Pruébalo en línea!

Dado que no hay otra forma de tomar entrada en ///, va al final del programa. Simplemente agregue la entrada deseada al programa.

Ahorró 11 bytes al hacer más reemplazos, según lo recomendado por @SteveBennett

Camarada SparklePony
fuente
Probablemente hay algunos patrones que puede reemplazar varias veces a la vez, como "Nuevo" y "akota". Molesto que no se pueda hacer mucho más inteligente como eliminar secciones de nombres de estado, porque convertir el carácter restante a mayúsculas es muy costoso ...
Steve Bennett
@SteveBennett Editado, ¡gracias!
Camarada SparklePony
2

Python 2 , 131125 bytes

lambda s:s[0]+'CLLKARADEZVAK.T..DETTH.NSAHY...ID.D..O..Y.IRE.X..NALINC.VJM.SY.T..AAOI'[int(s[0]+s[-2:],36)%386%334%181%98%70]

Pruébalo en línea!

ovs
fuente
1

TAESGL , 386 bytes

B=«ōďā,AL,ņćđ,AK,ķċđ,AZ,ćōē,AR,ďċđ,CA,ĭāď,CO,ŕĭ,CT,ćđēą,DE,ĕŕ,FL,īĭ,GA,ńāē,HI,ćĉďą,ID,ĭċď,IL,ľđā,ţ,ńĕĕ,IA,ķő,KS,ŏĝ,KY,ŏĕĕ,LA,ŏđć,ME,ņāē,MD,ńđā,MA,īđą,MI,ļēď,MN,ŕğ,MS,ňė,MO,ććĕĉ,MT,ćċćĉ,NE,ŕēď,NV,ň ćŋā,NH,ň ĩēđ,NJ,ň ğĕċ,NM,ň ĉĝ,NY,ćņ ġĉă,NC,ćņ ńċą,ND,ĩēą,OH,ŋĺ,OK,ļķ,OR,ĺđď,PA,ĉĉğ đēā,RI,ōċ ġĉă,SC,ōċ ńċą,SD,ňďą,TN,ċĕď,TX,ōđą,UT,ćđāā,VT,ğğ,VA,ďĉē,WA,ĉĉć ğğ,WV,ľēđ,WI,ĉĩĕ,WY»Ĵ",";B[BĪA)+1

Interprete

Compresión muy simple de los nombres de estado, agregados a una matriz con las abreviaturas.

Tom
fuente
1

Japt, 383 bytes

La compresión de la primera cadena puede mejorarse experimentando con el orden de las letras.

g +`lkzÇUaidlnyaÀÍ¥evhjmycdhkÎödnxttaaviy`g`alabaµ
Ã2ka
iza
kÂ6s
Öâfnia
åªv
¬nש
Ü.Ø
fÓQ»
gegia
°ii
i»
ÅJno
Äa
Å0
kÂ6s
kÀ_cky
lia
Úpe
æ¯À
ÚUaÖ³etts
Úòig
·nÌta
æ«7ppi
æ¬
Úa
ßka
va»
w mp¢i
w jÀ y
w ´xi¬
w yk
Íh ÖÚ¦na
Íh »kota
oo
oklaÊá
eg
pnsylvia
r¸ Ó
Ñh ÖÚ¦na
Ñh »kota
âÊte
x
©ah
vÚ
virgia
Øgn
ØÙ virgia
æÈ;n
wyÇg`·bUv) u

Pruébalo en línea

Lanudo
fuente
1

Mathematica, 138 140 134 Bytes

+2 bytes: se encontró un error (compensación de matriz necesaria de 1 no 0)

-6 bytes: se encontró un mejor hash

#~StringTake~1<>"R_ATE__IN_COI_J_I_SLNAT_Y_Y_HKOAE__SAA_DDLM_RVAH_XDTVA__I_N_EA_T_DY_C_KZL"~StringTake~{1+Hash@#~Mod~89866736~Mod~73}&

Similar a otros, toma el nombre y toma la primera letra. Luego aplica el hash predeterminado de Mathematica y luego le aplica " Hash@#~Mod~89866736~Mod~73" dos módulos para obtener un número único para cada estado. Este valor luego se busca en una cadena para generar la segunda letra.

Probablemente se pueda jugar más al golf, pero el espacio de búsqueda es enorme para Mathematica. Las segundas letras duplicadas no se consideraron en la búsqueda hash. _los caracteres representan valores desperdiciados en la cadena. En teoría, podría reducir la cadena a solo 19 caracteres, pero encontrar el hash personalizado para producir eso sería una pesadilla.

Ian Miller
fuente
1

Perl 5, 150 148 bytes (147 + 1)

Esto de ninguna manera es óptimo, pero hace su trabajo. Necesita -nbandera de línea de comando.

s/las//;s/ai?n//;s/[oie]n|ri//;s/e([vx])/$1/;s/issi?//;s/(.).+ /\1/;/(.)(.)/;/^([^W]).*(?:[cogavn][wiku]|[ir][ys][li]|rm)([adyti])$/;print uc"$1$2"
Silvio Mayolo
fuente