给定左侧的50个美国州名之一作为输入，输出其两个字母的邮政编码，如右侧所示：

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

规则

• 输入和输出均区分大小写。你们中许多人不输出如Al对Alabama。
• 您可以假定输入是上面显示的50个状态名称之一。
• 您可能无法访问Internet或使用内置状态数据（Mathematica看着您）。

在此代码段中可以找到输入和输出的单独列表（请不要运行它，它只是用于压缩帖子）：

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

（不计分）布朗尼积分（如果您还可以将其District of Columbia作为投入品和生产品DC，维尔京群岛等）。

计分

这是代码高尔夫球，因此每种语言中以字节为单位的最短代码获胜。

（最初由ETHProductions 提出）

的Javascript，124个 117字节

（由于hvd节省了7个字节）

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

说明：

• regexp查找首字母和最后一个字母，首字母的两个字母的匹配项
• 第一部分匹配两个以上单词的州（包括哥伦比亚特区）
• 第二部分比赛阿拉斯加和亚利桑那
• 第三部分比赛马萨诸塞州，密西西比州和密苏里州
• 第四部分比赛密歇根州，明尼苏达州和蒙大拿州
• 第五部分比赛内布拉斯加州和内华达州
• 第六部分匹配所有缩写为前两个字母的所有剩余州，特殊情况下排除爱荷华州
• 第七部分匹配所有其余状态的缩写，分别为第一个字母和第三个字母
• 第八部分匹配其他所有内容，缩写为首字母和尾字母
• 那只是剥离这些字母并大写的一种情况
• 还匹配波多黎各和美属萨摩亚，但不匹配关岛，马里亚纳群岛或美属维尔京群岛

Javascript 137 135 134 132 113 110 108 101 99 94 93 92字节

这基于HP Williams解决方案，在正则表达式之外进行了一些改进，并在其中进行了一些调整。

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

（仅用于可读性的换行符）

正则表达式的注释：

.*( .|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

没有意义的替代正则表达式（相同长度）：

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

历史

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字节

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]

演示版

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

果冻，75 字节

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

在线尝试！

...或查看测试套件 -请注意，必须进行少量更改才能一次运行多个输入的完整程序（我换出了程序输入原子³，以便从寄存器中调用®，然后设置寄存器每个州名称）。

怎么样？

计算用于邮政编码第二个字符的索引，将其附加到第一个字符并以大写形式显示结果。

首先找到空格字符的索引（如果找不到，则返回0）；

否则检查它是阿拉斯加还是密苏里州（k或o，为5 ）；

否则，在列表中找到输入状态的索引Arizona Minnesota Mississippi Nevada Montana Texas Tennessee（如果未找到，则返回0）-如果是这样，它将取该索引mod 2加3（用于z n s v t x n）；

否则将字符串转换为普通数，从256的基数转换为整数，除以29487后找到余数，除以14后再找到余数，并用它索引到9620的二进制表示形式，并将结果加倍-产生0适用于使用最后一个字母的州，适用于使用第二个字母的州。

除第一种情况外，所有其他情况都将递增，并且结果值将递减（将找到的空间索引加1）。

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字节

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]

在线尝试！

使用简单的哈希函数来查找缩写的第二个字符。

Python 2，94 90字节

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

在线尝试

（仅使用Python 2，因为Python 3哈希值不稳定，而且您不能在不将其转换为字节的情况下对字符串进行哈希处理。）

适用于所有50个州，以及哥伦比亚特区和波多黎各的奖金地区。

通过将数字写入base-36可以节省一个字节int("5clu7x0aixb0pelmpugv5iiibphrpf",36)。我在等我是否可以想到一个更具创造性的解决方案。

更新：

由于哈希中有12个未使用的数字位置，因此有2 ^36个可能的数字将起作用。似乎有理由相信，其中一个将具有很大的指数。对于任何给定的质数和指数，找到一个值都非常快。我设法找到一个因数为19 ⁹的表达式，将表示该数字的表达式的大小减小了四个字节。

这基本上与我的C答案相同，但是使用Python。由于基本哈希函数不同，因此我不得不找到不同的归约函数，原来是mod 52而不是mod54。但是，与C相比，最大的节省来自使用bignums编码矢量的可能性，当然实际上，Python标准似乎是可以使用lambda文字而不是完整的程序。

Retina，113 81 80 77 70 68字节

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

T`l`L

在线尝试！包括所有51个测试用例。通过使用@JörgHülsermann的正则表达式可节省32个字节，该正则表达式可找到第二个字母（通过调整以支持DC；编辑：多亏@JörgHülsermann节省了1个字节）。通过从@SteveBennett的正则表达式切换到@HPWilliam的答案，节省了3个字节。再次感谢@SteveBennett，节省了7 9个字节。然后删除其他字母，并将字符串大写。

PHP> = 7.1，113字节

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

在线版本

罢工是通过之前的较早开始比赛进行的

([vxz])匹配亚利桑那州，内华达州，新墨西哥州， 宾夕法尼亚州，德克萨斯州，

(.) （前一个空格）匹配新罕布什尔州，新泽西州，新墨西哥州，纽约州，北卡罗来纳州，北达科他州，罗德岛州，南卡罗来纳州，南达科他州，西弗吉尼亚州

[CGHKLPV].*(.)匹配加利福尼亚，科罗拉多州，康涅狄格州，乔治亚州，夏威夷，堪萨斯州，肯塔基州，路易斯安那州，新罕布什尔州，北卡罗来纳州，宾夕法尼亚州，南卡罗来纳州，佛蒙特州，弗吉尼亚州，西弗吉尼亚州

ow(a) 匹配爱荷华州

las(k) 比赛阿拉斯加

ssi?(.)匹配马萨诸塞州，密西西比州，密苏里州，田纳西州

n(n|t|[de]$)匹配康涅狄格州， 肯塔基州，缅因州，马里兰州，明尼苏达州，蒙大拿州，宾夕法尼亚州， 罗德岛州，田纳西州，佛蒙特州

这些州没有匹配项，因此我们采用前两个字母：阿拉巴马州，阿肯色州，特拉华州，佛罗里达州，爱达荷州，伊利诺伊州，印第安纳州，密歇根州，内布拉斯加州，俄亥俄州，俄克拉荷马州，俄勒冈州，犹他州，华盛顿州，威斯康星州，怀俄明州

第一次使用此Regex子模式 ?|，它允许将反向引用存储在一个中。

支持哥伦比亚特区

替换(.)为([^o])+3字节

在线尝试！

PHP，150字节

<?=($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]);

在线尝试！测试用例

PHP，887854字节

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

在线尝试！

第一次来，万岁！

C，945个 937 718 711 660 616字节

由于仅使用ASCII，因此节省了219个字节。

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

不需要换行，仅用于显示目的。将状态作为输入。在线尝试！

这个怎么运作：

• struct{int*a,b;}m[]=...声明一个m具有两个值的映射-一个四字节字符串和一个字符。这在比较循环中使用，该比较循环将第二个索引到第五个索引与char*a映射进行比较。
• gets(b)读取一个字符串b。这就是缩写的状态。
• putchar(*b) 打印该字符串的第一个字符，因为每个缩写都以该状态的第一个字母开头。
• for(;m[i].a;i++)遍历地图的每个值。（这可以缩短。）
• if(!strncmp(m[i].a,b+1,4))将当前映射值与b（要缩写的状态）的第二到第五个字符进行比较。这是因为唯一的区别在于前五个字符，但是我们已经打印了第一个字符。
• puts(&m[i].b); 打印缩写的第二个字母（如果状态名称与当前地图值匹配）和换行符。

C，148141字节

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)认为输入的第二个到第五个字符是整数；然后使用hash将那个整数散列为0-56 i%663694%57。然后，在代表偏移量第二个字母的位置的偏移量向量中查找散列值。我选择了这四个特定的字节，因为（1）密苏里州和密西西比州的第一个字符有所不同，并且（2）一些状态只有四个字符。在C中，您可以使用NUL终止符字节，但除此之外，没有什么可靠的。（这会将两个Norths以及两个Souths都哈希到相同的值。但这没关系，因为所有这些值的关联偏移均为6。）

碰巧的是，该特定哈希值会为哥伦比亚特区，波多黎各和“维尔京群岛”（以这种方式键入，而不是“美属维尔京群岛”）的缩写的第二个字母产生正确的位置，因为该算法坚持认为第一个字母缩写字符是名称的第一个字符）。

常数694694和57是通过自动测试发现的；57是我发现的最小哈希范围。（第一个版本使用380085和63，但是当我扩展测试范围时，我发现了新版本。）如果为“使用名称中的最后一个字符”添加了代码，则似乎存在较小的哈希值。不幸的是，用于选择最后一个字符的C语法过于冗长，无法提供帮助。

只有8个不同的偏移量，因此它们可以存储在171位（3 * 57）查找表中，每个条目具有3位。但是我想不出一种将这些位有效地插入程序的方法。十六进制编码每四位大约需要一个字符，再加上0x前缀。我无法比151个字节更好，后者比字符串版本长得多。如果可以以某种方式将171位作为原始八位字节插入，则它们将占用22个字节，因此可能有解决方案，但是读取文件比较麻烦。

实际上，181个字节

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

此解决方案期望输入为带引号的字符串。

在线尝试！

说明

该解决方案使用与我的Python 3解决方案相同的哈希策略。为简便起见，我将省略有关如何计算哈希值以及为什么选择哈希值的解释（如果需要，请阅读其他答案）。

同样为了简洁起见，我将省略非常长的字符串的内容，因为否则解释将难以理解。

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个字节

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]

在线尝试！

输入应作为字节对象（字节字符串，而不是Unicode字符串）。

感谢Johnathon Allan的大量字节

说明

a通过应用哈希a = sum(o*5**i) % 236（o每个字符的ASCII序数i是它在字符串中的索引，从末尾算起），每个状态名称都被哈希为一个整数。236选择该模数是因为它是使50个州名称中所有哈希值都不同的最小模数。然后，将这些哈希映射到状态缩写，然后使用得到的字典（使用字符串替换压缩）来查找给定状态名的缩写（将其哈希以获取适当的键）。

红宝石，106个 103字节

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

如果输入包含空格，则第二个输出字母为空格之后的字母。其他...

根据公式j>8?j/4:-1（-1表示结尾），对输入中所有字符的总和进行散列，以获得其字符在魔术字符串中的索引指示输入字符串中第二个输出字母的索引的字符。如果散列给出的字符不在魔术字符串中，则第二个字母为输入的第二个字母。

为了解释魔术字符串，下面对它们编码的哈希字符和字母索引进行说明。请注意，即使第二个字母也可以显示特拉华州-这是因为其哈希码与肯塔基州相冲突。幸运的是，特拉华州的最后一个字母与第二个字母相同。

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 

取消测试程序

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

///，619608字节

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

在线尝试！

由于没有其他方法可以在///中获取输入，因此它将在程序末尾使用。只需将所需的输入附加到程序即可。

按照@SteveBennett的建议，通过进行更多替换来节省11个字节

Python 2中，131个是125字节

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]

在线尝试！

TAESGL，386字节

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

口译员

状态名称的非常​​简单的压缩，添加到带有缩写的数组中。

Japt，383个字节

通过尝试字母的顺序，可以提高对第一字符串的压缩效果。

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

在线尝试

数学，138个 140个 134字节

+2个字节-发现错误（所需的数组偏移量为1而不是0）

-6个字节-找到更好的哈希

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

与其他名称类似，它使用名称并使用第一个字母。然后，它应用默认的Mathematica哈希，然后对其应用两个模数“ Hash@#~Mod~89866736~Mod~73”，以获取每个状态的唯一数字。然后在字符串中查询该值以生成第二个字母。

可能可以打更多的高尔夫球，但是Mathematica的搜索空间很大。哈希搜索中不考虑重复的第二个字母。_字符表示字符串中的浪费值。从理论上讲，您可以将字符串减少到仅19个字符，但是找到要生成的自定义哈希值将是一场噩梦。

Perl 5中，150个 148字节（147 + 1）

这绝不是最佳选择，但可以做到。需要-n命令行标志。

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字节

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]

在线尝试！

阿诺尔德的答案的港口。