En sélectionnant l’un des 50 noms d’ États américains à gauche, indiquez son code postal à deux lettres comme indiqué à droite:

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

Règles

• L'entrée et la sortie sont sensibles à la casse. Vous ne pouvez pas sortir beaucoup, par exemple, Alpour Alabama.
• Vous pouvez supposer que l'entrée est l'un des 50 noms d'états indiqués ci-dessus.
• Vous ne pouvez pas accéder à Internet ou utiliser des données d'état intégrées (Mathematica vous regarde).

Vous pouvez trouver des listes séparées d’entrées et de sorties dans cet extrait (veuillez ne pas l’exécuter, c’est juste pour compresser le post):

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

(Non-marquant) Points Brownie si vous pouvez également prendre District of Columbiaen entrée et produire DC, Iles Vierges, etc. etc.

Notation

C'est du code-golf , donc le code le plus court en octets dans chaque langue gagne .

(Initialement proposé par ETHProductions)

Javascript, 124 117 octets

(sauvé 7 octets grâce à 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()

Explication:

• L'expression rationnelle trouve une correspondance avec les première et dernière lettres et les deux lettres de l'abréviation
• La première partie correspond aux États avec plus de deux mots (y compris le District de Columbia)
• Deuxième partie correspond à l'Alaska et l'Arizona
• Troisième partie correspond à Massachusets, Mississippi et Missouri
• La quatrième partie correspond au Michigan, au Minnesota et au Montana
• La cinquième partie correspond au Nebraska et au Nevada
• La sixième partie correspond à tous les États restants abrégés en leurs deux premières lettres, avec un cas particulier pour exclure l'Iowa
• La septième partie correspond à tous les états restants abrégés en leurs première et troisième lettres
• La huitième partie correspond à tout le reste, abrégé en première et dernière lettres
• Ensuite, il s’agit simplement de dépouiller ces lettres et de capitaliser
• Correspond aussi à Porto Rico et aux Samoa américaines, mais pas à Guam, aux îles Mariannes ni aux îles Vierges américaines.

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

Ceci est basé sur la solution HP Williams, avec quelques améliorations en dehors de la regex et quelques ajustements en son sein.

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

(Linebreaks pour la lisibilité seulement)

Commentaire pour la 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 alternative inutile (même longueur):

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

Histoire

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 octets

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]

Démo

let f =

s=>s[0]+'.KT..N.VEA.XVL.H.TZ.AA..I.EADATO.JTISRDIYOI.DALA.Y.KE.C.D.R.YAS.NM...C.L...N'[parseInt(s.split` `.join``,36)%359%248*8%99*3%83]

;[
  "Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho",
  "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi",
  "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio",
  "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia",
  "Washington", "West Virginia", "Wisconsin", "Wyoming"
]
.map(s => console.log(s, '-->', f(s)))

Gelée , 75 octets

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

Essayez-le en ligne!

... ou voir une suite de tests - Notez qu'un petit changement a dû être fait pour exécuter le programme complet pour plusieurs entrées en une fois (j'ai échangé l'atome d'entrée du programme ³, pour un rappel du registre ®, un et définir le registre à chaque nom d’état).

Comment?

Calcule l'index à utiliser pour le deuxième caractère du code postal, l'ajoute au premier caractère et met en majuscule le résultat.

Trouve d’abord l’index d’un caractère espace (ou 0 si non trouvé);

Sinon vérifie s'il s'agit de l'Alaska ou du Missouri (en rapportant 5 pour kou o);

Else trouve l'index de l'état d'entrée dans la liste Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(ou 0 s'il n'est pas trouvé) - si c'est le cas, il prend cet index mod 2 plus 3 (pour z n s v t x n);

Else convertit la chaîne en ordinaux, convertit celle de la base 256, trouve le reste de celle-ci après l'avoir divisé par 29487, trouve le reste de celle-ci après la division par 14 et l'utilise pour l'indexation dans la représentation binaire de 9620 et double le résultat - 0 pour les États qui utilisent leur dernière lettre et 2 pour ceux qui utilisent leur deuxième lettre.

Tous les cas sauf le tout premier sont incrémentés et la valeur résultante est décrémentée (en augmentant l'index d'espace trouvé de un).

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 octets

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]

Essayez-le en ligne!

Utilise une simple fonction de hachage pour trouver le deuxième caractère de l'abréviation.

Python 2, 94 90 octets

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

Essayez-le en ligne

(Uniquement Python 2 car les hachages Python 3 ne sont pas stables et vous ne pouvez pas hacher une chaîne sans la transformer en octets.)

Fonctionne avec les 50 états, plus en prime District de Columbia et Porto Rico.

Il serait possible d'enregistrer un octet en écrivant le numéro dans la base-36: int("5clu7x0aixb0pelmpugv5iiibphrpf",36). J'attends de voir si je peux penser à une solution plus créative.

Mise à jour:

Puisqu'il y a 12 positions de chiffres inutilisées dans le hachage, il y a 2 ³⁶ nombres possibles qui fonctionneront. Il semblait raisonnable de croire que l'un d'entre eux aurait un facteur primordial avec un exposant important. Pour un nombre premier et un exposant donnés, trouver une valeur est assez rapide; J'ai réussi à en trouver un avec un facteur de 19 à ⁹ , réduisant la taille de l'expression nécessaire pour représenter le nombre par quatre octets.

Ceci est fondamentalement la même procédure que ma réponse C mais en utilisant Python. Comme la fonction de hachage de base est différente, je devais trouver une fonction de réduction différente, qui s’avère être le mod 52 au lieu du mod 54. Mais les économies les plus importantes par rapport à C proviennent de la possibilité d’utiliser bignums pour coder le vecteur, et bien sûr. le fait que la norme pour Python semble être qu'il est correct d'utiliser un littéral lambda au lieu d'un programme complet.

Retina , 113 81 80 77 70 68 octets

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

T`l`L

Essayez-le en ligne! Comprend les 51 cas de test. Sauvegardé 32 octets en s'appropriant le regex de @ JörgHülsermann qui trouve la deuxième lettre (avec un tweak pour supporter DC; edit: sauvegardé 1 octet grâce à @ JörgHülsermann). Sauvegardé de 3 octets en basculant dans la regex @ SteveBennett de son commentaire à la réponse @ HPWilliam. Sauvé 7 9 octets merci encore à @SteveBennett. Les autres lettres sont ensuite supprimées et la chaîne mise en majuscule.

PHP> = 7.1, 113 octets

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

Version en ligne

Les frappes sont identiques lors d'un match précédent avant

([vxz])correspond à Arizona, Nevada, Nouveau Mexique, Pennsylvanie, Texas,

(.) (une case avant) correspond aux New Hampshire, New Jersey, Nouveau-Mexique, New York, Caroline du Nord, Dakota du Nord, Rhode Island, Caroline du Sud, Dakota du Sud, Virginie de l'Ouest

[CGHKLPV].*(.)matchs Californie, Colorado, Connecticut, Géorgie, Hawaii, Kansas, Kentucky, Louisiane, New Hampshire , Caroline du Nord, Pennsylvanie, Caroline du Sud , Vermont, Virginie, Virginie de l'Ouest

ow(a) correspondre à l'Iowa

las(k) correspondre à l'Alaska

ssi?(.)matchs Massachusetts, Mississippi, Missouri, Tennessee

n(n|t|[de]$)matchs du Connecticut, du Kentucky, du Maine, du Maryland, du Minnesota, du Montana, de la Pennsylvanie, du Rhode Island, du Tennessee et du Vermont

Aucune correspondance pour ces états, nous prenons donc les deux premières lettres Alabama, Arkansas, Delaware, Floride, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregon, Utah, Washington, Wisconsin, Wyoming

La première fois que je me sers de ce Regex Subpatter ?| avec permet de stocker les références arrières en un.

Soutenir le district de Columbia

Remplacer (.)par ([^o])+3 octets

Essayez-le en ligne!

PHP, 150 octets

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

Essayez-le en ligne! Testcases

PHP, 887 854 octets

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

Essayez-le en ligne!

Première minuterie, hourra!

C, 945 937 718 711 660 616 octets

219 octets enregistrés grâce à ASCII uniquement.

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

Newline inutile, uniquement à des fins d'affichage. Prend l'état en entrée. Essayez-le en ligne!

Comment ça fonctionne:

• struct{int*a,b;}m[]=...déclare une carte mavec deux valeurs - une chaîne de quatre octets et un caractère. Ceci est utilisé dans la boucle de comparaison, qui compare les deuxième au cinquième index de char*ala carte.
• gets(b)lit une chaîne b. Ce sera l'état à abréger.
• putchar(*b) affiche le premier caractère de cette chaîne, puisque chaque abréviation commence par la première lettre de l'état.
• for(;m[i].a;i++)parcourt chaque valeur de la carte. (Cela pourrait être raccourci.)
• if(!strncmp(m[i].a,b+1,4))compare la valeur actuelle de la carte aux deuxième au cinquième caractères de b(l'état à abréger). En effet, les seules différences concernent les cinq premiers caractères, mais nous avons déjà imprimé le premier caractère.
• puts(&m[i].b); affiche la seconde lettre de l’abréviation (si le nom de l’état correspond à la valeur actuelle de la carte) et une nouvelle ligne.

C, 148 141 octets

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)considère que le deuxième au cinquième caractère de l'entrée est un entier; cet entier est ensuite haché en 0-56 en utilisant le hachage i%663694%57. La valeur hachée est ensuite recherchée dans un vecteur de décalages qui représente l'emplacement de la seconde lettre de l'abréviation. J'ai choisi ces quatre octets particuliers car (1) le cinquième caractère est différent du Missouri et du Mississippi, et (2) certains États n'ont que quatre caractères. En C, vous pouvez utiliser l'octet de terminaison NUL, mais rien de plus n'est fiable. (Cela hache les deux nord à la même valeur, ainsi que les deux sud. Mais cela n'a pas d'importance, car le décalage associé est de 6 pour toutes ces choses.)

En l’occurrence, ce hachage donne la position correcte pour les secondes lettres des abréviations de District de Columbia, de Porto Rico et de "Virgin Islands" (tapées de cette manière, et non comme "US Virgin Islands", caractère de l’abréviation soit le premier caractère du nom).

Les constantes 663694 et 57 ont été trouvées avec un test automatisé; 57 était la plus petite plage de hachage que j'ai trouvée. (La première version utilisait 380085 et 63, mais lorsque j'ai élargi la plage de test, j'ai trouvé le nouveau.) Il semble qu'un hachage légèrement plus petit existe si un code est ajouté pour "utiliser le dernier caractère du nom"; malheureusement, la syntaxe C pour sélectionner le dernier caractère est trop verbeuse pour rendre cela utile.

Il n'y a que 8 décalages différents, ils pourraient donc être stockés dans une table de consultation de 171 bits (3 * 57) avec trois bits par entrée. Mais je ne pouvais pas penser à un moyen d'insérer ces bits efficacement dans le programme. Le codage hexadécimal nécessiterait environ un caractère sur quatre bits, plus les 0xpréfixes. Je ne pouvais pas faire mieux que 151 octets, ce qui est beaucoup plus long que la version chaîne. Si les 171 bits pouvaient être insérés en tant qu'octets bruts, ils occuperaient 22 octets. Il pourrait donc y avoir une solution, mais la lecture d'un fichier est fastidieuse.

En fait , 181 octets

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

Cette solution attend une entrée sous forme de chaîne entre guillemets.

Essayez-le en ligne!

Explication

Cette solution utilise la même stratégie de hachage que ma solution Python 3 . Par souci de brièveté, je vais omettre l'explication de la manière dont le hachage est calculé et de la raison de son choix (allez lire l'autre réponse si vous voulez ce bit).

Aussi, par souci de brièveté, je vais laisser de côté le contenu des très longues chaînes, car sinon l'explication serait illisible.

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 octets

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]

Essayez-le en ligne!

L'entrée est attendue sous la forme d'un objet octet (une chaîne d'octets plutôt qu'une chaîne Unicode).

Merci à Johnathon Allan pour une quantité absurde d'octets

Explication

Chaque nom d'état est haché en un entier aen appliquant le hachage a = sum(o*5**i) % 236(où oest l'ordinal ASCII d'un caractère et ison index dans la chaîne, en comptant à partir de la fin). Le module a 236été choisi car c’est le plus petit module qui distingue toutes les valeurs de hachage des 50 noms d’états américains. Ces hachages sont ensuite mappés sur les abréviations d'état et le dictionnaire résultant (compressé à l'aide de la substitution de chaîne) est utilisé pour rechercher l'abréviation à l'aide d'un nom d'état (le hachage pour obtenir la clé appropriée).

Ruby, 106 103 octets

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

Si l'entrée contient un espace, la deuxième lettre de sortie est celle après l'espace. Autre...

Hachez la somme de tous les caractères de l'entrée pour obtenir un caractère dont l'index dans la chaîne magique indique l'indice de la deuxième lettre en sortie de la chaîne d'entrée, conformément à la formule j>8?j/4:-1(-1 signifie la fin.). Si le hachage donne un caractère qui n'est pas dans la chaîne magique, la deuxième lettre est la deuxième lettre d'entrée.

Comme explication de la chaîne magique, les caractères de hachage et les index de lettre qu’ils encodent se trouvent ci-dessous. Notez que Delaware apparaît même si la deuxième lettre le ferait - c'est parce que son code de hachage se heurte au Kentucky. Heureusement, la dernière lettre de Delaware est la même que la seconde.

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 

Programme non testé

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 octets

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

Essayez-le en ligne!

Comme il n'y a pas d'autre moyen de prendre une entrée dans ///, cela passe à la fin du programme. Il suffit d’ajouter l’entrée souhaitée au programme.

Sauvegardé 11 octets en faisant plus de remplacements, comme recommandé par @SteveBennett

Python 2 , 131 à 125 octets

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]

Essayez-le en ligne!

TAESGL , 386 octets

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

Interprète

Compression très simple des noms d'états, ajoutés à un tableau avec les abréviations.

Japt, 383 octets

La compression de la première chaîne peut être améliorée en expérimentant l’ordre des lettres.

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

Essayez-le en ligne

Mathematica, 138 140 134 octets

+2 octets - a trouvé une erreur (décalage de tableau requis de 1 à 0)

-6 octets - a trouvé un meilleur hash

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

Semblable à d'autres, il prend le nom et prend la première lettre. Ensuite, il applique le hachage Mathematica par défaut, puis lui applique deux modules " Hash@#~Mod~89866736~Mod~73" pour obtenir un numéro unique pour chaque état. Cette valeur est ensuite recherchée dans une chaîne pour générer la deuxième lettre.

Peut probablement être plus joué au golf, mais l’espace de recherche est immense pour Mathematica. Les secondes lettres dupliquées n'étaient pas prises en compte dans la recherche par hachage. _les caractères représentent les valeurs gaspillées dans la chaîne. En théorie, la chaîne ne pouvait contenir que 19 caractères, mais trouver le hachage personnalisé pour le produire serait un cauchemar.

Perl 5, 150 148 octets (147 + 1)

Ce n'est en aucun cas optimal, mais il fait son travail. Nécessite un -nindicateur de ligne de commande.

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 octets

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]

Essayez-le en ligne!

Un port de réponse d' Arnauld .