Cho một trong 50 tên tiểu bang Hoa Kỳ ở bên trái làm đầu vào, xuất mã bưu chính gồm hai chữ cái như hình bên phải:

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

Quy tắc

• Đầu vào và đầu ra đều nhạy cảm. Bạn nhiều đầu ra không ví dụ Alcho Alabama.
• Bạn có thể giả sử đầu vào là một trong 50 tên trạng thái được hiển thị ở trên.
• Bạn không được truy cập internet hoặc sử dụng dữ liệu trạng thái tích hợp (nhìn vào bạn, Mathicala).

Có thể tìm thấy danh sách đầu vào và đầu ra riêng biệt trong đoạn trích này (vui lòng không chạy nó, nó chỉ để nén bài đăng):

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

(Không ghi điểm) Brownie điểm nếu bạn cũng có thể lấy District of Columbialàm đầu vào và sản xuất DC, Quần đảo Virgin, v.v.

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng .

(Ban đầu được đề xuất bởi ETH Productstions)

Javascript, 124 117 byte

(đã lưu 7 byte nhờ vào 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()

Giải trình:

• Regrec tìm thấy sự trùng khớp với các chữ cái đầu tiên và cuối cùng hai chữ cái viết tắt
• Phần đầu phù hợp với các tiểu bang có nhiều hơn hai từ (bao gồm Quận Columbia)
• Phần thứ hai phù hợp với Alaska và Arizona
• Phần thứ ba phù hợp với Massachusets, Mississippi và Missouri
• Phần thứ tư phù hợp với Michigan, Minnesota và Montana
• Phần thứ năm phù hợp với Nebraska và Nevada
• Phần thứ sáu khớp với tất cả các trạng thái còn lại được viết tắt bằng hai chữ cái đầu tiên của họ, với trường hợp đặc biệt để loại trừ Iowa
• Phần thứ bảy phù hợp với tất cả các trạng thái còn lại viết tắt bằng chữ cái đầu tiên và thứ ba của họ
• Phần thứ tám khớp với mọi thứ khác, được viết tắt thành chữ cái đầu tiên và cuối cùng của họ
• Sau đó, nó chỉ là một trường hợp tước các chữ cái và viết hoa
• Cũng phù hợp với Puerto Rico và Samoa thuộc Hoa Kỳ, nhưng không phải là đảo Guam, quần đảo Marianas hay Quần đảo Virgin thuộc Hoa Kỳ

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

Điều này dựa trên giải pháp HP Williams, với một số cải tiến bên ngoài regex và một vài điều chỉnh trong đó.

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

(Linebreaks chỉ để đọc)

Bình luận cho 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 thay thế vô nghĩa (cùng chiều dài):

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

Lịch sử

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 byte

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]

Bản giới thiệu

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

Thạch , 75 byte

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

Hãy thử trực tuyến!

... hoặc xem bộ kiểm tra - Lưu ý một thay đổi nhỏ phải được thực hiện để chạy chương trình đầy đủ cho nhiều đầu vào trong một lần (Tôi đã đổi nguyên tử đầu vào chương trình ³, để thu hồi từ thanh ghi ®, một và đặt thanh ghi đến từng tên tiểu bang lần lượt).

Làm sao?

Tính toán chỉ số để sử dụng cho ký tự thứ hai của mã bưu chính, nối nó vào ký tự đầu tiên và viết hoa kết quả.

Đầu tiên tìm thấy chỉ mục của một ký tự khoảng trắng (hoặc 0 nếu không tìm thấy);

Khác kiểm tra nếu đó là Alaska hoặc Missouri (mang lại 5 cho khoặc o);

Khác tìm thấy chỉ mục của trạng thái đầu vào trong danh sách Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(hoặc 0 nếu không tìm thấy) - nếu vậy nó sẽ lấy chỉ mục đó mod 2 cộng với 3 (cho z n s v t x n);

Else chuyển đổi chuỗi thành thứ tự, chuyển đổi từ cơ sở 256, tìm phần còn lại của chuỗi đó sau khi chia cho 29487, tìm phần còn lại sau khi chia cho 14 và sử dụng chuỗi đó để biểu diễn thành biểu diễn nhị phân của 9620 và nhân đôi kết quả - mang lại 0 cho các tiểu bang sử dụng chữ cái cuối cùng của họ và 2 cho những tiểu bang sử dụng chữ cái thứ hai của họ.

Tất cả trừ trường hợp đầu tiên được tăng lên và giá trị kết quả được giảm dần (tăng chỉ số không gian được tìm thấy bởi một).

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 byte

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]

Hãy thử trực tuyến!

Sử dụng hàm băm đơn giản để tìm ký tự thứ hai của chữ viết tắt.

Python 2, 94 90 byte

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

Dùng thử trực tuyến

(Chỉ Python 2 vì băm Python 3 không ổn định và bạn cũng không thể băm chuỗi mà không biến nó thành byte.)

Hoạt động với tất cả 50 tiểu bang, cộng với vai trò là Quận Columbia và Puerto Rico.

Có thể lưu một byte bằng cách viết số vào cơ sở-36 : int("5clu7x0aixb0pelmpugv5iiibphrpf",36). Tôi đang chờ xem liệu tôi có thể nghĩ ra một giải pháp sáng tạo hơn không.

Cập nhật:

Vì có 12 vị trí chữ số không được sử dụng trong hàm băm, có 2 ³⁶ số có thể sẽ hoạt động. Có vẻ hợp lý khi tin rằng một trong số họ sẽ có yếu tố chính với số mũ lớn. Đối với bất kỳ số nguyên tố và số mũ cụ thể nào, việc tìm kiếm một giá trị khá nhanh; Tôi quản lý để tìm một cái có hệ số 19 ⁹ , giảm kích thước của biểu thức cần thiết để biểu thị số bằng bốn byte.

Về cơ bản, đây là quy trình tương tự như câu trả lời C của tôi nhưng sử dụng Python. Vì hàm băm cơ sở là khác nhau, tôi đã phải tìm một hàm khử khác, hóa ra là mod 52 thay vì mod 54. Nhưng khoản tiết kiệm lớn nhất so với C đến từ khả năng sử dụng bignums để mã hóa vectơ, và dĩ nhiên thực tế là tiêu chuẩn cho Python dường như là sử dụng chữ lambda thay vì một chương trình hoàn chỉnh.

Võng mạc , 113 81 80 77 70 68 byte

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

T`l`L

Hãy thử trực tuyến! Bao gồm tất cả 51 trường hợp thử nghiệm. Đã lưu 32 byte bằng cách chiếm dụng regex của @ JörgHülsermann tìm thấy chữ cái thứ hai (với một tinh chỉnh để hỗ trợ DC; chỉnh sửa: đã lưu 1 byte nhờ @ JörgHülsermann). Đã lưu 3 byte bằng cách chuyển sang regex của @ SteveBennett từ nhận xét của anh ấy sang câu trả lời của @ HPWilliam. Đã lưu 7 9 byte một lần nữa nhờ @SteveBennett. Các chữ cái khác sau đó sẽ bị xóa và chuỗi ký tự.

PHP> = 7.1, 113 byte

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

Phiên bản trực tuyến

Các cuộc đình công được kết hợp thông qua một trận đấu bắt đầu sớm hơn trước

([vxz])phù hợp với Arizona, Nevada, New Mexico, Pennsylvania, Texas,

(.) (một không gian trước đó) phù hợp với New Hampshire, New Jersey, New Mexico, New York, North Carolina, North Dakota, Rhode Island, South Carolina, South Dakota, West Virginia

[CGHKLPV].*(.)phù hợp với California, Colorado, Connecticut, Georgia, Hawaii, Kansas, Kentucky, Louisiana, New Hampshire , North Carolina, Pennsylvania, South Carolina , Vermont, Virginia, West Virginia

ow(a) trận đấu Iowa

las(k) trận đấu Alaska

ssi?(.)phù hợp với Massachusetts, Mississippi, Missouri, Tennessee

n(n|t|[de]$)phù hợp với Connecticut, Kentucky, Maine, Maryland, Minnesota, Montana, Pennsylvania, Rhode Island, Tennessee, Vermont

Không phù hợp với các tiểu bang này, vì vậy chúng tôi lấy hai chữ cái đầu tiên Alabama, Arkansas, Delkn, Florida, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregon, Utah, Washington, Wisconsin, Wyoming

Lần đầu tiên tôi sử dụng Regex Subpatter này ?| với việc cho phép lưu trữ các phản hồi trong một.

Hỗ trợ Quận Columbia

Thay thế (.)bằng ([^o])+3 byte

Hãy thử trực tuyến!

PHP, 150 byte

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

Hãy thử trực tuyến! Tủ thử

PHP, 887 854 byte

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

Hãy thử trực tuyến!

Hẹn giờ đầu tiên, hoan hô!

C, 945 937 718 711 660 616 byte

Đã lưu được 219 byte chỉ nhờ ASCII.

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

Dòng mới không cần thiết, chỉ cho mục đích hiển thị. Lấy trạng thái làm đầu vào. Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

• struct{int*a,b;}m[]=...khai báo một bản đồ mcó hai giá trị - chuỗi bốn byte và một ký tự. Điều này được sử dụng trong vòng lặp so sánh, so sánh các chỉ số thứ hai đến thứ năm với char*atrong bản đồ.
• gets(b)đọc một chuỗi b. Đây sẽ là nhà nước để viết tắt.
• putchar(*b) in ký tự đầu tiên của chuỗi đó, vì mỗi chữ viết tắt bắt đầu bằng chữ cái đầu tiên của trạng thái.
• for(;m[i].a;i++)các vòng lặp qua từng giá trị của bản đồ. (Điều này có thể được rút ngắn.)
• if(!strncmp(m[i].a,b+1,4))so sánh giá trị bản đồ hiện tại với các ký tự thứ hai đến thứ năm của b(trạng thái để viết tắt). Điều này là do sự khác biệt duy nhất là trong năm ký tự đầu tiên, nhưng chúng tôi đã in ký tự đầu tiên.
• puts(&m[i].b); in chữ cái viết tắt thứ hai (nếu tên trạng thái khớp với giá trị bản đồ hiện tại) và một dòng mới.

C, 148 141 byte

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)coi ký tự thứ hai đến thứ năm của đầu vào là một số nguyên; số nguyên đó sau đó được băm vào 0-56 bằng cách sử dụng hàm băm i%663694%57. Giá trị băm sau đó được tra cứu trong một vectơ bù trừ đại diện cho vị trí của chữ cái thứ hai của chữ viết tắt. Tôi đã chọn bốn byte cụ thể đó bởi vì (1) Missouri và Mississippi trước tiên khác nhau ở ký tự thứ năm và (2) một số tiểu bang chỉ có bốn ký tự Trong C bạn có thể sử dụng byte kết thúc NUL, nhưng không có gì đáng tin cậy. (Điều này băm cả hai miền Bắc về cùng một giá trị, cũng như cả hai miền Nam. Nhưng điều đó không quan trọng bởi vì phần bù liên quan là 6 cho tất cả những điều này.)

Khi điều đó xảy ra, hàm băm cụ thể đó mang lại vị trí chính xác cho các chữ cái thứ hai của các chữ viết tắt của Quận Columbia, Puerto Rico và "Quần đảo Virgin" (gõ theo cách đó, không phải là "Quần đảo Virgin thuộc Hoa Kỳ", bởi vì thuật toán nhấn mạnh rằng đầu tiên ký tự viết tắt là ký tự đầu tiên của tên).

Các hằng số 663694 và 57 được tìm thấy với một bài kiểm tra tự động; 57 là phạm vi băm nhỏ nhất tôi tìm thấy. (Phiên bản đầu tiên sử dụng 380085 và 63, nhưng khi tôi mở rộng phạm vi thử nghiệm, tôi đã tìm thấy phiên bản mới.) Có vẻ như một hàm băm nhỏ hơn tồn tại nếu một mã được thêm vào để "sử dụng ký tự cuối cùng trong tên"; Thật không may, cú pháp C để chọn ký tự cuối cùng quá dài để làm cho nó hữu ích.

Chỉ có 8 offset khác nhau, vì vậy chúng có thể được lưu trữ trong bảng tra cứu 171 bit (3 * 57) với ba bit cho mỗi mục nhập. Nhưng tôi không thể nghĩ ra cách nào để chèn các bit đó một cách hiệu quả vào chương trình. Mã hóa hex sẽ yêu cầu khoảng một ký tự trên bốn bit, cộng với các 0xtiền tố. Tôi không thể làm tốt hơn 151 byte, dài hơn nhiều so với phiên bản chuỗi. Nếu bằng cách nào đó, 171 bit có thể được chèn dưới dạng octet thô, chúng sẽ chiếm 22 byte, do đó có thể có một giải pháp, nhưng đọc một tệp thì rất khó hiểu.

Trên thực tế , 181 byte

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

Giải pháp này mong đợi đầu vào như một chuỗi trích dẫn.

Hãy thử trực tuyến!

Giải trình

Giải pháp này sử dụng chiến lược băm giống như giải pháp Python 3 của tôi . Để cho ngắn gọn, tôi sẽ bỏ qua phần giải thích về cách tính băm và lý do tại sao nó được chọn (hãy đọc câu trả lời khác nếu bạn muốn bit đó).

Ngoài ra để cho ngắn gọn, tôi sẽ bỏ qua nội dung của các chuỗi rất dài, vì nếu không thì lời giải thích sẽ không thể đọc được.

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 byte

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]

Hãy thử trực tuyến!

Đầu vào được mong đợi dưới dạng đối tượng byte (chuỗi byte, thay vì chuỗi Unicode).

Cảm ơn Johnathon Allan vì số lượng byte vô lý

Giải trình

Mỗi tên trạng thái được băm thành một số nguyên abằng cách áp dụng hàm băm a = sum(o*5**i) % 236(trong đó olà thứ tự ASCII của một ký tự và ilà chỉ mục của nó trong chuỗi, đếm ngược từ cuối). Mô-đun 236được chọn vì đây là mô-đun nhỏ nhất khiến tất cả các giá trị băm khác biệt với 50 tên tiểu bang Hoa Kỳ. Các giá trị băm này sau đó được ánh xạ tới các chữ viết tắt trạng thái và từ điển kết quả (được nén bằng cách sử dụng thay thế chuỗi) được sử dụng để tra cứu tên viết tắt được đặt tên trạng thái (băm nó để lấy khóa chiếm dụng).

Ruby, 106 103 byte

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

Nếu đầu vào chứa một khoảng trắng, chữ cái đầu ra thứ hai là chữ cái sau dấu cách. Khác ...

Băm tổng của tất cả các ký tự trong đầu vào để có được một ký tự có chỉ số trong chuỗi ma thuật cho biết chỉ số của chữ cái đầu ra thứ hai trong chuỗi đầu vào, theo công thức j>8?j/4:-1(-1 có nghĩa là kết thúc.). Nếu hàm băm đưa ra một ký tự không có trong chuỗi ma thuật, thì chữ cái thứ hai là chữ cái đầu vào thứ hai.

Như một lời giải thích về chuỗi ma thuật, các ký tự băm và các chỉ mục chữ cái mà chúng mã hóa ở bên dưới. Lưu ý rằng Delkn xuất hiện ngay cả khi chữ cái thứ hai sẽ làm - điều này là do mã băm của nó đụng độ với Kentucky. May mắn là lá thư cuối cùng của Del biết giống như lá thư thứ hai.

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 trong chương trình thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Vì không có cách nào khác để nhận đầu vào trong ///, nên nó đi vào cuối chương trình. Chỉ cần nối các đầu vào mong muốn vào chương trình.

Đã lưu 11 byte bằng cách thay thế nhiều hơn, theo khuyến nghị của @SteveBennett

Python 2 , 131 125 byte

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]

Hãy thử trực tuyến!

TAESGL , 386 byte

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

Thông dịch viên

Nén rất đơn giản các tên trạng thái, được thêm vào một mảng với các chữ viết tắt.

Japt, 383 byte

Việc nén chuỗi đầu tiên có thể là ngẫu nhiên bằng cách thử nghiệm thứ tự của các chữ cái.

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

Dùng thử trực tuyến

Toán học, 138 140 134 byte

+2 byte - đã tìm thấy một lỗi (bù mảng cần thiết bằng 1 chứ không phải 0)

-6 byte - tìm thấy hàm băm tốt hơn

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

Tương tự như những người khác, nó lấy tên và lấy chữ cái đầu tiên. Sau đó, nó áp dụng hàm băm Mathicala mặc định, sau đó áp dụng hai mô-đun cho nó " Hash@#~Mod~89866736~Mod~73" để lấy một số duy nhất cho mỗi trạng thái. Giá trị này sau đó được tra cứu trong một chuỗi để tạo chữ cái thứ hai.

Có thể có thể chơi gôn nhiều hơn nhưng không gian tìm kiếm rất lớn cho Mathicala tìm thấy. Các chữ cái thứ hai trùng lặp không được xem xét trong tìm kiếm băm. _ký tự đại diện cho các giá trị lãng phí trong chuỗi. Về lý thuyết, bạn có thể giảm chuỗi xuống chỉ còn 19 ký tự nhưng việc tìm ra hàm băm tùy chỉnh để tạo ra đó sẽ là một cơn ác mộng.

Perl 5, 150 148 byte (147 + 1)

Điều này không có nghĩa là tối ưu, nhưng nó thực hiện công việc của nó. Cần -ncờ dòng lệnh.

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 byte

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]

Hãy thử trực tuyến!

Một câu trả lời của Arnauld .