왼쪽에 50 개의 미국 주 이름 중 하나가 입력으로 주어지면 오른쪽에 표시된대로 2 자리 우편 번호 를 출력 하십시오.

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 가지 상태 이름 중 하나라고 가정 할 수 있습니다.
• 인터넷에 액세스하거나 내장 상태 데이터를 사용할 수 없습니다 (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, 버진 아일랜드 등

채점

이것은 code-golf 이므로 각 언어에서 가장 짧은 바이트 단위의 코드가 이깁니다 .

(원래 ETHProductions가 제안 함)

자바 스크립트, 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()

설명:

• 정규 표현식은 첫 글자와 마지막 글자와 약어의 두 글자를 찾습니다.
• 첫 번째 부분은 두 단어 이상으로 상태를 일치시킵니다 (컬럼비아 특별구 포함).
• 두 번째 부분은 알래스카와 애리조나와 일치
• 세 번째 부분은 매사추세츠, 미시시피 및 미주리와 일치
• 네 번째 부분은 미시간, 미네소타 및 몬태나와 일치
• 다섯 번째 부분은 네브라스카와 네바다와 일치
• 여섯 번째 부분은 첫 두 글자로 축약 된 나머지 모든 주와 일치하며 아이오와를 제외하는 특별한 경우가 있습니다.
• 일곱 번째 부분은 첫 번째와 세 번째 문자로 축약 된 나머지 모든 상태와 일치합니다.
• 여덟 번째 부분은 첫 번째와 마지막 문자로 축약 된 다른 모든 항목과 일치합니다.
• 그런 다음 그 글자를 지우고 대문자로 쓰는 경우입니다.
• 푸에르토 리코 및 아메리칸 사모아와 일치하지만 괌, 마리아나 스 제도 또는 미국령 버진 아일랜드와는 일치하지 않습니다.

자바 스크립트, 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

자바 스크립트 (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

온라인으로 사용해보십시오!

... 또는 테스트 스위트를 참조하십시오 -한 번에 여러 입력에 대해 전체 프로그램을 실행하기 위해 약간의 변경이 필요했습니다 ( ³레지스터 ®,, 1 에서 리콜하기 위해 프로그램 입력 원자를 교체 하고 레지스터를 설정해야 함) 차례로 각 주 이름으로).

어떻게?

우편 번호의 두 번째 문자에 사용할 색인을 계산하여 첫 번째 문자에 추가하고 결과를 대문자로 만듭니다.

먼저 공백 문자의 색인을 찾습니다 (또는 찾지 못한 경우 0).

Els는 알래스카 또는 미주리 (5 일 k또는 5 일 o)인지 확인합니다.

Else는 목록에서 입력 상태의 인덱스를 찾습니다 Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(또는 찾을 수없는 경우 0 z n s v t x n).

Else는 문자열을 서수로 변환하고 밑을 256에서 변환하고 29487로 나눈 후 나머지를 찾고 14로 나눈 나머지를 찾은 다음이를 9620의 이진 표현으로 색인화하고 결과를 두 배로하여 결과를 두 배로 만듭니다. 최종 문자를 사용하는 주와 2 번째 문자를 사용하는 주에 대해

첫 번째 경우를 제외하고 모두 증가하고 결과 값이 감소합니다 (공간 인덱스가 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'

파이썬 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]

온라인으로 사용해보십시오!

간단한 해시 함수를 사용하여 약어의 두 번째 문자를 찾습니다.

파이썬 2, 94 90 바이트

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

온라인으로 사용해보십시오

(파이썬 3 해시는 안정적이지 않으며 문자열을 바이트로 바꾸지 않으면 해시 할 수 없기 때문에 파이썬 2 만 해당됩니다.)

50 개 주와 함께 작동하며 보너스 디스트릭트 디스트릭트와 푸에르토 리코로 보너스를 제공합니다.

base-36에 숫자를 쓰면 1 바이트를 절약 할 수 있습니다 int("5clu7x0aixb0pelmpugv5iiibphrpf",36). 더 창의적인 솔루션을 생각할 수 있는지 기다리고 있습니다.

최신 정보:

해시에는 12 개의 사용되지 않는 숫자 위치가 있기 때문에 236 ^개의 가능한 숫자가 작동합니다. 그들 중 하나가 지수가 큰 주요 요소를 가지고 있다고 믿는 것이 합리적이었습니다. 주어진 소수와 지수에 대해 값을 찾는 것은 매우 빠릅니다. 나는 인수가 19 ⁹ 인 것을 찾아서 4 바이트로 숫자를 나타내는 데 필요한 표현식의 크기를 줄였습니다.

이것은 기본적으로 C 답변 과 동일한 절차 이지만 Python을 사용합니다. 기본 해시 함수가 다르기 때문에 다른 축소 함수를 찾아야했는데 mod 54 대신 mod 52로 나타났습니다. 그러나 C보다 큰 절감 효과는 bignums를 사용하여 벡터를 인코딩 할 수 있다는 것입니다. 파이썬의 표준은 완전한 프로그램 대신 람다 리터럴을 사용하는 것이 좋습니다.

망막 , 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 바이트를 절약했습니다. 저장된 7 개 @SteveBennett 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 Subpatter ?| 를 처음 사용하면 역 참조를 하나로 저장할 수 있습니다.

컬럼비아 특별구 지원

교체 (.)로 ([^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, 887,854 바이트

<?=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[]=...m4 바이트 문자열과 하나의 문자라는 두 가지 값 으로 맵 을 선언합니다 . 이것은 비교 루프에서 사용되며 char*a맵에서 두 번째에서 다섯 번째 색인을 비교합니다 .
• gets(b)문자열을 읽습니다 b. 이것이 약어 상태가됩니다.
• putchar(*b) 각 약어가 상태의 첫 번째 문자로 시작하므로 해당 문자열의 첫 번째 문자를 인쇄합니다.
• for(;m[i].a;i++)지도의 각 값을 반복합니다. (단축 될 수 있습니다.)
• if(!strncmp(m[i].a,b+1,4))현재지도 값을 두 번째에서 다섯 번째 문자 b(약어 상태)와 비교합니다. 첫 5 개의 문자 만 다른 점이 있지만 이미 첫 번째 문자를 인쇄했기 때문입니다.
• 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)입력의 두 번째 문자부터 다섯 번째 문자를 정수로 간주합니다. 그 정수는 해시를 사용하여 0-56으로 해시 i%663694%57됩니다. 그런 다음 해시 값은 약어의 두 번째 문자 위치를 나타내는 오프셋 벡터로 조회됩니다. 나는 (1) 미주리 주와 미시시피 주가 다섯 번째 문자에서 처음으로 다르고 (2) 일부 주에는 4 문자 만 있기 때문에 특정 4 바이트를 선택했습니다 .C에서는 NUL 종결 자 바이트를 사용할 수 있지만 그 이상은 신뢰할 수 없습니다. (이것은 남북뿐만 아니라 남북을 같은 값으로 해시합니다. 그러나 관련 오프셋이 모두 6이기 때문에 중요하지 않습니다.)

이 특정 해시는 알고리즘이 첫 번째로 약어의 문자는 이름의 첫 문자입니다.

상수 663694 및 57은 자동 테스트로 확인되었습니다. 57은 내가 찾은 가장 작은 해시 범위입니다. (첫 번째 버전은 380085와 63을 사용했지만 테스트 범위를 확장했을 때 새로운 범위를 찾았습니다.) "이름의 마지막 문자 사용"에 코드를 추가하면 약간 작은 해시가 존재하는 것 같습니다. 불행히도 마지막 문자를 선택하기위한 C 구문은 너무 유용하여 도움이되지 않습니다.

8 개의 서로 다른 오프셋이 있으므로 항목 당 3 비트로 172 비트 (3 * 57) 조회 테이블에 저장 될 수 있습니다. 그러나 그 비트를 프로그램에 효율적으로 삽입하는 방법을 생각할 수 없었습니다. 16 진 인코딩은 4 비트 당 약 1 개의 문자와 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

파이썬 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]

온라인으로 사용해보십시오!

입력은 bytes 객체 (유니 코드 문자열이 아닌 바이트 문자열)로 예상됩니다.

터무니없는 바이트 수에 대한 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 바이트를 절약했습니다.

파이썬 2 , 131125 바이트

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

통역사

약어로 배열에 추가 된 상태 이름을 매우 간단하게 압축합니다.

apt, 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 바이트-실수 발견 (0이 아닌 1의 어레이 오프셋 필요)

-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 자로 줄일 수 있지만 사용자 정의 해시를 찾는 것은 악몽입니다.

펄 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"

파이썬 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]

온라인으로 사용해보십시오!

Arnauld의 답변 포트입니다 .