Soldaki 50 ABD eyalet adından biri giriş olarak verildiğinde, iki harfli posta kodunu sağda gösterildiği gibi çıkarın:

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

kurallar

• Giriş ve çıkış hem büyük / küçük harf duyarlıdır. Birçok değil çıkış örn Aliçin Alabama.
• Girişin yukarıda gösterilen 50 durum adından biri olduğunu varsayabilirsiniz.
• İnternete erişemez veya dahili durum verilerini kullanamazsınız (size bakmak, Mathematica).

Giriş ve çıkışların ayrı listeleri bu snippet'te bulunabilir (lütfen çalıştırmayın, yalnızca yazıyı sıkıştırmak içindir):

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

(Puanlama yok) Brownie District of Columbia, girdi ve ürün DC, Virgin Adaları vb.

puanlama

Bu kod golf , yani her dilde bayt cinsinden en kısa kod kazanır .

(İlk önerilen ETHProductions ile)

Javascript, 124 117 bayt

(hvd sayesinde 7 byte kurtarıldı)

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

Açıklama:

• Regexp, kısaltmanın iki harfini ilk ve son harflerle eşleştirir
• İlk bölüm iki kelimeden fazla olan durumlarla eşleşir (Columbia Bölgesi dahil)
• İkinci kısım Alaska ve Arizona ile eşleşiyor
• Üçüncü bölüm Massachusets, Mississippi ve Missouri ile eşleşiyor
• Dördüncü kısım Michigan, Minnesota ve Montana ile eşleşti
• Beşinci bölüm Nebraska ve Nevada ile eşleşti
• Altıncı bölüm, geri kalan tüm ülkeleri ilk iki harfiyle kısaltılmış, Iowa'yı dışlayan özel bir durumla eşleşiyor
• Yedinci bölüm, ilk ve üçüncü harflerle kısaltılmış olan tüm kalan durumlarla eşleşir
• Sekizinci bölüm, ilk ve son harfleriyle kısaltılmış olan diğer her şeyle eşleşir.
• O zaman sadece bu harflerin çıkarılması ve büyük harf kullanımı ile ilgili bir durum.
• Ayrıca Porto Riko ve Amerikan Samoası ile eşleşir ancak Guam, Marianas adaları veya ABD Virjin Adaları ile eşleşmez.

JavaScript, 137 135 134 132 113 110 108 101 99 94 93 92 bayt

Bu, regex dışında bazı iyileştirmeler ve içinde birkaç tweaks olan HP Williams çözümüne dayanıyor.

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

(Yalnızca okunabilirlik için satır başlıkları)

Regex için yorum:

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

Anlamsız alternatif regex (aynı uzunluk):

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

Tarih

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 bayt

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]

gösteri

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

Jöle , 75 bayt

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

Çevrimiçi deneyin!

... ya da bir test takımına bakın - Bir seferde birden fazla giriş için tam programı çalıştırmak için küçük bir değişiklik yapılması gerektiğine dikkat edin (Program giriş atomunu, ³kayıttan geri çağırmak için bir program için değiştirdim ®ve kayıt defterini ayarladım) sırayla her bir devlet adına).

Nasıl?

Posta kodunun ikinci karakteri için kullanılacak dizini hesaplar, ilk karaktere ekler ve sonucu büyük harflerle yazar.

İlk önce bir boşluk karakterinin indeksini bulur (veya bulunmazsa 0);

Başka Alaska veya Missouri olup olmadığını kontrol eder (için 5 veren kveya o);

Başka ise, listedeki giriş durumunun dizinini bulur Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(veya bulunamazsa 0) - eğer öyleyse bu indeks mod 2 plus 3'ü (for z n s v t x n) alır;

Else, dizgeyi sıralılara dönüştürür, üs 256'dan dönüştürür, geri kalanını 29487'ye böldükten sonra kalanı bulur, geri kalanını 14'e böldükten sonra bulur ve bunu 9620'nin ikili gösterime endekslemek için kullanır ve sonucu iki katına çıkarır - 0 son mektubunu kullanan devletler için, ikinci mektubunu kullananlar için ise 2.

İlk vaka hariç tümü artar, sonuçta elde edilen değer azalır (bir bulunan boşluğun endeksini yükseltir).

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 bayt

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]

Çevrimiçi deneyin!

Kısaltmanın ikinci karakterini bulmak için basit bir karma işlevi kullanır.

Python 2, 94 90 bayt

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

Çevrimiçi deneyin

(Yalnızca Python 2 çünkü Python 3 karmaları kararlı değildir ve baytlara dönüştürmeden bir dizgiye de sahip olamazsınız.)

Tüm 50 eyalete ek olarak, bir de Columbia ve Porto Riko bonus bölgesi olarak çalışıyor.

Baz-36: 'daki sayıyı yazarak bir bayt tasarruf etmek mümkün olacaktır int("5clu7x0aixb0pelmpugv5iiibphrpf",36). Daha yaratıcı bir çözüm düşünebilecek miyim diye bakmayı bekliyorum.

Güncelleme:

Karmada 12 kullanılmamış rakam konumu bulunduğundan, çalışacak 2 ³⁶ olası sayı vardır. Bunlardan birinin büyük bir üs ile ana bir faktör olacağına inanmak makul görünüyordu. Herhangi bir asal ve üs için, bir değer bulmak oldukça hızlıdır; 19 ⁹ faktörüne sahip bir tane bulmayı başardım , sayıyı dört bayt olarak göstermek için gereken ifadenin boyutunu azalttım.

Bu temelde C cevabım ile aynı prosedür ama Python kullanıyor. Temel karma fonksiyonu farklı olduğu için, mod 54 yerine mod 52'ye dönüşen farklı bir azaltma fonksiyonu bulmam gerekiyordu. Fakat C'ye göre en büyük tasarruf, vektörü kodlamak için bignum kullanma olasılığından ve elbette Python'un standardının, tam bir program yerine lambda hazır bilgisini kullanmanın doğru olduğu görülüyor.

Retina , 113 81 80 77 70 68 bayt

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

T`l`L

Çevrimiçi deneyin! 51 test vakasının tümünü içerir. @ JörgHülsermann'ın ikinci mektubu bulan regex'ine uygun olarak 32 bayt kurtarıldı (DC'yi desteklemek için ince ayarlarla; düzenleme: @ JörgHülsermann sayesinde 1 bayt kurtarıldı). @ SteveBennett'in regex'ine yorumundan @ HPWilliam'ın cevabına geçerek 3 bayt kurtardı. Kaydedilen 7 @SteveBennett 9 bayt tekrar teşekkürler. Diğer harfler daha sonra silinir ve dize büyük harfle yazılır.

PHP> = 7.1, 113 Bayt

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

Çevrimiçi sürüm

Grevler, daha önceki bir maçtan önce oynanır.

([vxz])maçlar Arizona, Nevada, New Mexico, Pennsylvania, Teksas,

(.) (bir boşluk önce) New Hampshire, New Jersey, New Mexico, New York, Kuzey Carolina, Kuzey Dakota, Rhode Island, Güney Carolina, Güney Dakota, Batı Virginia ile eşleşir

[CGHKLPV].*(.)maçlar California, Colorado, Connecticut, Georgia, Havai, Kansas, Kentucky, Louisiana, New Hampshire , Kuzey Carolina, Pennsylvania, Güney Carolina , Vermont, Virginia, Batı Virginia

ow(a) Iowa maçı

las(k) Alaska maçı

ssi?(.)maçlar Massachusetts, Mississippi, Missouri, Tennessee

n(n|t|[de]$)maçlar Connecticut, Kentucky, Maine, Maryland, Minnesota, Montana, Pensilvanya, Rhode Island, Tennessee, Vermont

Bu eyaletlerle eşleşmiyor bu yüzden ilk iki harfi alacağız Alabama, Arkansas, Delaware, Florida, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregon, Utah, Washington, Wisconsin, Wyoming

Bu Regex Alt Yazıcısını ilk kez kullandığımda ?|, geri referansları bir tanede depolamaya izin veriyor.

Columbia Bölgesi'ni destekleyin

+3 Bayt (.)ile değiştirin([^o])

Çevrimiçi deneyin!

PHP, 150 Bayt

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

Çevrimiçi deneyin! testcases

PHP, 887 854 bayt

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

Çevrimiçi deneyin!

İlk zamanlayıcı, yaşasın!

C, 945 937 718 711 660 616 bayt

Yalnızca ASCII sayesinde 219 bayt kaydedildi.

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

Gereksiz Newline, sadece gösterim amaçlıdır. Durumu girdi olarak alır. Çevrimiçi deneyin!

Nasıl çalışır:

• struct{int*a,b;}m[]=...mdört baytlık bir dize ve bir karakter olan iki değerli bir harita bildirir . Bu, char*aharitada ikinci ile beşinci dizinleri karşılaştıran karşılaştırma döngüsünde kullanılır .
• gets(b)bir dize okur b. Bu kısaltılacak devlet olacaktır.
• putchar(*b) Her bir kısaltma, durumun ilk harfiyle başladığından, bu dizgenin ilk karakterini yazdırır.
• for(;m[i].a;i++)Haritanın her bir değeri boyunca dolaşır. (Bu kısaltılabilir.)
• if(!strncmp(m[i].a,b+1,4))mevcut harita değerini, ikinci ile beşinci karakter arasında b(kısaltılacak durum) karşılaştırır. Bunun nedeni, tek farkın ilk beş karakterde olması, ancak biz zaten ilk karakteri bastık.
• puts(&m[i].b); kısaltmanın ikinci harfini (durum adı geçerli harita değeriyle eşleşiyorsa) ve yeni bir satır yazdırır.

C, 148 141 bayt

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)girişin ikinci ila beşinci karakterini bir tamsayı olarak kabul eder; bu tamsayı daha sonra karma kullanılarak 0-56'ya bölünmüştür i%663694%57. Özetlenmiş değer daha sonra kısaltmanın ikinci harfinin konumunu temsil eden ofset vektöründe aranır. Bu belirli dört baytı seçtim çünkü (1) Missouri ve Mississippi ilk olarak beşinci karakterde farklılık gösteriyor ve (2) bazı eyaletlerde sadece dört karakter var. (Bu, hem Kuzeyleri hem de Güneyleri aynı değere getirmektedir. Ancak bunun nedeni, ilişkili ofsetin hepsi için 6 olmasıdır.)

Olduğu gibi, söz konusu karma, Columbia Bölgesi, Porto Riko ve "Virgin Adaları" nın kısaltmasının ikinci harfleri için doğru pozisyonu veriyor (bu şekilde, "ABD Virgin Adaları" olarak yazılmadı, çünkü algoritma ilk önce ısrar ediyor. kısaltmanın karakteri ismin ilk karakteridir).

663694 ve 57 sabitleri otomatik bir testle bulundu; 57, bulduğum en küçük karma değerdi. (İlk sürüm 380085 ve 63'ü kullandı, ancak test aralığını genişlettiğimde yenisini buldum.) "Addaki son karakteri kullan" için bir kod eklenirse biraz daha küçük bir karma olduğu görünüyor; ne yazık ki, son karakteri seçmek için C sözdizimi bu yardımcı olmak için çok endişe vericidir.

Sadece 8 farklı ofset vardır, bu yüzden giriş başına üç bit içeren 171 bitlik (3 * 57) bir arama tablosunda saklanabilirlerdi. Ancak bu bitleri programa verimli bir şekilde yerleştirmenin bir yolunu düşünemedim. Hex-kodlama dört bit başına yaklaşık bir karakter, artı 0xönekler gerektirir. Dize sürümünden çok daha uzun olan 151 bayttan daha iyi yapamadım. 171 bit bir şekilde ham sekizli metinler olarak eklenebilirse, 22 baytlık yer kaplarlardı, bu nedenle bir çözüm olabilirdi, ancak bir dosyayı okumak tıkalı.

Aslında , 181 bayt

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

Bu çözüm girdiyi kote edilmiş bir dize olarak bekler.

Çevrimiçi deneyin!

açıklama

Bu çözüm benim Python 3 çözümümle aynı karma stratejiyi kullanıyor . Kısacası, karma değerinin nasıl hesaplandığının ve neden seçildiğinin açıklamasını ihmal edeceğim (o kısmı istiyorsanız diğer cevabı okuyun).

Ayrıca, kısalık için, çok uzun dizelerin içeriğini dışarıda bırakacağım çünkü aksi halde açıklama okunaklı olmayacaktı.

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 bayt

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]

Çevrimiçi deneyin!

Girişin bir bayt nesnesi (Unicode dizesi yerine bir bayt dizesi) olması beklenir.

Saçma bir miktar bayt için Johnathon Allan'a teşekkürler

açıklama

Her durum adı, karma auygulayarak bir tamsayıya yazılır a = sum(o*5**i) % 236( okarakterin ASCII sırasındaki karakteridir ive dizgede dizinidir, sonundan geriye doğru sayılır). Modül 236seçildi, çünkü tüm karma değerlerinin 50 ABD devlet adı için farklı olmasına neden olan en küçük modül olduğu için seçildi. Bu karma değerler daha sonra durum kısaltmalarına eşlenir ve ortaya çıkan sözlük (dize değiştirme kullanılarak sıkıştırılmış) bir durum adı verilen kısaltmaya bakmak için kullanılır (uygun anahtarı elde etmek için hash).

Ruby, 106 103 bayt

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

Giriş boşluk içeriyorsa, ikinci çıkış harfi boşluktan sonraki harfdir. Başka...

Girişteki tüm karakterlerin toplamını, sihirli dizedeki dizini girdi dizisindeki ikinci çıktı harfinin dizinini belirten bir karakter elde etmek için, formülüne göre j>8?j/4:-1(-1, son anlamına gelir). Karma, sihirli dizgide olmayan bir karakter verirse, ikinci harf ikinci girdi harfidir.

Sihirli dizgenin bir açıklaması olarak, karma karakterler ve kodladıkları harf indeksleri aşağıdadır. Delaware'in ikinci mektubun yapmasına rağmen göründüğünü unutmayın - bunun nedeni karma kodunun Kentucky ile çakışmasıdır. Neyse ki Delaware'in son harfi ikincisiyle aynı.

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 

Test programında Ungolfed

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 bayt

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

Çevrimiçi deneyin!

/// içinde giriş yapmanın başka bir yolu olmadığından programın sonuna gider. Sadece istediğiniz girişi programa ekleyin.

@SteveBennett tarafından önerilen şekilde daha fazla değişiklik yaparak 11 bayt kurtardı

Python 2 , 131 125 bayt

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]

Çevrimiçi deneyin!

TAESGL , 386 bayt

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

tercüman

Durum adlarının çok basit bir şekilde sıkıştırılması, kısaltmaları içeren bir diziye eklenir.

Japt, 383 bayt

İlk dizenin sıkıştırılması, harflerin sırasını denemek suretiyle geliştirilebilir.

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

Çevrimiçi deneyin

Mathematica, 138 140 134 Bayt

+2 bayt - bir hata bulundu

-6 bayt - daha iyi bir karma bulundu

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

Diğerlerine benzer şekilde adını alır ve ilk harfi alır. Sonra varsayılan Mathematica karma uygular sonra iki modül uygular "Hash@#~Mod~89866736~Mod~73 , her durum için benzersiz bir sayı elde " . Bu değer daha sonra ikinci harfi oluşturmak için bir dizgede aranır.

Muhtemelen daha çok golf oynayabilir ancak arama alanı Mathematica'nın bulması için çok büyük. Kopyalanan ikinci harf karma aramada dikkate alınmadı. _karakterleri, dizgideki harcanan değerleri temsil eder. Teoride dizgiyi sadece 19 karaktere indirgeyebilirsiniz, ancak bunu üretmek için özel hash bulmak bir kabus olurdu.

Perl 5, 150 148 bayt (147 + 1)

Bu hiçbir şekilde optimal değildir, ancak işini yapar. İhtiyaç -nkomut satırı işaretini.

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 bayt

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]

Çevrimiçi deneyin!

Arnauld'un cevabının limanı .