Existem 8 estados e territórios australianos, cada um com uma abreviação de 2 ou 3 letras:

• ATO: Território da Capital Australiana
• NSW: Nova Gales do Sul
• NT: Território do Norte
• QLD: Queensland
• SA: Austrália do Sul
• TAS: Tasmânia
• VIC: Victoria
• WA: Austrália Ocidental

Sua tarefa é escrever uma função / programa que use uma abreviação válida do estado australiano em maiúscula e retorne o nome completo correto (diferenciando maiúsculas de minúsculas como acima).

Nenhum espaço em branco extra é permitido, além de uma única nova linha à direita, onde esse é um efeito colateral inevitável de todos os programas nesse idioma.

Por exemplo:

f("TAS") => "Tasmania"

Regras padrão de código de golfe (o código mais curto em bytes vence!) E brechas se aplicam.

Retina , 135 121 bytes

13 bytes de golfe graças ao @Neil usando táticas inteligentes de inserção de espaço, que inspiraram mais um byte sendo jogado no golfe

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

Experimente online!

Observe os espaços à direita na quarta e na última linha.

Geléia , 56 bytes

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

Um link monádico que recebe e retorna listas de caracteres.

Veja todos os casos em Experimente online!

Nota: Reutilizar as palavras "Austrália" e "Território" não ajuda a reduzir a contagem de bytes.

Como?

Tomando a soma dos ordinais das oito abreviações de estado, o módulo 15 fornece 8 valores únicos. Tomando os resultados desses módulos 9 mantém a singularidade.

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 bytes

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"

Solução um tanto ingênua, mas eu queria ir para um desafio bastante simples para o meu primeiro. Não tenho certeza se é melhor em Haskell.

Salvou um byte movendo o espaço para t

Mathematica, 177 bytes

Solução óbvia: (199 bytes)

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

Solução aprimorada: (182 bytes, executável apenas no meu computador Wolfram Mathematica 10.2)

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

Melhor solução:

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

Infelizmente, a repetição " Territory"pode salvar apenas 0 bytes.

Parece que a função Hash padrão do Mathematica muda com as versões. Mas adicionar um método tornará o código mais longo. Agora, o uso da função Hash padrão da caixa de areia do Mathematica pode reduzir o código em cerca de 9 bytes.

Mathematica (sandbox - agora - versão 11), 168 bytes

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

Python, 181 bytes

1 byte salvo graças 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]

Experimente online!

Sed, 167 157 bytes

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 bytes

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

Economizou 5 bytes graças a Jörg Hülsermann .

C # , 289 bytes

Dados

• Entrada String s A abreviação do estado.
• Saída String O nome do estado expandido

Golfe

(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 ];
};

Ungolfed legible

// 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 ];
};

Código 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();
      }
   }
}

Lançamentos

• v1.0 - 289 bytes- Solução inicial.

Notas

• Nenhum

Rexx (Regina) , 148 147 bytes

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)

Experimente online!

JavaScript (ES6), 167 bytes

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