Kürzen Sie diesen US-Bundesstaat!

50

Wenn einer der 50 US- Bundesstaatennamen links als Eingabe angegeben ist, geben Sie die zweistellige Postleitzahl wie rechts gezeigt aus:

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

Regeln

  • Eingabe und Ausgabe unterscheiden zwischen Groß- und Kleinschreibung. Du hast viele nicht ausgegeben zB Alfür Alabama.
  • Sie können davon ausgehen, dass es sich bei der Eingabe um einen der 50 oben gezeigten Statusnamen handelt.
  • Sie dürfen nicht auf das Internet zugreifen oder eingebaute Zustandsdaten verwenden (Sie betrachten Mathematica).

Separate Listen mit Ein- und Ausgängen finden Sie in diesem Snippet (bitte nicht ausführen, nur zum Komprimieren des Posts):

Code-Snippet anzeigen

(Nicht-Scoring) Brownie-Punkte, wenn Sie auch District of Columbiaals Input nehmen und produzieren können DC, Virgin Islands, etc. etc.

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache .

(Ursprünglich vorgeschlagen von ETHProductions)

code-golf  string  kolmogorov-complexity  state-abbreviation 
— Steve Bennett
quelle
11
Für diejenigen, die wissen Entity[a="AdministrativeDivision",{#,"UnitedStates"}]@EntityProperty[a,"StateAbbreviation"]&
— möchten
12
@BetaDecay Fragen, die als Off-Topic geschlossen sind, sind keine nützlichen Dupe-Ziele.
— Mego
7
@ DavidC Sie können 20Bytes speichern : Entity["AdministrativeDivision",{#,"UnitedStates"}]@"StateAbbreviation"&:)
— Genisis
2
Zusätzliche Gutschrift für die Aufnahme der anderen 12 zweistelligen Codes in die vollständige offizielle Liste der Abkürzungen für US-Post: AA (ARMED FORCES AMERICAS), AE (ARMED FORCES EUROPE), AP (ARMED FORCES PACIFIC), AS (AMERICAN SAMOA), DC (KOLUMBIEN), FM (FEDERATED STATES OF MICRONESIA), GU (GUAM), MH (MARSHALL ISLANDS), MP (NORTHERN MARIANA ISLANDS), PR (PUERTO RICO), PW (PALAU), VI (VIRGIN ISLANDS).
— Joe Snyder
2
Ja, das ist kein Betrug.
— Christopher

Antworten:

25

Javascript, 124 117 Bytes

(7 Bytes gespart dank 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()

Erläuterung:

  • Der reguläre Ausdruck findet eine Übereinstimmung mit dem ersten und letzten Buchstaben der beiden Buchstaben der Abkürzung
  • Der erste Teil entspricht Bundesstaaten mit mehr als zwei Wörtern (einschließlich District of Columbia).
  • Der zweite Teil entspricht Alaska und Arizona
  • Der dritte Teil entspricht Massachusets, Mississippi und Missouri
  • Der vierte Teil trifft auf Michigan, Minnesota und Montana
  • Der fünfte Teil entspricht Nebraska und Nevada
  • Der sechste Teil entspricht allen verbleibenden Bundesstaaten, die mit den ersten beiden Buchstaben abgekürzt sind, mit einem Sonderfall zum Ausschluss von Iowa
  • Der siebte Teil entspricht allen verbleibenden Zuständen, die mit dem ersten und dritten Buchstaben abgekürzt sind
  • Der achte Teil stimmt mit allen anderen Buchstaben überein, die mit dem ersten und letzten Buchstaben abgekürzt sind
  • Dann geht es nur darum, diese Buchstaben zu entfernen und groß zu schreiben
  • Passt auch zu Puerto Rico und Amerikanisch-Samoa, aber nicht zu Guam, Marianen oder Amerikanischen Jungferninseln
— HP Williams
quelle
Wow, das ist großartig! +1!
— NoOneIsHere
3
Nett! Weitere Möglichkeiten: Die Initiale [A-Z]ist nicht erforderlich, da bekannt ist, dass die Eingabe gültig ist. Der Iowa-Sonderfall kann so verkürzt werden, dass [AFIOUW][^o]er ausgeschlossen wird und für das Finale verbleibt .+.
— HDV
1
Ihre Regex-Maschine ist so effizient im Vergleich zu meiner ... Ich wünschte, es gäbe eine Möglichkeit, sie mit meiner kürzeren Regex zum Laufen zu bringen. Aber sie basieren auf so unterschiedlichen Prinzipien.
— Steve Bennett
1
Nun, es gibt einige, die auf ihre Art seltsam sind. Es gibt eine schöne Sammlung, die sowohl den "ersten und letzten" als auch den "ersten beiden" Regeln entspricht (Colorado, Delaware, Kalifornien ...), aber dann ruiniert Mississippi (MS) sie.
— 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()Können wir auf 100 kommen? :)
— Steve Bennett
22

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

Dies basiert auf der HP Williams-Lösung mit einigen Verbesserungen außerhalb des regulären Ausdrucks und ein paar Verbesserungen darin.

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

(Zeilenumbrüche nur zur besseren Lesbarkeit)

Kommentar für den 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

Sinnloser alternativer regulärer Ausdruck (gleiche Länge):

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

Geschichte

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
quelle
Das ist einfach wahnsinnig, ich wünschte, ich könnte wieder upvoten.
— ETHproductions
Schau jetzt nicht hin! 99!
— Steve Bennett
94. Total verrückt. Ich habe diese Optimierung ...s.s?zufällig entdeckt ( erfasst Mississippi, Missouri, Massachussetts und Alaska). Ich war .*skgerade dabei, das Fragment an einen anderen Ort zu verschieben, und die Tests liefen einfach und bestanden, während das Fragment nirgendwo vorhanden war. Einfachster 5 Charakter Gewinn aller Zeiten!
— Steve Bennett
Wow, und mir ist gerade aufgefallen, dass ...s.s?das auch versehentlich zu Kansas passt und wie durch ein Wunder immer noch das richtige Ergebnis liefert.
— Steve Bennett
Und noch ein Charakter mit M[onti]+. So seltsam: Wenn der Zustand mit M beginnt, ist der zweite Buchstabe der letzte in einer Folge von mindestens einem o, n, t oder i. Eine sehr seltsame Art, Michican, Minnesota oder Montana einzufangen.
— Steve Bennett
20

JavaScript (ES6), 156 136 Byte

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

Demo

Code-Snippet anzeigen

— Arnauld
quelle
1
Ist dies mit dieser Methode optimal?
— Nur ASCII
2
@ Nur ASCII Dies ist für beliebige Bereiche brachial erzwungen, daher ist es nur für garantiert optimal X MOD[50-1000] MOD[50-1000] MOD[50-100]. Aber das .slice(1)war ein Fehler. Zur Zeit läuft wieder die ganze Saite.
— Arnauld
2
Können Sie einem Neuling erklären, was dies bewirkt?
— Hankrecords
1
@Hankrecords Sicher, wird es tun. (Aber ich bin gerade in einem Zug mit eingeschränktem Internetzugang.)
— Arnauld
1
jetzt ist meins 135!
— Steve Bennett
17

Jelly , 75 Bytes

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

Probieren Sie es online!

... oder sehen Sie sich eine Testsuite an - Beachten Sie, dass eine kleine Änderung vorgenommen werden musste, um das gesamte Programm für mehrere Eingaben auf einmal auszuführen (ich habe das Programm-Eingabe-Atom ausgetauscht ³, für einen Rückruf aus dem Register ®, eins und das Register gesetzt) zu jedem Zustandsnamen der Reihe nach).

Wie?

Berechnet den Index für das zweite Zeichen der Postleitzahl, hängt ihn an das erste Zeichen an und setzt das Ergebnis in Großbuchstaben.

Findet zuerst den Index eines Leerzeichens (oder 0, wenn nicht gefunden);

Andernfalls wird geprüft, ob es sich um Alaska oder Missouri handelt (mit 5 für koder o).

Andernfalls wird der Index des Eingabezustands in der Liste gefunden Arizona Minnesota Mississippi Nevada Montana Texas Tennessee(oder 0, falls nicht gefunden). In diesem Fall wird der Index Mod 2 plus 3 (für z n s v t x n) verwendet.

Andernfalls wird die Zeichenfolge in Ordnungszahlen konvertiert, die von der Basis 256 konvertiert, der Rest nach der Division durch 29487 ermittelt, der Rest nach der Division durch 14 ermittelt und mit diesem Wert in die Binärdarstellung von 9620 indexiert und das Ergebnis verdoppelt - es ergibt sich 0 für Staaten, die ihren letzten Buchstaben und 2 für diejenigen, die ihren zweiten Buchstaben verwenden.

Alle bis auf den allerersten Fall werden inkrementiert, und der resultierende Wert wird dekrementiert (wobei der um eins gefundene Raumindex erhöht wird).

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
quelle
1
Dies ist das längste Gelee, das ich je gesehen habe =)
— Caird Coinheringaahing
11

Python 2 , 191 Bytes

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]

Probieren Sie es online!

Verwendet eine einfache Hash-Funktion, um das zweite Zeichen der Abkürzung zu finden.

— Nur ASCII
quelle
11

Python 2, 94 90 Bytes

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

Probieren Sie es online aus

(Nur Python 2, da Python 3-Hashes nicht stabil sind und Sie auch keinen String hashen können, ohne ihn in Bytes umzuwandeln.)

Funktioniert mit allen 50 Bundesstaaten sowie als Bonus District of Columbia und Puerto Rico.

Es wäre möglich , ein Byte zu speichern , indem die Zahl in der Basis-36 zu schreiben: int("5clu7x0aixb0pelmpugv5iiibphrpf",36). Ich bin gespannt, ob mir eine kreativere Lösung einfällt.

Aktualisieren:

Da der Hash 12 nicht verwendete Ziffernpositionen enthält, gibt es 2 36 mögliche Zahlen, die funktionieren. Es schien vernünftig zu glauben, dass einer von ihnen einen Primfaktor mit einem großen Exponenten haben würde. Für jede gegebene Primzahl und jeden gegebenen Exponenten ist es ziemlich schnell, einen Wert zu finden. Es gelang mir, einen Ausdruck mit dem Faktor 19 9 zu finden , wodurch die Größe des Ausdrucks, der für die Darstellung der Zahl benötigt wird, um vier Bytes verringert wurde.

Dies ist im Grunde das gleiche Verfahren wie bei meiner C-Antwort, jedoch mit Python. Da die Basis-Hash-Funktion unterschiedlich ist, musste ich eine andere Reduktionsfunktion finden, die sich als Mod 52 anstelle von Mod 54 herausstellt. Die größten Einsparungen gegenüber C ergeben sich jedoch aus der Möglichkeit, Bignums zum Codieren des Vektors zu verwenden, und natürlich Die Tatsache, dass der Standard für Python zu sein scheint, dass es in Ordnung ist, ein Lambda-Literal anstelle eines vollständigen Programms zu verwenden.

— rici
quelle
9

Retina , 113 81 80 77 70 68 Bytes

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

T`l`L

Probieren Sie es online! Beinhaltet alle 51 Testfälle. 32 Bytes gespart durch Aneignung von @ JörgHülsermanns Regex, der den zweiten Buchstaben findet (mit einem Tweak zur Unterstützung von DC; edit: 1 Byte gespart dank @ JörgHülsermann). 3 Bytes gespart, indem er von seinem Kommentar zu @ HPWilliams Antwort zu @ SteveBennetts Regex gewechselt hat. Gespeichert 7 9 Bytes Dank nochmals an @SteveBennett. Die anderen Buchstaben werden dann gelöscht und die Zeichenfolge groß geschrieben.

— Neil
quelle
Sehr schön, hätte nicht gedacht, dass man einen Satz komplett entfernbarer Saiten bekommen könnte.
— Colsw
@ConnorLSW ewar wirklich am problematischsten.
— Neil
@ JörgHülsermann Danke für die Gegenleistung!
— Neil
@ JörgHülsermann Oh, also kann ich dann noch ein Byte speichern?
— Neil
1
Warten Sie, Indiana wird ID. Sie können es wahrscheinlich beheben, indem Sie einfach $ nach dem hinzufügen d. (Möglicherweise möchten Sie automatische Tests verwenden - ich habe ein Skript, das ständig alle 50 Fälle überprüft.)
— Steve Bennett
8

PHP> = 7.1, 113 Bytes

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

Online Version

Die Treffer werden durch ein früheres Anfangsspiel zuvor ausgeglichen

([vxz])Streichhölzer Arizona, Nevada, New Mexico, Pennsylvania, Texas,

(.) (ein Leerzeichen zuvor) entspricht New Hampshire, New Jersey, New Mexiko, New York, North Carolina, North Dakota, Rhode Island, South Carolina, South Dakota, West Virginia

[CGHKLPV].*(.)Streichhölzer Kalifornien, Colorado, Connecticut, Georgia, Hawaii, Kansas, Kentucky, Louisiana, New Hampshire , North Carolina, Pennsylvania, South Carolina , Vermont, Virginia, West Virginia

ow(a) Spiel Iowa

las(k) Spiel Alaska

ssi?(.)Stimmt mit Massachusetts, Mississippi, Missouri, Tennessee überein

n(n|t|[de]$)Streichhölzer Connecticut, Kentucky, Maine, Maryland, Minnesota, Montana, Pennsylvania, Rhode Island, Tennessee, Vermont

Keine Übereinstimmung für diese Staaten, daher nehmen wir die ersten beiden Buchstaben Alabama, Arkansas, Delaware, Florida, Idaho, Illinois, Indiana, Michigan, Nebraska, Ohio, Oklahoma, Oregon, Utah, Washington, Wisconsin, Wyoming

Wenn ich diesen Regex-Subpatter?| zum ersten Mal verwende, können die Rückverweise in einem gespeichert werden.

Unterstützen Sie den District of Columbia

Ersetzen Sie (.)mit ([^o])+3 Bytes

Probieren Sie es online!

PHP, 150 Bytes

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

Probieren Sie es online! Testfälle

— Jörg Hülsermann
quelle
3
Ist n|t|ein Byte nicht kürzer als [nt]|?
— Neil
@ Neil Ja, das ist es. Ich habe es nicht bemerkt. Vielen Dank
— Jörg Hülsermann
7

PHP, 887 854 Bytes

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

Probieren Sie es online!

Erster Timer, Hurra!

— Ivanka Todorova
quelle
1
Auf diese Weise werden im Array ein wenig die Werte mit Leerzeichen oder wo der zweite Buchstabe richtig ist, entfernt. Und $argv[1]wird ersetzt durch $argn sandbox.onlinephpfunctions.com/code/…
— Jörg
@ JörgHülsermann vielen dank! Ich freue mich sehr über eure Antworten hier auf codegolf in php!
— Ivanka Todorova
Ich bin nur ein kleines Licht gegen andere Leute hier. Der Lernaufwand ist gut, wenn jemand eine Verbesserung findet. Ich hoffe, dass Sie in Zukunft weitere Fragen beantworten
— Jörg Hülsermann
7

C 945 937 718 711 660 616 Bytes

219 Bytes nur dank ASCII gespart.

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

Zeilenumbruch nicht erforderlich, nur für Anzeigezwecke. Übernimmt den Zustand als Eingabe. Probieren Sie es online!

Wie es funktioniert:

  • struct{int*a,b;}m[]=...Deklariert eine Map mmit zwei Werten - einer 4-Byte-Zeichenfolge und einem Zeichen. Dies wird in der Vergleichsschleife verwendet, die den zweiten bis fünften Index mit dem char*ain der Karte vergleicht.
  • gets(b)liest eine Zeichenfolge b. Dies ist der abzukürzende Zustand.
  • putchar(*b) Gibt das erste Zeichen dieser Zeichenfolge aus, da jede Abkürzung mit dem ersten Buchstaben des Status beginnt.
  • for(;m[i].a;i++)durchläuft jeden Wert der Karte. (Dies kann möglicherweise gekürzt werden.)
  • if(!strncmp(m[i].a,b+1,4))vergleicht den aktuellen Kartenwert mit dem zweiten bis fünften Zeichen von b(dem abzukürzenden Zustand). Dies liegt daran, dass sich nur die ersten fünf Zeichen unterscheiden, das erste Zeichen jedoch bereits gedruckt wurde.
  • puts(&m[i].b); druckt den zweiten Buchstaben der Abkürzung (wenn der Statusname mit dem aktuellen Kartenwert übereinstimmt) und eine neue Zeile.
— MD XF
quelle
Dies scheint zu einer falschen Ausgabe für die Nord- / Südstaaten zu führen.
— Felix Dombek
6

C 148 141 Bytes

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)betrachtet das zweite bis fünfte Zeichen der Eingabe als Ganzzahl; Diese ganze Zahl wird dann mit dem Hash auf 0-56 gehasht i%663694%57. Der Hash-Wert wird dann in einem Vektor von Offsets nachgeschlagen, die den Ort des zweiten Buchstabens der Abkürzung darstellen. Ich habe diese speziellen vier Bytes ausgewählt, weil (1) Missouri und Mississippi sich zuerst im fünften Zeichen unterscheiden und (2) einige Zustände nur vier Zeichen haben. In C können Sie das NUL-Abschlussbyte verwenden, aber nichts darüber hinaus ist zuverlässig. (Dadurch werden beide Norden und beide Süden auf den gleichen Wert gehasht. Dies spielt jedoch keine Rolle, da der zugehörige Versatz für alle diese Werte 6 beträgt.)

Zufälligerweise ergibt dieser bestimmte Hash die richtige Position für die zweiten Buchstaben der Abkürzungen von District of Columbia, Puerto Rico und "Virgin Islands" (so geschrieben, nicht als "US Virgin Islands", da der Algorithmus darauf besteht, dass der erste die richtige Position ergibt Zeichen der Abkürzung das erste Zeichen des Namens sein).

Die Konstanten 663694 und 57 wurden mit einem automatisierten Test gefunden; 57 war der kleinste Hash-Bereich, den ich gefunden habe. (Die erste Version verwendete 380085 und 63, aber als ich den Testbereich erweiterte, fand ich den neuen.) Es scheint, dass ein etwas kleinerer Hash existiert, wenn ein Code für "das letzte Zeichen im Namen verwenden" hinzugefügt wird; Leider ist die C-Syntax für die Auswahl des letzten Zeichens zu wortreich, um dies hilfreich zu machen.

Es gibt nur 8 verschiedene Offsets. Sie könnten also in einer 171-Bit-Nachschlagetabelle (3 * 57) mit drei Bits pro Eintrag gespeichert sein. Aber ich konnte mir keine Möglichkeit vorstellen, diese Bits effizient in das Programm einzufügen. Hex-Codierung würde ungefähr ein Zeichen pro vier Bits plus die 0xPräfixe erfordern . Ich könnte es nicht besser machen als 151 Bytes, was viel länger ist als die String-Version. Wenn die 171 Bits irgendwie als rohe Oktette eingefügt werden könnten, würden sie 22 Bytes belegen, daher könnte es eine Lösung geben, aber das Lesen einer Datei ist klobig.

— rici
quelle
4

Eigentlich 181 Bytes

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

Diese Lösung erwartet eine Eingabe in Anführungszeichen.

Probieren Sie es online!

Erläuterung

Diese Lösung verwendet dieselbe Hashing-Strategie wie meine Python 3-Lösung . Der Kürze halber werde ich die Erklärung weglassen, wie der Hash berechnet wird und warum er ausgewählt wurde (lesen Sie die andere Antwort, wenn Sie dieses Bit möchten).

Auch der Kürze halber werde ich den Inhalt der sehr langen Zeichenketten weglassen, da sonst die Erklärung unlesbar wäre.

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
quelle
3

Python 3 , 230 Bytes

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]

Probieren Sie es online!

Die Eingabe wird als Byte-Objekt erwartet (eine Byte-Zeichenfolge anstelle einer Unicode-Zeichenfolge).

Vielen Dank an Johnathon Allan für eine absurde Menge an Bytes

Erläuterung

Jeder Zustandsname wird adurch Anwenden des Hashes a = sum(o*5**i) % 236(wobei odie ASCII-Ordnungszahl eines Zeichens und isein Index in der Zeichenfolge ist, beginnend mit dem Ende) zu einer Ganzzahl gehasht . Das Modul 236wurde gewählt, weil es das kleinste Modul ist, bei dem alle Hash-Werte für die 50 US-Bundesstaatsnamen unterschiedlich sind. Diese Hashes werden dann den Zustandsabkürzungen zugeordnet, und das resultierende Wörterbuch (komprimiert durch Zeichenfolgensubstitution) wird verwendet, um die Abkürzung unter Angabe eines Zustandsnamens nachzuschlagen (Hashing, um den entsprechenden Schlüssel zu erhalten).

— Mego
quelle
Speichern Sie 179 Bytes mitlambda 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
... und noch 51 dazu mitlambda 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
Ich bin überrascht, dass das Rückwärtszählen weniger Bytes kostet als eine vorwärtszählende Hash-Funktion - aber ich kann mit ein wenig
— Chris H
1
@ ChrisH Ich dachte, ich hätte eine gefunden, aber die komprimierte Zeichenfolge ist teurer.
— Mego
2

Ruby, 106 103 Bytes

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

Wenn die Eingabe ein Leerzeichen enthält, ist der zweite Ausgabebuchstabe der nach dem Leerzeichen. Sonst...

Hash die Summe aller Zeichen in der Eingabe, um ein Zeichen zu erhalten, dessen Index in der magischen Zeichenfolge den Index des zweiten Ausgangsbuchstabens in der Eingabezeichenfolge gemäß der Formel angibt j>8?j/4:-1(-1 bedeutet das Ende.). Wenn der Hash ein Zeichen enthält, das nicht in der magischen Zeichenfolge enthalten ist, ist der zweite Buchstabe der zweite eingegebene Buchstabe.

Zur Erläuterung der magischen Zeichenfolge sind die Hash-Zeichen und die von ihnen kodierten Buchstabenindizes unten aufgeführt. Beachten Sie, dass Delaware angezeigt wird, obwohl der zweite Buchstabe dies tun würde. Dies liegt daran, dass der Hash-Code mit Kentucky kollidiert. Zum Glück ist der letzte Brief von Delaware der gleiche wie der zweite.

Letter(index)
Last  (-1)  (-MD    )-VA    6-GA-LA  >-DE-KY    P-PA    _-CT    a-KS    c-VT
3rd    (2)  ;-TN    ?-MN    .-TX     O-NV
4th    (3)  }-MS    A-IA    F-MT     L-AZ
5th    (4)  K-MO    M-AK    r-ME     S-HI

Ungolfed im Testprogramm

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
quelle
2

/// , 619 608 Bytes

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

Probieren Sie es online!

Da es keine andere Möglichkeit gibt, Eingaben in /// vorzunehmen, erfolgt die Eingabe am Ende des Programms. Hängen Sie einfach die gewünschte Eingabe an das Programm an.

Durch mehr Ersetzungen wurden 11 Byte gespart, wie von @SteveBennett empfohlen

— Genosse SparklePony
quelle
Es gibt wahrscheinlich einige Muster, die Sie mehrfach auf einmal ersetzen können, wie "Neu" und "Akota". Es ist ärgerlich, dass Sie nicht viel schlauer vorgehen können, als Abschnitte von Staatsnamen zu entfernen, weil das Konvertieren des verbleibenden Zeichens in Großbuchstaben so teuer ist ...
— Steve Bennett
@SteveBennett Bearbeitet, danke!
— Genosse SparklePony
1

TAESGL , 386 Bytes

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

Dolmetscher

Sehr einfache Komprimierung der Statusnamen, hinzugefügt in ein Array mit den Abkürzungen.

— Tom
quelle
1

Japt, 383 Bytes

Die Komprimierung der ersten Saite kann durch Experimentieren mit der Reihenfolge der Buchstaben verbessert werden.

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

Probieren Sie es online aus

— Zottelig
quelle
1

Mathematica, 138 140 134 Bytes

+2 Bytes - Fehler gefunden (benötigter Array-Offset von 1, nicht 0)

-6 Bytes - einen besseren Hash gefunden

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

Ähnlich wie bei anderen nimmt es den Namen und den ersten Buchstaben. Dann wendet es den Standard - Mathematica - Hash an, dann " Hash@#~Mod~89866736~Mod~73" wendet es zwei Module an , um eine eindeutige Zahl für jeden Zustand zu erhalten. Dieser Wert wird dann in einer Zeichenfolge nachgeschlagen, um den zweiten Buchstaben zu generieren.

Kann wahrscheinlich mehr Golf gespielt werden, aber der Suchraum ist riesig für Mathematica zu finden. Doppelte zweite Buchstaben wurden bei der Hash-Suche nicht berücksichtigt. _Zeichen stehen für verschwendete Werte in der Zeichenfolge. Theoretisch könnte man die Zeichenfolge auf nur 19 Zeichen reduzieren, aber es wäre ein Albtraum, den zu produzierenden benutzerdefinierten Hash zu finden.

— Ian Miller
quelle
1

Perl 5, 150 148 Bytes (147 + 1)

Das ist keineswegs optimal, aber es macht seinen Job. Benötigt -nBefehlszeilen-Flag.

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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.