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,
Al
paraAlabama
. - 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):
(Sin puntuación) Puntos Brownie si también puede tomar District of Columbia
como 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
fuente
Entity[a="AdministrativeDivision",{#,"UnitedStates"}]@EntityProperty[a,"StateAbbreviation"]&
20
bytes:Entity["AdministrativeDivision",{#,"UnitedStates"}]@"StateAbbreviation"&
:)Respuestas:
Javascript,
124117bytes(guardado 7 bytes gracias a hvd)
Explicación:
fuente
[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.+
.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? :)Javascript,
13713513413211311010810199949392 bytesEsto 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.
(Saltos de línea solo para legibilidad)
Comentario para la expresión regular:
Regex alternativo sin sentido (misma longitud):
Historia
94
99
101
108
110
113
132
134
135
137
fuente
...s.s?
captura Mississippi, Missouri, Massachussetts y Alaska) por accidente. En realidad, estaba en el proceso de mover el.*sk
fragmento 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!...s.s?
también coincide inadvertidamente con Kansas y, por milagro, sigue dando el resultado correcto.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.JavaScript (ES6),
156136 bytesManifestación
Mostrar fragmento de código
fuente
X MOD[50-1000] MOD[50-1000] MOD[50-100]
. Pero.slice(1)
fue un error. Actualmente se ejecuta nuevamente en toda la cadena.Jalea , 75 bytes
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
k
oo
);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 (paraz 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).
fuente
Python 2 , 191 bytes
Pruébalo en línea!
Utiliza una función hash simple para encontrar el segundo carácter de la abreviatura.
fuente
Python 2,
9490 bytesPrué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.
fuente
Retina ,
1138180777068 bytesPrué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
79 bytes gracias de nuevo a @SteveBennett. Las otras letras se eliminan y la cadena se pone en mayúscula.fuente
e
fue el más problemático, de verdad.d
. (Es posible que desee utilizar las pruebas automáticas. Tengo un script que comprueba constantemente los 50 casos)PHP> = 7.1, 113 bytes
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 Occidentalow(a)
coincidir con Iowalas(k)
partido Alaskassi?(.)
coincide con Massachusetts, Mississippi, Missouri,Tennesseen(n|t|[de]$)
coincide conConnecticut,Kentucky,Maine, Maryland, Minnesota, Montana,Pennsylvania,Rhode Island,Tennessee,VermontNo 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 bytesPruébalo en línea!
PHP, 150 bytes
Pruébalo en línea! Casos de prueba
fuente
n|t|
un byte más corto que[nt]|
?PHP,
887854 bytesPruébalo en línea!
Primer temporizador, ¡hurra!
fuente
$argv[1]
se reemplaza con$argn
sandbox.onlinephpfunctions.com/code/…php
!C,
945937718711660616 bytesGuardado 219 bytes gracias a ASCII-only.
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 mapam
con 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 conchar*a
en el mapa.gets(b)
Lee una cadenab
. 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 deb
(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.fuente
C,
148141 bytes*(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 hashi%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
0x
prefijos. 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.fuente
En realidad , 181 bytes
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.
fuente
Python 3 , 230 bytes
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
a
aplicando el hasha = sum(o*5**i) % 236
(dondeo
es el ordinal ASCII de un carácter yi
es su índice en la cadena, contando desde el final). El módulo236
se 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).fuente
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'[sum(c*5**i for i,c in enumerate(s[::-1]))%236]
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('%','$$').replace('$','!!').replace('!','..')[sum(c*5**i for i,c in enumerate(s[::-1]))%236-5]
Ruby,
106103bytesSi 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.
Sin golf en el programa de prueba
fuente
/// ,
619608 bytesPrué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
fuente
Python 2 ,
131125bytesPruébalo en línea!
fuente
TAESGL , 386 bytes
Interprete
Compresión muy simple de los nombres de estado, agregados a una matriz con las abreviaturas.
fuente
Japt, 383 bytes
La compresión de la primera cadena puede mejorarse experimentando con el orden de las letras.
Pruébalo en línea
fuente
Mathematica,
138140134 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.fuente
Perl 5,
150148 bytes (147 + 1)Esto de ninguna manera es óptimo, pero hace su trabajo. Necesita
-n
bandera de línea de comando.fuente
Python 2 , 152 bytes
Pruébalo en línea!
Un puerto de la respuesta de Arnauld .
fuente