Il y a 8 états et territoires australiens, chacun avec une abréviation de 2 ou 3 lettres:

• ACT: Territoire de la capitale australienne
• NSW: Nouvelle-Galles du Sud
• NT: Territoire du Nord
• QLD: Queensland
• SA: Australie du Sud
• TAS: Tasmanie
• VIC: Victoria
• WA: Australie occidentale

Votre tâche consiste à écrire une fonction / programme qui prend une abréviation d'état australienne valide en majuscules et renvoie le nom complet correct (sensible à la casse comme ci-dessus).

Aucun espace supplémentaire n'est autorisé, à l'exception d'une seule nouvelle ligne de fin où il s'agit d'un effet secondaire inévitable de chaque programme dans cette langue.

Par exemple:

f("TAS") => "Tasmania"

Les règles de code-golf standard (le code le plus court en octets gagne!) Et les échappatoires s'appliquent.

Rétine , 135 121 octets

13 octets de golf grâce à @Neil en utilisant des tactiques intelligentes d'insertion d'espace, qui ont inspiré un octet de plus à jouer au golf

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

Essayez-le en ligne!

Notez les espaces de fin sur la quatrième et la dernière ligne.

Gelée , 56 octets

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

Un lien monadique prenant et renvoyant des listes de personnages.

Voir tous les cas sur Essayez-le en ligne!

Remarque: La réutilisation des mots "Australie" et "Territoire" n'aide pas à réduire le nombre d'octets.

Comment?

La somme des ordinaux des huit abréviations d'état modulo 15 donne 8 valeurs uniques. Prendre les résultats de ces modules 9 conserve 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 octets

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"

Solution un peu naïve, mais je voulais opter pour un défi assez simple pour mon premier. Je ne sais même pas si mieux est possible à Haskell.

Enregistré un octet en déplaçant l'espace en t

Mathematica, 177 octets

Solution évidente: (199 octets)

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

Solution améliorée: (182 octets, exécutable uniquement sur mon ordinateur Wolfram Mathematica 10.2)

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

Meilleure solution:

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

Malheureusement, la répétition " Territory"ne peut enregistrer que 0 octet.

Il semble que la fonction de hachage par défaut de Mathematica change par rapport aux versions. Mais l'ajout d'une méthode allongera le code. L'utilisation de la fonction de hachage par défaut du bac à sable Mathematica peut désormais raccourcir le code d'environ 9 octets.

Mathematica (bac à sable - maintenant - version 11), 168 octets

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

Python, 181 octets

1 octet enregistré grâce à @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]

Essayez-le en ligne!

Sed, 167 157 octets

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 octets

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

5 octets enregistrés grâce à Jörg Hülsermann .

C # , 289 octets

Les données

• Entrée String s Abréviation de l'état.
• Sortie String Le nom de l'état développé

Golfé

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

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

Non lisible non lisible

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

Code complet

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

Communiqués

• v1.0 - 289 bytes- Solution initiale.

Remarques

• Aucun

Rexx (Regina) , 148 147 octets

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)

Essayez-le en ligne!

JavaScript (ES6), 167 octets

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