Dado um dos 50 nomes de estados dos EUA à esquerda como entrada, imprima seu código postal de duas letras conforme mostrado à direita:

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

Regras

• A entrada e a saída diferenciam maiúsculas de minúsculas. Você não produz muitos, por exemplo, Alpara Alabama.
• Você pode assumir que a entrada é um dos 50 nomes de estados mostrados acima.
• Você não pode acessar a Internet ou usar dados de estado integrados (olhando para você, Mathematica).

Listas de entradas e saídas separadas podem ser encontradas neste snippet (por favor, não execute, é apenas para comprimir a postagem):

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

Brownie (sem pontuação) aponta se você também pode usar District of Columbiacomo entrada e produção DC, Ilhas Virgens, etc.

Pontuação

Isso é código-golfe , então o código mais curto em bytes em cada idioma vence .

(Originalmente proposto por ETHProductions)

Javascript, 124 117 bytes

(economizou 7 bytes graças ao 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()

Explicação:

• O regexp encontra uma correspondência com a primeira e a última letras das duas letras da abreviação
• A primeira parte corresponde aos estados com mais de duas palavras (incluindo o Distrito de Columbia)
• A segunda parte corresponde ao Alasca e Arizona
• A terceira parte corresponde a Massachusets, Mississippi e Missouri
• A quarta parte corresponde a Michigan, Minnesota e Montana
• Quinta parte corresponde a Nebraska e Nevada
• A sexta parte corresponde a todos os estados restantes abreviados para suas duas primeiras letras, com um caso especial para excluir Iowa
• A sétima parte corresponde a todos os estados restantes abreviados com a primeira e a terceira letras
• A oitava parte corresponde a todo o resto, abreviado com a primeira e a última letras
• Então é apenas um caso de descascar essas letras e capitalizar
• Também corresponde a Porto Rico e Samoa Americana, mas não Guam, Ilhas Marianas ou Ilhas Virgens Americanas

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

Isso é baseado na solução HP Williams, com algumas melhorias fora do regex e alguns ajustes nele.

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

(Quebras de linha apenas para legibilidade)

Comentário para a regex:

.*( .|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 inútil (mesmo comprimento):

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

História

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

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]

Demo

let f =

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]

;[
  "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"
]
.map(s => console.log(s, '-->', f(s)))

Geléia , 75 bytes

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

Experimente online!

... ou veja uma suíte de testes - Observe que uma pequena alteração teve que ser feita para executar o programa completo para várias entradas de uma só vez (troquei o átomo de entrada do programa ³, para um recall do registro ®, um e defini o registro para cada nome de estado).

Quão?

Calcula o índice a ser usado para o segundo caractere do código postal, anexa-o ao primeiro caractere e coloca o resultado em maiúsculas.

Primeiro localiza o índice de um caractere de espaço (ou 0, se não encontrado);

Senão verifica se é o Alasca ou o Missouri (produzindo 5 para kou o);

Senão encontra o índice do estado de entrada na lista Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(ou 0, se não for encontrado) - nesse caso, é necessário que o índice mod 2 mais 3 (para z n s v t x n);

Senão converte a sequência em ordinais, converte a partir da base 256, encontra o restante depois de dividir por 29487, localiza o restante depois de dividir por 14 e usa isso para indexar na representação binária de 9620 e dobra o resultado - produzindo 0 para estados que usam sua letra final e 2 para aqueles que usam sua segunda letra.

Todos os casos, exceto o primeiro, são incrementados e o valor resultante é diminuído (aumentando o índice de espaço encontrado por um).

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'

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]

Experimente online!

Usa uma função simples de hash para encontrar o segundo caractere da abreviação.

Python 2, 94 90 bytes

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

Experimente online

(Somente Python 2 porque os hashes do Python 3 não são estáveis ​​e você também não pode fazer hash de uma string sem transformá-la em bytes.)

Funciona com todos os 50 estados, além de bônus como Distrito de Columbia e Porto Rico.

Seria possível salvar um byte escrevendo o número na base-36: int("5clu7x0aixb0pelmpugv5iiibphrpf",36). Estou esperando para ver se consigo pensar em uma solução mais criativa.

Atualizar:

Como existem 12 posições de dígitos não utilizadas no hash, existem 2 ³⁶ números possíveis que funcionarão. Parecia razoável acreditar que um deles teria um fator primordial com um grande expoente. Para qualquer primo e expoente, encontrar um valor é bastante rápido; Eu consegui encontrar um com um fator de 19 ⁹ , a redução do tamanho da expressão necessária para representar o número de quatro bytes.

Este é basicamente o mesmo procedimento que minha resposta C, mas usando Python. Como a função hash base é diferente, eu tive que encontrar uma função de redução diferente, que acaba sendo o mod 52, em vez do 54. Mas as maiores economias em relação a C vêm da possibilidade de usar bignums para codificar o vetor e, é claro, o fato de que o padrão para Python parece ser aceitável usar um literal lambda em vez de um programa completo.

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

Experimente online! Inclui todos os 51 casos de teste. Economizou 32 bytes apropriando-se da regex de @ JörgHülsermann que encontra a segunda letra (com um ajuste para dar suporte ao DC; edite: economizou 1 byte graças a @ JörgHülsermann). Economizou 3 bytes mudando para a expressão regular de @ SteveBennett de seu comentário para a resposta de @ HPWilliam. Salvo 7 9 bytes, agradeço novamente a @SteveBennett. As outras letras são excluídas e a seqüência em maiúsculas.

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]);

Versão Online

Os ataques são correspondidos através de uma partida inicial anterior

([vxz])corresponde ao Arizona, Nevada, Novo México, Pensilvânia, Texas,

(.) (um espaço antes) corresponde a New Hampshire, Nova Jersey, Novo México, Nova York, Carolina do Norte, Dakota do Norte, Rhode Island, Carolina do Sul, Dakota do Sul, Virgínia Ocidental

[CGHKLPV].*(.)corresponde a Califórnia, Colorado, Connecticut, Geórgia, Havaí, Kansas, Kentucky, Louisiana, New Hampshire , Carolina do Norte, Pensilvânia, Carolina do Sul , Vermont, Virgínia, Virgínia Ocidental

ow(a) jogo Iowa

las(k) coincidir com o Alasca

ssi?(.)corresponde a Massachusetts, Mississippi, Missouri, Tennessee

n(n|t|[de]$)corresponde a Connecticut, Kentucky, Maine, Maryland, Minnesota, Montana, Pensilvânia, Rhode Island, Tennessee, Vermont

Como não há correspondência para esses estados, tomamos as duas primeiras letras Alabama, Arkansas, Delaware, Flórida, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregon, Utah, Washington, Wisconsin, Wyoming

A primeira vez que utilizo este subpatro Regex ?| permite armazenar as referências anteriores em uma.

Apoie o Distrito de Columbia

Substitua (.)por ([^o])+3 bytes

Experimente online!

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]);

Experimente online! Casos de teste

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]];

Experimente online!

Primeiro temporizador, viva!

C, 945 937 718 711 660 616 bytes

Economizou 219 bytes graças ao 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);}

Nova linha desnecessária, apenas para fins de exibição. Toma o estado como entrada. Experimente online!

Como funciona:

• struct{int*a,b;}m[]=...declara um mapa mcom dois valores - uma sequência de quatro bytes e um caractere. Isso é usado no loop de comparação, que compara os índices de segundo a quinto com char*ao mapa.
• gets(b)lê uma string b. Este será o estado a abreviar.
• putchar(*b) imprime o primeiro caractere dessa sequência, pois cada abreviação começa com a primeira letra do estado.
• for(;m[i].a;i++)percorre cada valor do mapa. (Isso pode ser reduzido.)
• if(!strncmp(m[i].a,b+1,4))compara o valor atual do mapa com o segundo ao quinto caracteres de b(o estado a abreviar). Isso ocorre porque as únicas diferenças estão nos cinco primeiros caracteres, mas já imprimimos o primeiro caractere.
• puts(&m[i].b); imprime a segunda letra da abreviação (se o nome do estado corresponder ao valor atual do mapa) e uma nova linha.

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 que o segundo ao quinto caractere da entrada é um número inteiro; esse número inteiro é então dividido entre 0 e 56 usando o hash i%663694%57. O valor do hash é então pesquisado em um vetor de deslocamentos que representam a localização da segunda letra da abreviação. Eu escolhi esses quatro bytes específicos porque (1) Missouri e Mississippi diferem primeiro no quinto caractere e (2) alguns estados têm apenas quatro caracteres Em C, você pode usar o byte terminador NUL, mas nada além disso é confiável. (Isso divide os dois nortes no mesmo valor, assim como os dois suls. Mas isso não importa, porque o deslocamento associado é 6 para todos eles.)

Por acaso, esse hash específico produz a posição correta para as segundas letras das abreviações de District of Columbia, Porto Rico e "Ilhas Virgens" (digitadas dessa maneira, não como "Ilhas Virgens Americanas", porque o algoritmo insiste em que a primeira caractere da abreviação seja o primeiro caractere do nome).

As constantes 663694 e 57 foram encontradas com um teste automatizado; 57 foi o menor intervalo de hash que encontrei. (A primeira versão usou 380085 e 63, mas quando estendi o intervalo de teste, encontrei o novo.) Parece que existe um hash um pouco menor se um código for adicionado para "use o último caractere no nome"; infelizmente, a sintaxe C para selecionar o último caractere é muito prolixo para tornar isso útil.

Existem apenas oito deslocamentos diferentes, portanto eles poderiam ter sido armazenados em uma tabela de pesquisa de 171 bits (3 * 57) com três bits por entrada. Mas não consegui pensar em uma maneira de inserir esses bits eficientemente no programa. A codificação hex exigiria cerca de um caractere por quatro bits, além dos 0xprefixos. Eu não poderia fazer melhor do que 151 bytes, que é muito maior que a versão da string. Se os 171 bits pudessem, de alguma forma, ser inseridos como octetos brutos, eles ocupariam 22 bytes, portanto poderia haver uma solução, mas a leitura de um arquivo é desajeitada.

Na verdade , 181 bytes

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

Esta solução espera entrada como uma string entre aspas.

Experimente online!

Explicação

Esta solução utiliza a mesma estratégia de hash da minha solução Python 3 . Por uma questão de brevidade, vou omitir a explicação de como o hash é calculado e por que foi escolhido (leia a outra resposta, se você quiser esse bit).

Também por questões de brevidade, deixarei de fora o conteúdo das seqüências muito longas, pois caso contrário a explicação seria ilegível.

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

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]

Experimente online!

A entrada é esperada como um objeto de bytes (uma sequência de bytes, em vez de uma sequência Unicode).

Agradecimentos a Johnathon Allan por uma quantidade absurda de bytes

Explicação

Cada nome de estado é hash para um número inteiro aaplicando o hash a = sum(o*5**i) % 236(onde oé o ordinal ASCII de um caractere e ié o seu índice na string, contando desde o final). O módulo 236foi escolhido porque é o menor módulo que faz com que todos os valores de hash sejam distintos para os 50 nomes de estados dos EUA. Esses hashes são mapeados para as abreviações de estado e o dicionário resultante (compactado usando substituição de cadeia) é usado para procurar a abreviação com o nome de um estado (usando o hash para obter a chave apropriada).

Ruby, 106 103 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}

Se a entrada contiver um espaço, a segunda letra de saída será aquela após o espaço. Outro...

Hash a soma de todos os caracteres na entrada para obter um caractere cujo índice na string mágica indica o índice da segunda letra de saída na string de entrada, de acordo com a fórmula j>8?j/4:-1(-1 significa o final). Se o hash fornecer um caractere que não esteja na sequência mágica, a segunda letra será a segunda letra de entrada.

Como explicação da sequência mágica, os caracteres de hash e os índices de letras que eles codificam estão abaixo. Observe que Delaware aparece mesmo que a segunda letra seja exibida - isso ocorre porque seu código de hash entra em conflito com o Kentucky. Felizmente, a última carta de Delaware é a mesma que a 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 

Ungolfed in program program

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]]}

/// , 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/

Experimente online!

Como não há outra maneira de obter informações em ///, isso ocorre no final do programa. Basta acrescentar a entrada desejada ao programa.

Economizou 11 bytes fazendo mais substituições, conforme recomendado por @SteveBennett

Python 2 , 131 125 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]

Experimente online!

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

Intérprete

Compressão muito simples dos nomes dos estados, adicionada a uma matriz com as abreviações.

Japonês, 383 bytes

A compactação da primeira corda pode ser improvável experimentando a ordem das 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

Experimente online

Mathematica, 138 140 134 Bytes

+2 bytes - encontrou um erro (deslocamento de matriz necessário de 1 e não 0)

-6 bytes - encontrou um hash melhor

#~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}&

Semelhante a outros, leva o nome e leva a primeira letra. Em seguida, aplica o hash padrão do Mathematica e, em seguida, aplica dois módulos a ele " Hash@#~Mod~89866736~Mod~73" para obter um número exclusivo para cada estado. Esse valor é pesquisado em uma seqüência de caracteres para gerar a segunda letra.

Provavelmente é possível jogar mais, mas o espaço de pesquisa é enorme para o Mathematica encontrar. As segundas letras duplicadas não foram consideradas na pesquisa de hash. _caracteres representam valores desperdiçados na sequência. Em teoria, você poderia reduzir o número de caracteres para apenas 19 caracteres, mas encontrar o hash personalizado a ser produzido seria um pesadelo.

Perl 5, 150 148 bytes (147 + 1)

Isso não é o ideal, mas faz o seu trabalho. Precisa de -nsinalizador de linha 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"

Python 2 , 152 bytes

lambda s:s[0]+'.NY.SDS...O.DT..RT.AAYJZE.K.I.X.TI.EL.CMI..E.NA..L....TH.......O....DAAC..VNH.YAI.RVDA..L....A'[int(s.replace(' ','')[1:],36)%358%235%95]

Experimente online!

Um porto da resposta de Arnauld .