Hay 8 estados y territorios australianos, cada uno con una abreviatura de 2 o 3 letras:

• ACT: Territorio de la Capital Australiana
• Nueva Gales del Sur: Nueva Gales del Sur
• NT: Territorio del Norte
• QLD: Queensland
• SA: Australia del Sur
• TAS: Tasmania
• VIC: Victoria
• WA: Australia occidental

Su tarea es escribir una función / programa que tome una abreviatura válida del estado australiano en mayúsculas y devuelva el nombre completo correcto (distingue entre mayúsculas y minúsculas como se indicó anteriormente).

No se permiten espacios en blanco adicionales, aparte de una nueva línea final donde este es un efecto secundario inevitable de cada programa en ese idioma.

Por ejemplo:

f("TAS") => "Tasmania"

Se aplican las reglas estándar de código de golf (¡el código más corto en bytes gana!) Y las lagunas.

Retina , 135 121 bytes

13 bytes de golf gracias a @Neil mediante el uso de tácticas inteligentes de inserción en el espacio, que inspiraron un byte más de golf

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

Pruébalo en línea!

Tenga en cuenta los espacios finales en la cuarta y última línea.

Jalea , 56 bytes

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

Un enlace monádico que toma y devuelve listas de personajes.

¡Vea todos los casos en Pruébelo en línea!

Nota: Reutilizar las palabras "Australia" y "Territorio" no ayuda a reducir el recuento de bytes.

¿Cómo?

Tomando la suma de los ordinales de las ocho abreviaturas de estado, el módulo 15 da 8 valores únicos. Tomar los resultados de esos módulos 9 mantiene la unicidad.

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"

Una solución algo ingenua, pero quería ir por un desafío bastante simple para mi primero. Ni siquiera estoy seguro de si es mejor en Haskell.

Salvó un byte moviendo el espacio a t

Mathematica, 177 bytes

Solución obvia: (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"|>

Solución mejorada: (182 bytes, solo ejecutable en mi computadora Wolfram Mathematica 10.2)

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

Mejor solución:

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

Lamentablemente, la repetición " Territory"solo puede guardar 0 bytes.

Parece que la función Hash predeterminada de Mathematica cambia sobre las versiones. Pero agregar un método hará que el código sea más largo. El uso de la función Hash predeterminada de la caja de arena de Mathematica ahora puede acortar el código en aproximadamente 9 bytes.

Mathematica (sandbox - ahora - versión 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 guardado gracias 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]

Pruébalo en línea!

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

Guardado 5 bytes gracias a Jörg Hülsermann .

C # , 289 bytes

Datos

• Entrada String s La abreviatura del estado.
• Salida String El nombre del estado expandido

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

Sin golf

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

Legible sin golf

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

Lanzamientos

• v1.0 - 289 bytes- Solución inicial.

Notas

• Ninguna

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)

Pruébalo en línea!

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