Meine Familie hat ein E-Commerce-Geschäft. Auf unserer eigenen Website zwingen wir die Benutzer, ihren Status aus einem Dropdown-Menü auszuwählen, wenn sie ihre Adresse eingeben. Über einige andere von uns verwendete Kanäle können Kunden jedoch alles, was sie möchten, in das Feld eingeben.

Meine Mutter liebt die Rechnungsvorlagen, die ich für sie erstellt habe und die automatisch generiert werden. Aber weil sie so hübsch und ausgeglichen sind, kann sie es nicht ertragen, wenn Leute die Namen ihrer Bundesstaaten aufschreiben oder schlimmer noch so etwas wie "New Jersey" schreiben. Sie sagt, es ruiniert den Look.

Mein Vater mag es, wenn Code leicht ist. Anstatt einen Switch-Case-Block zu verwenden, möchte er eine schlankere Lösung.

Die Herausforderung besteht also darin, eine kurze Funktion zu erstellen, die die möglichen Eingaben übernimmt und eine Abkürzung mit zwei Buchstaben zurückgibt (groß geschrieben, für Mama). Wir gehen davon aus, dass unsere Benutzer buchstabieren und immer ein Leerzeichen in den Namen setzen können (wo erforderlich) oder die richtige Abkürzung übergeben können. Der Anwendungsbereich umfasst die 50 US-Bundesstaaten.

• New York
• New York
• NY
• ny

sind alle akzeptablen Eingaben für New York und sollten NY ausgeben.

Wenn so etwas wie New Yrok übergeben wird, kann die Funktion den ursprünglichen Wert zurückgeben.

Sie können jede gängige Sprache verwenden. Dies ist ein Beliebtheitswettbewerb, also gewinnt derjenige mit den meisten Stimmen am Ende einer Woche. Ich gehe davon aus, dass dies Neuheit und Nützlichkeit begünstigen wird.

EDIT: Die Beschreibung ist Story Fluff, aber ich habe an einem ähnlichen Projekt gearbeitet und dachte, dass es einen interessanteren Weg geben muss, dies zu tun. Ich kann das Projekt selbst machen (bereits gemacht), aber ich dachte, dies sei ein guter Ort für eine interessantere Herausforderung. Mit "Jede gemeinsame Sprache" habe ich benutzerdefinierte Sprachen / Bibliotheken ausgeschlossen, die für diese Herausforderung entwickelt wurden. Ich habe versucht, nach neuartigen Methoden zu suchen, anstatt nach kostenloser Code-Hilfe. Ich denke, jeder hat das irgendwann getan, aber es würde Spaß machen, es auf ungewöhnliche Weise zu tun. Ich finde, dass die interessantesten Projekte diejenigen sind, bei denen Sie alltägliche Aufgaben auf neue und interessante Weise angehen - deshalb ist dies eher ein Beliebtheitswettbewerb als Golf.

Rubin

Ich dachte, es wäre interessant, die Zustandsabkürzungen zu extrahieren, ohne einen der Namen oder Abkürzungen explizit zu schreiben. Dieser berücksichtigt keine Rechtschreibfehler der Eingabe, da uns so etwas hier auf codegolf.SE egal ist, rihgt ?

def f(s)
  [
    /(.).* (.)/,              # two words
    /^([CDGHKLPV]).*(.)$/,    # first and last letter
    /^(.).*([ZVX])/,          # unique letter
    /^([NFOUW])(.)/,          # two first letters
    /^(.)([DNR])/,            # unique second letter
    /^(.).*(L|N)\2/,          # double letters
    /^(.).SS(A|O)/,           # double S before the one used
    /^(.).*?[SNW](.)/,        # identified by the letters before them
    /(.)(.)/                  # two first letters

  ].find { |r| r =~ s.upcase }
  $1+$2
end

Es dauerte eine beträchtliche Zeit, um clevere Muster zu finden, die allen Zuständen entsprachen. Die Reihenfolge der Muster ist wichtig - jedes aufeinanderfolgende Muster gilt für die verbleibenden Zustände, die nicht mit einem vorherigen Muster übereinstimmen:

N ew H ampshire, N ew J ersey, N ew M exiko, N ew Y ork, N orth C arolina, N orth D Akota, R hode I SLAND, S outh C arolina, S outh D Akota, W est V irginia

C aliforni a , C olorad o , C onnecticu t , D elawar e , G eorgi a , H awai i , K ansa s , K entuck y , L ouisian a , P ennsylvani a , V irgini a , V ermon t

A ri z ona, N e v ada, T e x as

Fl Orida, Ne Braska, Oh io, Ok Lahoma, oder egon, Ut ah, Wa shington, Wi sconsin, Wy oming

Ar kansas, In diana, Id aho

Es wird wirklich schwierig, allgemeine Muster zu erstellen, aber ...

T en n essee, M in n esota, I l l inois

M ass a chusetts und M iss o uri

A las k a, M arylan d , M ain e , M is s issippi, M on t ana, I ow a

Al Abama, Mi Chigan

Es kann natürlich Golf gespielt werden:

Ruby 2 - 191 165 154 Zeichen

Weitere 26 Zeichen werden entfernt, indem die regulären Ausdrücke ein wenig hässlich gemacht werden. Auch eine der ursprünglichen regulären Ausdrücke erwies sich als redundant!

gets;[/.* (.)/,/^[CDGHKLPV].*(.)$/,/.*([ZVX])/,/^[NFOUW](.)/,/^.([DNR])/,/.*(L|N)\1/,
/.*SS(A|O)/,/.*?[SNW](.)/,/.(.)/].find{|r|$_.upcase=~r}
puts $&[0]+$1

C #

Ich habe Zeichen bereits in den Zuständen für die Abkürzungen verwendet, um die Zustandszeichenfolge zu verkürzen.

public string GetAbbr(string state)
            {

                var states =
                    new[] {
                        "AlasKa", "ALabama", "AriZona", "ARkansas", "CAlifornia", "COlorado", "ConnecticuT",
                        "DElaware", "FLorida", "GeorgiA", "HawaiI", "IDaho", "ILlinois", "INdiana", "IowA", "KansaS",
                        "KentuckY", "LouisianA", "MainE", "MarylanD", "MAssachusetts", "MIchigan", "MinNnesota",
                        "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", "washington D.C.", "West Virginia", "WIsconsin", "WYoming"
                    };
                var all = states.ToDictionary(st => string.Concat(st.Where(char.IsUpper)));

                var wanted = all.FirstOrDefault(pair => state.ToUpper().Equals(pair.Value.ToUpper()) || state.ToUpper().Equals(pair.Key));

                return wanted.Key ?? state;
            }

JavaScript (E6)

Hier ist der Großteil die Liste der Namen, wobei der camelCase- Trick verwendet wird, um ein wenig zu verkürzen. Golf, 617 Bytes.

F=i=>
  "AkAlAzArCaCoCtDeFlGaHiIdIlInIaKsKyLaMeMdMaMiMnMsMoMtNeNvNhNjNmNyNcNdOhOkOrPaRiScSdTnTxUtVtVaWaWvWiWyAlaskaAlabamaArizonaArkansasCaliforniaColoradoConnecticutDelawareFloridaGeorgiaHawaiiIdahoIllinoisIndianaIowaKansasKentuckyLouisianaMaineMarylandMassachusettsMichiganMinnesotaMississippiMissouriMontanaNebraskaNevadaNew hampshireNew jerseyNew mexicoNew yorkNorth carolinaNorth dakotaOhioOklahomaOregonPennsylvaniaRhode islandSouth carolinaSouth dakotaTennesseeTexasUtahVermontVirginiaWashingtonWest virginiaWisconsinWyoming"
  .match(/.[^A-Z]*/g).map((w,q)=>U(w,U(w)==U(i)?p=q%50:p),U=s=>s.toUpperCase(),p=-1)[p]||i

Python

Beschlossen, dies nur als Code-Golf-Herausforderung zu tun. Habe es mit Hilfe von daniero und hsl auf 906 713 694 Zeichen gebracht:

s='AK,AL,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,ALASKA,ALABAMA,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(",")
x=input().upper()
print(s[s.index(x)%50]if x in s else x)

Wenn jedoch Module zulässig sind (wie das us-Modul ), kann ich es auf 130 Zeichen reduzieren:

import us
i=raw_input()
x=us.states.lookup(i)
print x.abbr if x else i

Und wenn Sie den ursprünglichen Wert nicht zurückgeben müssten, wenn der Status nicht existiert, könnte ich ihn auf 50 Zeichen reduzieren:

import us
print us.states.lookup(raw_input()).abbr

Bash + Sed, 291 Bytes

Schamlose Umstellung von Danieros Ruby-Lösung auf sed:

echo $*|tr a-z A-Z|sed -e\
"/\(.\).* \(.\).*/b1;/^\([CDGHKLPV]\).*\(.\)$/b1;/^\(.\).*\([ZVX]\).*/b1;\
/^\([NFOUW]\)\(.\).*/b1;/^\(.\)\([DNR]\).*/b1;/^\(.\).*\([LN]\)[LN].*/b1;\
/^\(.\).*SS\([AO]\).*/b1;/^\(.\).*\([ED])\)$/b1;/^\(.\).*[SNW]\(.\).*/b1;\
/\(.\)\(.\).*/b1;:1 s//\1\2/"

Golfscript - 750 653

Der Großteil besteht aus den Statusnamen und Abkürzungen.

{.96>32*-}%.,2>{"ALABAMA,AL,ALASKA,AK,ARIZONA,AZ,ARKANSAS,AR,CALIFORNIA,CA,COLORADO,CO,CONNECTICUT,CT,DELAWARE,DE,FLORIDA,FL,GEORGIA,GA,HAWAII,HI,IDAHO,ID,ILLINOIS,IL,INDIANA,IN,IOWA,IA,KANSAS,KS,KENTUCKY,KY,LOUISIANA,LA,MAINE,ME,MARYLAND,MD,MASSACHUSETTS,MA,MICHIGAN,MI,MINNESOTA,MN,MISSISSIPPI,MS,MISSOURI,MO,MONTANA,MT,NEBRASKA,NE,NEVADA,NV,NEW HAMPSHIRE,NH,NEW JERSEY,NJ,NEW MEXICO,NM,NEW YORK,NY,NORTH CAROLINA,NC,NORTH DAKOTA,ND,OHIO,OH,OKLAHOMA,OK,OREGON,OR,PENNSYLVANIA,PA,RHODE ISLAND,RI,SOUTH CAROLINA,SC,SOUTH DAKOTA,SD,TENNESSEE,TN,TEXAS,TX,UTAH,UT,VERMONT,VT,VIRGINIA,VA,WASHINGTON,WA,WEST VIRGINIA,WV,WISCONSIN,WI,WYOMING,WY"","/.@?)=}{}if

Erläuterung:

{        }%                         Map this to every character in the input string:
 .96>32*-                             Subtract 32 from the ASCII value if it's from "a" onwards.
                                      This turns every lowercase letter into an uppercase letter.
           .,2>                     Check if the input length is greater than 2.
               {              }     If it is, they inputted the full name.
                "..."                 Our string is in the form "STATE NAME,STATE ABBREVIATION".
                     ","/             We split the string at every comma to turn it into an array.
                         .@?          Then we see where the input string is in the array...
                            )=        ...then we return the value right next to it.
                               {}   If not, they inputted the abbreviation.
                                      ...do nothing.
                                 if EndIf
                                    (implied) Print the abbreviation

PHP

Mein Versuch, der nicht so erfolgreich war, wie ich gehofft hatte, verwendet die Zeichenfolgenlänge und eine bestimmte Zeichenplatzierung, um die Abkürzung aus dem Statusnamen zu extrahieren. Wahrscheinlich ist eine bessere Sequenzierung der Namenseliminierung möglich.

function findAbb ($state) {
    $first = substr($state, 0, 1);
    $last = substr($state, -2,1);
    $state = strtolower($state);
    if (strlen($state) < 4) {
        return strtoupper($state);
    }
    if (strpos($state, ' ')) { //if it's a space, return the first letter of each word.
        $space_index = strpos($state, ' ');
        $state = explode(' ', $state);
        return strtoupper(substr($state[0], 0, 1) . substr($state[1], 0, 1));
    }
    if (startsWith($state, 'io')) { //iowa is annoying, get rid of it.
        return strtoupper($first . $last);
    }
    if (startsWith($state, 'w,i')) { //if it starts with a W, return the first 2.
        return strtoupper(substr($state, 0, 2));
    }
    if (strlen($state) < 7 && strpos($state, 'm')===false) { //matches texas, ohio, and utah.
        return strtoupper($first . substr($state, -4,1));
    }
    if (strlen($state) < 7 && substr($state, 0, 1) > 'j' && substr($state, 0, 1) < 'n') { //matches maine, kansas, and hawaii
        return strtoupper($first . $last);
    }
    if (startsWith($state, 'c,d,k,l,p,v,g,h')) { //some unique states
        return strtoupper($first . $last);
    }
    if (strpos($state, 'sk')) {
        return strtoupper ('ak');
    }
    if (startsWith($state, 'k,l', 1)) {
        return strtoupper(substr($state, 0, 2));
    }
    if (startsWith($state, 'n')) {
        return strtoupper($first . substr($state, 2, 1));
    }
    if (startsWith($state, 'n', 2) || startsWith($state, 'z', 3)) { //montana, tennessee, minnesota, and arizona
        return strtoupper($first . substr($state, 3, 1));
    }
    if (startsWith($state, 'm') && ($last == 's') || ($last == 'n')) {
        return strtoupper(substr($state, 0, 2));
    }
    if (strpos($state,'o')) {
        return strtoupper($first . 'o');
    }
    if (strpos($state,'y')) {
        return strtoupper($first . 'd');
    }
    if (strpos($state,'r')) {
        return strtoupper($first . 'r');
    }
    if (strpos($state,'ss')) {
        return strtoupper($first . 's');
    }

    return $state; //otherwise return the name of the state (it was mispelled).
}

function startsWith ($state, $letters, $index = 0) { //takes a comma separated array and finds contents.
    $letters = split(',',$letters);
    for ($q = 0; $q<count($letters); $q++) {
        if (strpos($state,$letters[$q]) === $index) {
            return true;
        }
    }
    return false;
}

Natürlich kann es Golf gespielt werden. Dies ist mein erster Golfversuch, daher sind Einsichten willkommen. (911)

function t($s){$s=u($s);$f=b($s,0,1);$l=b($s,-2,1);
if(strlen($s)<4)return $s;if(strpos($s,' '))$s=split(' ',$s);
return b($s[0],0,1).b($s[1],0,1);
if(w($s,'IO'))return $f.$l;
if(w($s,'W,I'))return b($s,0,2);
if(strlen($s)<7 && strpos($s,'M')===false)return $f.b($s,-4,1);
if(strlen($s)<7 && b($s,0,1)>'I' && b($s,0,1)<'N')return $f.$l;
if(w($s,'C,D,K,L,P,V,G,H'))return $f.$l;if(strpos($s, 'SK'))return 'AK';
if(w($s,'K,L',1))return b($s,0,2);if(w($s,'N'))return $f.b($s,2,1);
if(w($s,'N',2) || w($s,'Z',3))return $f.b($s,3,1);
if(w($s,'M') && ($l=='S') || ($l=='N'))return b($s,0,2);
if(strpos($s,'O'))return $f.'O';
if(strpos($s,'Y'))return $f.'D';if(strpos($s,'R'))return $f.'R';
if(strpos($s,'SS'))return $f.'S';return $s;}function w($s,$l,$i=0){$l=split(',',$l);
for($q=0;$q<count($l);$q++)if(strpos($s,$l[$q])===$i)return 1;return 0;}
function u($z){return strtoupper($z);}
function b($v,$x,$y){return substr($v,$x,$y);}

Javascript

Ich weiß, dass dies kein Code-Golf ist, aber ich möchte es trotzdem spielen. :) :)

var r=new XMLHttpRequest
r.open("GET","https://gist.githubusercontent.com/mshafrir/2646763/raw/f2a89b57193e71010386a73976df92d32221d7ba/states_hash.json",0)
r.send()
var o=r.responseText,m=prompt(),a=m
o=JSON.parse(o)
for(var i in o)if(o[i].toLowerCase()==m.toLowerCase())a=i
alert(a)

Yay für neue Dinge! (Stapelschnipsel)