Esistono 8 stati e territori australiani, ciascuno con un'abbreviazione di 2 o 3 lettere:

• ATTO: Territorio della capitale australiana
• NSW: Nuovo Galles del Sud
• NT: Territorio del Nord
• QLD: Queensland
• SA: Australia Meridionale
• TAS: Tasmania
• VIC: Victoria
• WA: Australia occidentale

Il tuo compito è quello di scrivere una funzione / programma che prenda un'abbreviazione di stato australiana valida in maiuscolo e restituisca il nome completo corretto (con distinzione tra maiuscole e minuscole come sopra).

Non sono ammessi spazi aggiuntivi, tranne una nuova riga finale in cui questo è un inevitabile effetto collaterale di ogni programma in quella lingua.

Per esempio:

f("TAS") => "Tasmania"

Si applicano le regole standard per il golf del codice (vince il codice più breve in byte!) E le scappatoie.

Retina , 135 121 byte

13 byte giocati a golf grazie a @Neil usando un'intelligente tattica di inserimento dello spazio, che ha ispirato un altro byte da giocare a golf

AS
asmania
^W
Western 
NT
NorthernT
T$
 Territory
A
Australia
aC
an Capital
IC
ictoria
LD
ueensland
SW
ew SWales
S
South 

Provalo online!

Nota gli spazi finali sulla quarta e ultima riga.

Gelatina , 56 byte

OS%15ị“ÞÑṿ“ıÐṁṾṗ“¡ʋẹḢ⁾ḅ“¢T¡ż¶““msẒw²ẉṪP“ØÑĊ“©$Ḅ3ẊḳƓ“ÇH°»

Un collegamento monadico che prende e restituisce elenchi di personaggi.

Vedi tutti i casi su Provalo online!

Nota: il riutilizzo delle parole "Australia" e "Territorio" non aiuta a ridurre il numero di byte.

Come?

Prendendo la somma degli ordinali delle otto abbreviazioni di stato modulo 15 si ottengono 8 valori univoci. Prendendo i risultati di questi modulo 9 si mantiene l'unicità.

OS%15ị“ ... » - Main link: list of characters a
O             - cast to ordinals
 S            - sum
  %15         - modulo 15
      “ ... » - list of compressed strings:
              -   "Victoria"
              -   "Western Australia"
              -   "Northern Territory"
              -   "South Australia"
              -   ""
              -   "Australian Capital Territory"
              -   "Tasmania"
              -   "New South Wales"
              -   "Queensland"
     ị        - index into (1-indexed and modular - hence the single empty entry)

Haskell, 193 192 byte

f"NSW"="New South Wales"
f"QLD"="Queensland"
f"ACT"=a++"n Capital"++t
f"VIC"="Victoria"
f"TAS"="Tasmania"
f"SA"="South "++a
f"NT"="Northern"++t
f"WA"="Western "++a
a="Australia"
t=" Territory"

Soluzione un po 'ingenua, ma volevo fare una sfida abbastanza semplice per il mio primo. Non sono nemmeno sicuro che in Haskell sia possibile migliorare.

Salvataggio di un byte spostando lo spazio in t

Mathematica, 177 byte

Soluzione ovvia: (199 byte)

<|"ACT"->"Australian Capital Territory","NSW"->"New South Wales","NT"->"Northern Territory","QLD"->"Queensland","SA"->"South Australia","TAS"->"Tasmania","VIC"->"Victoria","WA"->"Western Australia"|>

Soluzione migliorata: (182 byte, eseguibile solo sul mio computer Wolfram Mathematica 10.2)

{,"Northern Territory","Queensland",,,,,"Australian Capital Territory","New South Wales",,,"Tasmania",,,"Western Australia","Victoria",,,,,,,,,,,,"South Australia"}[[Hash@#~Mod~29]]&

Soluzione migliore:

{,"Northern Territory","Queensland",a="Australia",,,,a<>"n Capital Territory","New South Wales",,,"Tasmania",,,"Western "<>a,"Victoria",,,,,,,,,,,,"South "<>a}[[Hash@#~Mod~29]]&

Purtroppo la ripetizione " Territory"può salvare solo 0 byte.

Sembra che la funzione Hash predefinita di Mathematica cambi sopra le versioni. Ma l'aggiunta di un metodo allungherà il codice. L'uso della funzione Hash predefinita della sandbox Mathematica ora può ridurre il codice di circa 9 byte.

Mathematica (sandbox - ora - versione 11), 168 byte

{a="Australia","Western "<>a,,,,"South "<>a,,a<>"n Capital Territory",,,,"Tasmania","Northern Territory",,,,"New South Wales","Victoria","Queensland"}[[Hash@#~Mod~20]]&

Python, 181 byte

1 byte salvato grazie a @Jonathan Allan

lambda a,s='Australia',t=' Territory':[s+'n Capital'+t,'New South Wales','Northern'+t,'Queensland','South '+s,'Tasmania','Victoria','Western '+s]['ACNSNTQLSATAVIWA'.index(a[:2])//2]

Provalo online!

Sed, 167 157 byte

s/T$/ Territory/
s/N /Northern /
s/AS/asmania/
s/IC/ictoria/
s/LD/ueensland/
s/W$/Wales/
s/A/Australia/
s/C/n Capital/
s/NS/New S/
s/^W/Western /
s/S/South /

PHP, 148 143 byte

<?=strtr(["0n Capital 3",Victoria,Queensland,West20,10,Tasmania,North23,"New 1 Wales"][md5(hj.$argn)%8],[Australia,"South ","ern ",Territory]);

5 byte salvati grazie a Jörg Hülsermann .

C # , 289 byte

Dati

• Input String s L'abbreviazione dello stato.
• Output String Il nome dello stato espanso

golfed

(string s)=>{return new System.Collections.Generic.Dictionary<string,string>(){{"ACT","Australian Capital Territory"},{"NSW","New South Wales"},{"NT","Northern Territory"},{"QLD","Queensland"},{"SA","South Australia"},{"TAS","Tasmania"},{"VIC","Victoria"},{"WA","Western Australia"}}[s];};

Ungolfed

( string s ) => {
    return new System.Collections.Generic.Dictionary<string, string>() {
        { "ACT", "Australian Capital Territory" },
        { "NSW", "New South Wales" },
        { "QLD", "Queensland" },
        { "TAS", "Tasmania" },
        { "VIC", "Victoria" },
        { "NT", "Northern Territory" },
        { "SA", "South Australia" },
        { "WA", "Western Australia" }
    }[ s ];
};

Leggibile non golfato

// Takes a state name abbreviated 
( string s ) => {

    // Creates a dictionary with the state name abbreviated and the full state name and returns the one that match
    return new System.Collections.Generic.Dictionary<string, string>() {
        { "ACT", "Australian Capital Territory" },
        { "NSW", "New South Wales" },
        { "QLD", "Queensland" },
        { "TAS", "Tasmania" },
        { "VIC", "Victoria" },
        { "NT", "Northern Territory" },
        { "SA", "South Australia" },
        { "WA", "Western Australia" }
    }[ s ];
};

Codice completo

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = ( string s ) => {
             return new System.Collections.Generic.Dictionary<string, string>() {
                 { "ACT", "Australian Capital Territory" },
                 { "NSW", "New South Wales" },
                 { "QLD", "Queensland" },
                 { "TAS", "Tasmania" },
                 { "VIC", "Victoria" },
                 { "NT", "Northern Territory" },
                 { "SA", "South Australia" },
                 { "WA", "Western Australia" }
             }[ s ];
         };

         List<String>
             testCases = new List<String>() {
                 "ACT",
                 "NSW",
                 "QLD",
                 "TAS",
                 "VIC",
                 "NT",
                 "SA",
                 "WA",
             };

         foreach( String testCase in testCases ) {
             Console.WriteLine( $"Input: {testCase}\nOutput: {f( testCase )}\n");
         }

         Console.ReadLine();
      }
   }
}

Uscite

• v1.0 - 289 bytes- Soluzione iniziale.

Appunti

• Nessuna

Rexx (Regina) , 148 147 byte

a=Australia
t=Territory
s=South
ac=a'n' Capital t
ns=New s Wales
nt=Northern t
qs=Queensland
sa=s a
ta=Tasmania
vi=Victoria
wa=Western a
arg x 3
say value(x)

Provalo online!

JavaScript (ES6), 167 byte

s=>({A:`${A='Australia'}n Capital ${T='Territory'}`,N:s[2]?'New South Wales':'Northern '+T,T:'Tasmania',Q:'Queensland',S:'South '+A,V:'Victoria',W:'Western '+A}[s[0]])

f=
s=>({A:`${A='Australia'}n Capital ${T='Territory'}`,N:s[2]?'New South Wales':'Northern '+T,T:'Tasmania',Q:'Queensland',S:'South '+A,V:'Victoria',W:'Western '+A}[s[0]])

console.log('ACT NSW NT QLD SA TAS VIC WA'.split(' ').map(f))