Cela semble presque trivial, mais après quelques efforts, je ne pouvais pas battre la solution littérale dans J, je pensais que cela pourrait constituer un défi décent (bien que, pour être clair, ce ne soit pas un défi spécifique à J).

Le titre dit tout. Vous devez simplement écrire un programme ou une fonction (sans arguments) qui retourne ou affiche:

N NE E SE S SW W NW

Vous pouvez utiliser des nouvelles lignes au lieu d'espaces.

Une fonction sans argument renvoyant un tableau de chaînes telles que

['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']

est également acceptable.

Les lettres peuvent être majuscules ou minuscules, mais ne peuvent pas être mélangées.

Toile , 12 octets

＞X½+Ｔ）ＡuS{⁹‟

Essayez-le ici!

La chaîne, simplement compressée.

bash (24 octets)

en utilisant une expansion

echo N {N,,S}E S {S,,N}W

est la même longueur que le codage dur

echo N NE E SE S SW W NW

cependant, cela devient plus intéressant lors de la sortie de plus de points de la boussole

echo N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW

expansion du corset

echo N {{N,,E}N,,{E,,S}S}E S {{S,,W}S,,{W,,N}N}W

sinon, si l'ordre peut être changé, (17 octets), le truc, c'est que sans guillemets, le paramètre empy string disparaît

echo {N,,S}{W,,E}

Croissant Mornington , 4395 3823 octets

Take Northern Line to Bank
Take District Line to Parsons Green
Take District Line to Paddington
Take Bakerloo Line to North Wembley
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Barbican
Take Circle Line to Bank
Take Circle Line to Aldgate
Take Circle Line to Embankment
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Bayswater
Take Circle Line to Hammersmith
Take Circle Line to Baker Street
Take Circle Line to Bank
Take Circle Line to Embankment
Take Northern Line to Stockwell
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Farringdon
Take Circle Line to Hammersmith
Take Circle Line to Blackfriars
Take Circle Line to Bank
Take Circle Line to Moorgate
Take Northern Line to Waterloo
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Westminster
Take Circle Line to Hammersmith
Take Circle Line to Tower Hill
Take Circle Line to Bank
Take Circle Line to Edgware Road
Take Circle Line to Liverpool Street
Take Central Line to Mile End
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Mile End
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Barbican
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bayswater
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Baker Street
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Farringdon
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Embankment
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Blackfriars
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Moorgate
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Westminster
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Tower Hill
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Aldgate
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Edgware Road
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Essayez-le en ligne!

Attendez-vous à ce que vous lisiez tout cela, laissez-moi vous donner un bref aperçu de mon approche. L'idée principale est de stocker 3 copies des personnages N, E, S, Wà différentes stations de la ligne Circle, via Bank - Hammersmith. Ces caractères sont construits à partir du début du nom d'une station à Charing Cross. Ensuite, construisez à   partir du milieu d'un nom de station bien choisi en utilisant Mile End et Charing Cross, et stockez-le à Bank pour qu'il puisse être collecté à Hammersmith dans la concaténation. Enfin, concaténez les caractères un à un à Paddington et recopiez-les à nouveau via Bank - Hammersmith s’ils doivent être réutilisés ultérieurement.

Je pense que la solution actuelle est assez proche de l’optimum avec cette stratégie, du moins en termes de nombre de stations visitées: à peine 2 fois, j’utilisais une station uniquement pour le transit:

1. se rendre à Seven Sisters (via la gare Victoria)
2. et pour revenir à Mornington Crescent (via Bank).

Toutes les autres visites de stations étaient, si je n’avais pas oublié une visite, soit en stockant / récupérant quelque chose d’utile, soit en utilisant (en partie) la capacité de la station.

En ce qui concerne les longueurs de ligne, j'ai essayé de choisir les noms les plus courts sur Circle Line, mais il peut y avoir une légère amélioration. Il est possible que stocker quelque chose sur District puisse supprimer quelques octets.

PHP , 19 octets

N NE E SE S SW W NW

Essayez-le en ligne!

Obtenir cela de la route. Quelqu'un le fera éventuellement.

brainfuck , 142 139 131 119 octets

++++++++++[>+++>+++++++>++++++++>+++++++++<<<<-]>>>--.<<++.>>.<-.<.>.<.>>+++++.<.<.>>.<<.>>.>---.<<<.>>>.<<<.>>-----.>.

Essayez-le en ligne!

Il suffit de répéter 10 fois la boucle pour remplir les cellules avec 30, 70, 80 et 90, puis d’avancer et d’avancer et d’ajuster les valeurs des cellules pour imprimer les caractères requis. Pas très différent de la norme "Hello world!".

Brain-Flak , 204 octets

((((((((((((((((()()()){}()){}){}())){}{}))<([([][]){}()]{})(([][]){}[])>)<([][]
()())>)[[]]()())<([]()()())>)<((([]())[][]){}[][()])>)<([][()()])>[[]()])<([][((
)()){}])>)((()()())){}{})<((()()()()()){})>)

Essayez-le en ligne!

MarioLANG , 249 221 octets

+
+
+
+
+
+
+
+
+  ((+++++++++)))<
+>==============="
)++++++++)+++((-[!)--.)++.(.---------.).(.).)++.((.).).(.).++++.(.).(.(+++++++++.))
=================#================================================================.

Essayez-le en ligne!

Deadfish ~ , 188 183 octets

-5 grâce au calmar

iiissdddc{ddddd}iiiicdddd{iiiii}c{d}ic{dddd}iiicddd{iiii}c{dddd}iiic{iiiii}ic{d}ddddc{dddd}iiic{iiiii}ic{ddddd}dci{iiiii}ciiiic{ddddd}dddddciiiii{iiiii}c{ddddd}dddddcdddd{iiiii}c{i}dc

Essayez-le en ligne!

Formule Excel, 59 57 octets

Les éléments suivants doivent être entrés sous forme de formule matricielle ( Ctrl+ Shift+ Enter):

=SUBSTITUTE(ADDRESS(1,{14,369,5,499,19,517,23,387},4),1,)

Après avoir entré la formule sous forme de formule matricielle, mettez-la en surbrillance dans la barre de formule et évaluez-la en utilisant F9le résultat obtenu, par exemple:

Avant:

Après:

Comment ça fonctionne

La ADDRESSfonction renvoie une chaîne représentant une référence basée sur deux paramètres, rowet col. Le troisième paramètre contrôle le type de référence renvoyé, une référence absolue ou relative. Par exemple, =ADDRESS(1,2,4)retourne "B1".

Nous pouvons fournir un tableau à ADDRESSet l'utiliser comme une formule de tableau pour renvoyer plusieurs résultats, par exemple des =ADDRESS(1,{1,2,3},4)retours "A1","B1","C1".

Par conséquent, dans ma réponse, le tableau fourni ne ADDRESSconcerne que les numéros de colonne relatifs aux points cardinaux requis, par exemple, la colonne 14 est la colonne N, la colonne 369 est la colonne NE.

Cependant, nous ne sommes pas fini ici puisque toutes les références retournées ont la ligne inclus, par exemple, N1, NE1. Par conséquent, nous utilisons simplement SUBSTITUTEpour supprimer le 1de toutes les références.

Triangularité , 71 octets

..... .....
...."W"....
..."W N"...
.." SW "+..
." SE S"++.
"N NE E"+  

Essayez-le en ligne!

Il y a deux espaces sur la dernière ligne pour atteindre le nombre d'octets requis par Triangularity.

Charbon de bois , 14 octets

”{⊟“�_Ｚn↖⦄ＲüΦ≦

Essayez-le en ligne! Link correspond à la version verbeuse du code ... qui est simplement la chaîne à imprimer, car l’auto-déverbosifiant s’occupe de la compression de la chaîne.

L'impression de la chaîne non compressée prend 19 octets, car Charcoal imprime littéralement l'ASCII imprimable. La meilleure réponse algorithmique que je puisse trouver prend malheureusement 20 octets:

Ｅ⁸ΦSNWE›³﹪⁻﹪⁺⁵×⁶μχι⁸

Essayez-le en ligne! Les sorties utilisant le format tableau (coûteraient deux octets pour joindre les éléments sur les espaces). Fonctionne en remarquant que les lettres de la chaîne ne SNWEsont utilisées que lorsque l'index externe actuel est égal à 1 ou est éloigné (modulo 8) dans un sens ou dans l'autre de l'élément correspondant de la liste d'index 4,0,6,2.

brainfuck , 117 octets

+++++[>++++++>+>+++>>++++>+++++<<<<<<-]>++[>++>++>+>++>++[<]>-]>>-.>.<.<.>>.<<.>>.>-.<<<.>>.>.<.>.>--.<<.>>.<<.<.>>>.

Essayez-le en ligne!

Ce code créera d’abord les caractères "EN SW" dans la mémoire, puis se déplacera dans les deux sens pour les imprimer. L'espace est au milieu, car c'est le plus souvent imprimé. N et S et W et E ne paraissent jamais ensemble, ils se trouvent donc de part et d'autre de la mémoire. Pour l'optimisation, certaines des diminutions finales se produisent pendant la phase de sortie.

Python 2 , 62 61 58 53 octets

i=8
while i:print'NESESWNW'[~i+(i==4):][:1+i%2],;i-=1

Essayez-le en ligne!

Pas génial, mais au moins pas une impression simple.

Gelée ,  16 à  15 octets

“¤œỵpq⁵’ṃ“NESW 

Un programme complet imprimant le texte

Essayez-le en ligne!

16 ...

“¥Þ¡¦¢¬£æ‘ṃ“¡ɱ⁻»

Un lien niladique qui donne une liste de listes de caractères (minuscules).

Essayez-le en ligne!

Alternative 15 comme niladic lien qui donne une liste de caractères (minuscules) (espaces): “¡XÇŀqỵÑ’ṃ“¡⁴ṁ».

Commodore BASIC (TheC64Mini, C64, C128, VIC-20 etc.) 28 octets BASK en mémoire utilisés

 0 PRINT"N NE E SE S SW W NW

Dans Commodore BASIC, vous n'avez pas besoin du guillemet de fermeture PRINTni des LETinstructions car l'interpréteur le ferme automatiquement, ce qui enregistre un jeton BASIC.

Alternativement, on peut simplement utiliser le mode direct comme suit:

Commodore BASIC 23 caractères PETSCII (+ RETURNà exécuter)

?"N NE E SE S SW W NW

Je ne suis pas sûr de savoir comment compter le nombre d'octets utilisés dans cette instance selon l'interpréteur ?et PRINTutiliser le même nombre d'octets, et aucun programme n'est stocké en mémoire.

Japt , 16 octets

Renvoie un tableau de chaînes en minuscules. La chaîne compressée était de 18 octets, mais en utilisant ale délimiteur à la place, puis le fractionnement s'est avéré plus court.

`nÂà!Z°°nw`qa 

Try it - footer formate la sortie.

Poisson-mort ~ , 138 octets

{{i}i}c{{d}}cs{i}c{d}ic{{d}}iisicsic{{d}}iisicisddddddc{d}ddddc{{d}}iisicisddddddc{{iiii}}sicisddddddciiiic{{d}d}icisddc{{d}d}ics{i}c{i}dc

Essayez-le en ligne!

Ainsi, la sortie en minuscule avec des nouvelles lignes est meilleure que la valeur par défaut (majuscule avec espaces).

Ce code a été généré par mon optimiseur, écrit en C ++ (merci à squid pour une autre idée d'optimisation!):

#include <iostream>
#include <string>
#include <queue>
#include <vector>


int eval(const std::string& actions, int result)
{
    int mult = 1;

    for (int i = 0; i < (int)actions.length(); ++i)
    {
        switch (actions[i])
        {
        case 's':
            result *= result;
            if (result == 256)
                result = 0;
            break;

        case '{':
            mult *= 10;
            break;

        case '}':
            mult /= 10;
            break;

        case 'd':
            if (result > 256 && result - mult <= 256)
                result = (result - mult) % 256;
            else
                result -= mult;
            break;

        case 'i':
            if (result < 256 && result + mult >= 256)
                result = (result + mult) % 256;
            else
                result += mult;
            break;
        }
    }

    return result;
}

struct worse
{
    bool operator()(const std::string& a1, const std::string& a2)
    {
        return a1.length() > a2.length();
    }
};

std::string BestStr(int accumulator, int target)
{
    std::priority_queue<std::string, std::vector<std::string>, worse> actions;
    actions.push(std::string(""));
    while (true)
    {
        std::string a = actions.top();
        int new_acc = eval(a, accumulator);
        if (new_acc == target)
            return a + "c";

        actions.pop();

        int last_braces = 0;
        int i = a.length() - 1;
        while (i >= 0 && a[i] == '}' && last_braces < 2)
        {
            ++last_braces;
            --i;
        }
        bool is_last_i = (i >= 0 && a[i] == 'i');
        bool is_last_d = (i >= 0 && a[i] == 'd');
        bool may_add_braces = (i < 0 || a[i] == 's');
        bool may_add_c = (new_acc > 1 && new_acc < 30);

        if (may_add_c)
        {
            actions.push(a + "s");
        }
        if (may_add_braces)
        {
            actions.push(a + "{{}}");
            actions.push(a + "{}");
        }
        for (int braces_back = 0; braces_back <= last_braces; ++braces_back)
        {
            for (int c = 'd'; c <= 'i'; c += 'i' - 'd')
            {
                if ((!is_last_i || c == 'i') &&
                    (!is_last_d || c == 'd') ||
                    braces_back == 0)
                {
                    std::string new_actions = a;
                    new_actions.insert(new_actions.length() - braces_back, 1, (char)c);
                    actions.push(new_actions);
                }
            }
        }
    }
}

std::string DeadfishConvert(std::string s)
{
    std::string result;
    int accumulator = 0;

    for (int c: s)
    {
        result += BestStr(accumulator, c);
        accumulator = c;
    }
    return result;
}

int main()
{
    std::string s1 = DeadfishConvert("N NE E SE S SW W NW");
    std::cout << s1 << '\n';
    std::cout << s1.length() << '\n' << '\n';
    std::string s2 = DeadfishConvert("n ne e se s sw w nw");
    std::cout << s2 << '\n';
    std::cout << s2.length() << '\n' << '\n';
    std::string s3 = DeadfishConvert("N\nNE\nE\nSE\nS\nSW\nW\nNW");
    std::cout << s3 << '\n';
    std::cout << s3.length() << '\n' << '\n';
    std::string s4 = DeadfishConvert("n\nne\ne\nse\ns\nsw\nw\nnw");
    std::cout << s4 << '\n';
    std::cout << s4.length() << '\n' << '\n';
}

Fichier de commandes, 19 octets

La question n'a jamais indiqué que vous deviez générer une sortie N NE E SE S SW W NWet rien d'autre, ni qu'il ne pouvait pas quitter en raison d'une erreur après cela. Ce code renvoie uniquement une erreur mais ne se ferme pas à cause de cela.

N NE E SE S SW W NW

Sortie

>N NE E SE S SW W NW
'N' is not recognized as an internal or external command,
operable program or batch file.

Fichier de commandes, 25 octets

Seulement la N NE E SE S SW W NWsortie sans erreur ou crash.

@echo N NE E SE S SW W NW

Python2, 59 octets

''.join(' SEWN'[0xe0619042210504>>i*3&7]for i in range(19))

Le nombre magique correspond aux index de trois bits joints dans la chaîne de caractères, en ordre inverse, afin que nous puissions commencer à effectuer une itération sur le LSB.

J'ai passé un certain temps à essayer de réduire le nombre magique, mais répéter la chaîne de caractères via multiply pour permettre l'indexation supplémentaire ne fonctionne pas car il faut coder pour l'espace. chaîne que les chiffres supprimés du nombre magique (y compris un couple de malheureux ne se soucie pas du milieu):

''.join('WN S ES W xxE '[0x423659711>>i*2&15]for i in range(19))

K (ngn / k) , 23 22 octets

-1 octet grâce à ngn!

"WNES"@5\7108085518230

Essayez-le en ligne!

J , 34 30 octets

echo(#:3510)<;.1'NNEESESSWWNW'

Essayez-le en ligne!

05AB1E , 14 octets

.•2Àβ‡yÞJŒ¾oÒ8

Essayez-le en ligne!

Ceci affiche la chaîne sauf en minuscule.

Brachylog , 19 octets

"NNEESESSWWNW"ḍ₄ḍᵐc

Essayez-le en ligne!

Sortie sous forme de liste. ḍ₄ḍᵐcenregistre deux octets sur l'écriture de sept espaces et fait du prédicat entier un littéral chaîne, donc au moins cela lie PHP ...

"NNEESESSWWNW"         The string "NNEESESSWWNW"
              ḍ₄       split into quarters
                 ᵐ     with each quarter
                ḍ      split in half
                  c    and concatenated
                       is the output.

J'ai essayé d'être intelligent avec 3⟦{;"NESW"↺₍h₂a₀ᶠ}ᵐc, mais cela ne pouvait pas obtenir SE ou NW, et c'est un octet plus long de toute façon.

Espaces blancs , 151 octets

[S S S T    T   N
_Push_3_W][S S T    T   T   S N
_Push_-6_N][S S T   T   T   S T S S N
_Push_-52_space][S S S T    T   N
_Push_3_W][S T  S S T   N
_Copy_0-based_1st_(space)][S S S T  T   N
_Push_3_W][S S T    T   N
_Push_-1_S][S T S S T   S N
_Copy_0-based_2nd_(space)][S S T    T   N
_Push_-1_S][S T S S T   N
_Copy_0-based_1st_(space)][S S T    T   T   T   T   N
_Push_-15_E][S S T  T   N
_Push_-1_S][S T S S T   S N
_Copy_0-based_2nd_(space)][S T  S S T   S N
_Copy_0-based_2nd_(E)][S T  S S T   N
_Copy_0-based_1st_(space)][S T  S S T   N
_Copy_0-based_1st_(E)][S S T    T   T   S N
_Push_-6_N][S T S S T   S N
_Copy_0-based_2nd_(space)][S S T    T   T   S N
_Push_-6_N][N
S S N
_Create_Label_LOOP][S S S T S T S T S S N
_Push_84][T S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Explication:

1. Poussez sur la pile les valeurs unicode moins la constante 84 pour les caractères "WN W WS" (notez que la chaîne est enfoncée dans le sens inverse). De plus, j'utilise quelques copies des valeurs précédemment envoyées pour économiser des octets, si possible.
2. Puis lancez une boucle infinie, qui effectue les opérations suivantes:
   1. Ajoutez la constante 84 à la valeur unicode actuelle
   2. Imprimez-le en tant que personnage sur STDOUT

La constante 84est générée par ce programme Java que j'ai écrit pour un autre défi auquel j'ai répondu dans Whitespace .

MathGolf , 20 17 octets

ÿnesw▒∙╫m+mÉîÄ╪^─

-3 octets grâce à @maxb .

Essayez-le en ligne.

Explication:

ÿnesw      # Push 4-char string "nesw"
           #  STACK: "nesw"
     ▒     # Split to a list of characters
           #  STACK: ["n","e","s","w"]
      ∙    # Triplicate it
           #  STACK: ["n","e","s","w"],["n","e","s","w"],["n","e","s","w"]
╫          # Rotate the top one once towards the left
           #  STACK: ["n","e","s","w"],["n","e","s","w"],["e","s","w","n"]
 m+        # Append the top two together
           #  STACK: ["n","e","s","w"],["en","se","ws","nw"]
   m       # Map the strings in the top list to:
    ÉîÄ╪   #  Rotate the string the 1-based index amount of times towards the right
           #   STACK: ["n","e","s","w"],["ne","se","sw","nw"]
^          # Zip; creating pairs with the top two lists
           #  STACK: [["n","ne"],["e","se"],["s","sw"],["w","nw"]]
 ─         # Flatten this list
           #  STACK: ["n","ne","e","se","s","sw","w","nw"]
           # (after which the entire stack is output implicitly as result)

CSS , 42 39 octets

(merci à un arachnide de pierre pour la version révisée)

body:after{content:"N NE E SE S SW W NW"

Graine , 6014 octets

27 32429737401852232227804295321578416370544555457622262891879921280324727410131817586348135470079420921373938348260737299348550007805068404867624897650263347568409592608258945989033792510474363164709158118555665232935403908551415888090695760298337219819413274977014408722140235669339108001709528995376914900494019798521214727367535169036319615676199584661126257462974800782884967804763256678000063025237472650538076831876942979826335539886276642624472204985016283691316313249488093825552581263195700506490263014623798470563718844847334940964632636436478404543496272112184140337568637349767918641524452384959486975049813859244670160569884744538279036643294867674161431756929550170395739925307134312406291063668809195567313928307910934660574895433141956111513050736041440669472422865481546405020220238818265794921314653725749392385549924210837964649297239381603259476675148489582680939048820717739905271461370132524025785160026801625672272913416389786086946626728842588663673416395169524016926695769334183833366462685756958054189820999370092892855665559717806826530952610964256124463840218293029538229042911551526509745973128558291005365222643503139067010483637086697955919587162384655443959408291567894061028044826636171014388153130769792397282335858985323269310727311039012381122390183102126191168963870116881629339035600546009305431793687183913979054151312200573069395058914262857368132993952655571167118263728070696377852599343989848263167312887211748226689125561718255196655446099711296568221690530717651328503948183228932786503716890383195810396161663632504174142420921735055441162618914957825032056019218584287089599270312541933094119409995775035365862244691419255488688879630142415739738796957474249592086989231999568273454247198389863139439897248192949030226324637037937607004428557202644332945222019553599908855943840883606735602486216245714280716148378430738983808375466562604692991701163078094015860708365913183037140180020776525026891135163345427911749533164462233906885068864798951466382247930357444595606617682531499045805835102155190109668901179666311163071611393282924908189215675892953256826649762594463293867383921972181952997833560371571545190945543033351108064265894854803319008655145213765667074789305055723258530694850418765677462165413557272747961130459219342146615095862014137406489375157766959799291089215740196734079295172946350338663239451562589633216908805028629767462044463310475859283605554743731396818983359527612902567406307270838160926586311672252276690909354125055468912844343806046309796590149977323343332039095076680537362333773750051043281967620781236684580688649899599894791764969639275247700776637892615729757899608628514791667795106390376246890330575517824338764219021396958188958235055290896924249770944905659304681507478975095888248103169710912376599445302527257479613158446721050489233911736089191439017996962182413511012900366501119556105789078275149705515012300827868862038071066912823449506913958912235923323638505757204526506327010926007595704417253684932596231606733027284263178479840785607928320603259662026791082244015829365605451084366715394628351636563955621161378688550003390556445245074739462307110100863024184316465734324401688465928827408449165190271528329602702373730346394803239394173490819727873116531045433457650881080122796159241596543253982402471104065237941729677594379317274541529006952959000152687275974001138315010176843925599438278290218390644740919129323109582279220437886915496736885058271413958305953151184342725824729076581370881383360210631877985352671536000503948280559301633936877162466145026758809907939645467704805892486147550057845773849575278620555906080753862688722846292689494961297512113753414009189522365247542490200336579292488067953461299023326925661887077747288500270026888774635820948696015812357241781814592351848858954139716506111479475207696790949277211077720834891880913260866501916732427370806066035548982017315826213049658915419681842381914237502216614528174237875875738156132703973666564945026254499265910704148825037630761619650949635972980035630316257135212349181639940504547722767898302879234673272154028964478458469466250102554612059368293497511404163963705442187242769706586819405113285219700159125119338601931670779192478917206878107091618448093140705173062420040261126935373689918208815797991761563304607704283868972915636425613833785564679990574095368828308776724486415005128506687942819070129022911666887363253202695416103545769073021185132010920185208632024811337544715055406031297413168802089421761798020616230024290524096396092608042069087607272534874457093977610919233750725135220581682913316085638068663247820037223692942067994551786014033707387642820855601334002540339334606906772532939337779748305357112540312103757754695577077583846897693527091162962000082213332051059005644562753372638247584982354478224403477604356150912451128591138652721098074872513196253790561736352841309810909110001754673250730698454675988798465247376421075019414107337634079281061629221783859449063069175434073835673063716565555614782886016441814199915418848976070834414782427725187820926042778984081922550398210353288229598805397201850487997254871012213762289412828417039945896819359898337616122446201299182152276549340911589671291124887672310931868023491872685227548726494469798568145715500153324646857181224645073236602344526749192704938665584870007079941922775292601106345725659322322536675461008337648982039319953181733660980694781559207671567197161027796266390879206526082137700937056380629087949633487181507979286568656291044492869916694352395542638882544967807857391058161838343109606346401310155771709714142586733985703451391374159045025205718989407293651441039802247981386993858491342422355232055341447145969376687615001834650283116652856369804298047720786536278306210551862061566639283704928517998916884505819581251906693306116531467413995747910736025576089721150597919824878333808115757216261812226145636769545796913912159437533454858286778214791559458862216426856243544801486923659355580455048265633089421966932180992

Génère le programme befunge suivant:

"WN W WS S ES E EN N">:#,_@

Hodor , 177 octets

hodor.hod("HoOodoOorhodor  HoOodoOorhodor HooodorrHodor  HooodorrHodor  HODOR?!? HooodorrHodor  HODOR?!?  HODOR?!? Hooodorrhodor  Hooodorrhodor  HoOodoOorhodor Hooodorrhodor ");

Essayez-le en ligne!

Assembly (x86, Linux), 68 octets

$ od -x a
0000000 457f 464c 0001 0000 0000 0000 0000 0500
0000020 0002 0003 001b 0500 001b 0500 0004 0000
0000040 13b2 31b9 0000 cd05 2580 0020 0001 cd40
0000060 4e80 4e20 2045 2045 4553 5320 5320 2057
0000100 2057 574e
0000104
$ ./a
N NE E SE S SW W NW$

La source:

BITS 32
org 0x05000000
db 127,"ELF"
dd 1,0
dd $$
dw 2,3
dd 0x0500001B,0x0500001B
dd 4
mov dl,19
mov ecx,m
int 128
db 37
dw 32,1
inc eax
int 0x80
m db 'N NE E SE S SW W NW'

Code provenant principalement de Shortest ELF pour "Hello world \ n"?

Gelée , 16 octets

“æṖØq’ḃ⁴ḃ4ị“NESW

Essayez-le en ligne!

Avec pied de page à imprimer séparé par espace

Un lien niladique qui renvoie une liste de chaînes. 2 octets plus courts (et sans doute plus intéressants) que la chaîne compressée en Jelly.

C # (compilateur interactif Visual C #) , 24 octets

_=>"N NE E SE S SW W NW"

Essayez-le en ligne!