Abréger cet état américain!

50

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

Afficher l'extrait de code

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

code-golf string kolmogorov-complexity state-abbreviation Steve Bennett
la source
11
Pour les curieux de connaître l'approche de Mathematica:Entity[a="AdministrativeDivision",{#,"UnitedStates"}]@EntityProperty[a,"StateAbbreviation"]&
DavidC
12
@BetaDecay Les questions fermées hors sujet ne sont pas des cibles utiles pour la dupe.
Mego
7
@DavidC Vous pouvez économiser des 20octets: Entity["AdministrativeDivision",{#,"UnitedStates"}]@"StateAbbreviation"&:)
ngenisis
2
Offrez un crédit supplémentaire pour avoir inclus les 12 autres codes à deux caractères dans la liste officielle complète des abréviations postales américaines: AA (ARMED FORCES AMERICAS), AE (ARMED FORCES EUROPE), AP (ARMED FORCES PACIFIC), AS (AMERICAN SAMOA), DC (DISTRICT DE COLUMBIA), FM (ÉTATS FÉDÉRÉS DE MICRONÉSIE), GU (GUAM), MH (ÎLES MARSHALL), MP (ÎLES NORTH MARIANA), PR (PUERTO RICO), PW (PALAU), VI (VIERGES).
Joe Snyder
2
Oui ce n'est pas une dupe.
Christopher

Réponses:

25

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.
HP Williams
la source
Wow, c'est génial! +1!
NoOneIsHere
3
Agréable! Quelques autres opportunités: l'initiale [A-Z]n'est pas nécessaire car l'entrée est connue pour être valide. Le cas particulier de l'Iowa peut être abrégé [AFIOUW][^o]pour l'exclure, le laissant pour la finale .+.
hvd
1
Vos machines de regex sont si efficaces comparées aux miennes ... j'aimerais qu'il y ait un moyen de les faire fonctionner avec mon regex plus court. Mais ils sont construits sur des principes si différents.
Steve Bennett
1
Eh bien, il y en a beaucoup qui sont étranges à leur manière. Il y a une belle collection qui correspond à la fois aux règles du "premier et dernier" et des "deux premières" (Colorado, Delaware, Californie ...), mais le Mississippi (MS) le ruine ensuite.
Steve Bennett
1
101: s=>s[0]+/.+[A-Zz]|Nev?|.*sk|M.ss.s?|M[io]n?t?|[AFIOUW][^o]|Te.|.+/.exec(s)[0].slice(-1).toUpperCase()Peut-on arriver à 100? :)
Steve Bennett
22

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
Steve Bennett
la source
Ceci est juste fou, je voudrais pouvoir voter à nouveau.
ETHproductions
Ne regarde pas maintenant! 99!
Steve Bennett
94. Totalement fou. J'ai découvert cette optimisation ( ...s.s?captures du Mississippi, du Missouri, du Massachussetts et de l'Alaska) par accident. J'étais en train de déplacer le .*skfragment à un autre endroit, et les tests ont tout simplement fonctionné et réussi, alors que le fragment n'était présent nulle part. Plus facile gain de 5 caractères jamais!
Steve Bennett
Wow, et je viens de me rendre compte que cela ...s.s?correspond aussi par inadvertance au Kansas et donne toujours, par miracle, le bon résultat.
Steve Bennett
Et encore un personnage avec M[onti]+. Tellement bizarre: si l’état commence par M, alors la deuxième lettre est la dernière d’une séquence d’au moins un o, n, t ou i. Une façon très étrange de capturer Michican, Minnesota ou Montana.
Steve Bennett
20

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

Afficher l'extrait de code

Arnauld
la source
1
Est-ce que cela est forcé d'être optimal en utilisant cette méthode?
ASCII uniquement
2
@ ASCII-only Ceci est renforcé sur les gammes arbitrales, il est donc uniquement garanti d'être optimal pour X MOD[50-1000] MOD[50-1000] MOD[50-100]. Mais .slice(1)c'était une erreur. Actuellement en cours d'exécution sur toute la chaîne.
Arnauld
2
Pourriez-vous expliquer à un newb ce que cela fait?
Hankrecords
1
@Hankrecords Bien sûr, fera l'affaire. (Mais je suis dans un train avec un accès Internet limité actuellement.)
Arnauld
1
maintenant le mien a 135 ans!
Steve Bennett
17

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'
Jonathan Allan
la source
1
C'est la plus longue gelée que j'ai jamais vue =)
caird coinheringaahing
11

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.

ASCII seulement
la source
11

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 36 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 à 9 , 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.

rici
la source
9

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.

Neil
la source
Très sympa, je n'aurais pas pensé que vous pourriez obtenir un ensemble de cordes entièrement amovibles.
Colsw
@ConnorLSW eétait le plus gênant, vraiment.
Neil
@ JörgHülsermann Merci pour la faveur de retour!
Neil
@ JörgHülsermann Oh, alors je vais pouvoir sauvegarder un autre octet?
Neil
1
Attendez, Indiana ne devient ID. Vous pouvez probablement résoudre le problème simplement en ajoutant $ après le d. (Vous voudrez peut-être utiliser des tests automatiques - j'ai un script qui vérifie en permanence les 50 cas.)
Steve Bennett
8

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

Jörg Hülsermann
la source
3
Un n|t|octet n'est-il pas plus court que [nt]|?
Neil
@ Neil Oui c'est. Je ne m'en suis pas rendu compte. Merci
Jörg Hülsermann
7

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!

Ivanka Todorova
la source
1
De cette façon, un peu de golf Dans le tableau sont les valeurs avec espace ou où la deuxième lettre est correctement supprimée. Et $argv[1]est remplacé par $argn sandbox.onlinephpfunctions.com/code/…
Jörg Hülsermann
@ JörgHülsermann merci beaucoup! J'apprécie vraiment vos réponses ici sur codegolf in php!
Ivanka Todorova
Je ne suis qu'un peu de lumière contre les autres ici. L'effort d'apprentissage est bon si quelqu'un trouve une amélioration. J'espère que vous répondez à plus de questions à l'avenir
Jörg Hülsermann
7

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.
MD XF
la source
Cela semble produire une sortie erronée pour les états Nord * / Sud *.
Felix Dombek
6

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.

rici
la source
4

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
Mego
la source
3

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

Mego
la source
Enregistrer 179 octets aveclambda 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'[sum(c*5**i for i,c in enumerate(s[::-1]))%236]
Jonathan Allan
... et un autre 51 en plus aveclambda 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('%','$$').replace('$','!!').replace('!','..')[sum(c*5**i for i,c in enumerate(s[::-1]))%236-5]
Jonathan Allan
Je suis surpris que compter en arrière coûte moins d'octets qu'une fonction de hachage qui compte en avant - mais je ne peux pas en trouver un avec un peu de jeu
Chris H
1
@ChrisH Je pensais en trouver un, mais la chaîne compressée coûte plus cher.
Mego
2

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]]}
Level River St
la source
2

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

Camarade SparklePony
la source
Il y a probablement des motifs que vous pouvez remplacer plusieurs fois à la fois, comme "Nouveau" et "Akota". Ennuyeux de ne pas pouvoir faire beaucoup plus intelligemment, comme de supprimer des sections de noms d'état, car convertir le caractère restant en majuscule coûte tellement cher ...
Steve Bennett
@SteveBennett Edité, merci!
Camarade SparklePony
2

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!

ovs
la source
1

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.

À M
la source
1

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

Hirsute
la source
1

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.

Ian Miller
la source
1

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"
Silvio Mayolo
la source