text:
That's not my X, its Y is too Z
This challenge is inspired by a series of young children's books by Fiona Watt and Rachel Wells, which I've recently been enjoying with my daughter.
In each book a mouse (illustrated, but not part of the text) complains that a succession of 5 things of the same type are not its thing. It then backs this up by declaring that some component of the thing doesn't have the property it expects.
On the sixth time of asking, the mouse finds its thing and is pleased because it has the expected property.
Here is the text of a typical example:
That's not my bunny, its tail is too fluffy.
That's not my bunny, its paws are too rough.
That's not my bunny, its tail is too woolly.
That's not my bunny, its eyes are too shiny.
That's not my bunny, its nose is too wrinkled.
That's my bunny! Its ears are so soft.

Now, most programming folk would realise that this is a very algorithmic method of producing some text. Because it's such a clear process, we should be able to reproduce this by writing some code.
Let's start with three collections of words:
things = ["dinosaur", "lamb", "princess", "reindeer", "train"]
parts = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
properties = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

First, we decide which kind of thing we will be describing.
Then 5 times, we will generate the line "That's not my [thing], its [part] is too [property].
Finally, we generate the line "That's my [thing]! Its [part] is so [property]!

The challenge

Generate the text of a "That's not my..." story.
It must not consistently reproduce the same text.
It's code golf, so attempt to do so in the smallest number of bytes.
Use any language you please.
White space doesn't matter, but there must be a newline character between lines.
The lists of source words are not part of your answer (in TIO they can be added to the header).
You can rename the lists of source words.
Output can be output to a terminal or text generated into an object.
Please include a link to an online interpreter.
Ignore plurals, "its horns is" is fine.
It doesn't need to make sense. If your princess's funnel is too fluffy, just say so.

Sample output:
That's not my train, its engine is too rusty.
That's not my train, its hooves is too thick.
That's not my train, its sash is too fuzzy.
That's not my train, its tail is too velvety.
That's not my train, its horns is too glittery.
That's my train! Its hooves is so hairy.

Happy golfing!

In your first example, you differentiate between singular and plural nouns but later on you say we shouldn't - which is it?

@Shaggy The first example is the actual text of one of the books. It’s not a valid answer for this challenge. I’ve said to ignore plurals to simplify the challenge a little. That example is basically background information.

Related

You state "It doesn't need to make sense.", does that extend to near-contractions? (i.e. is "That's not my bunny, its eyes are too shiny. ... That's my bunny! Its eyes are so shiny." acceptable as a possible output?) - I'd guess so, just thought I'd check.

May we assume the input will always have more than 6 parts*properties?

@JonathanAllan you can. We’ll only check against the list I’ve given.

Aren't "It must not consistently reproduce the same text" and [tag:kolmogorov-complexity] kind of incompatible?

"That's not my bunny, its eyes are too shiny" soon became "That's not my bunny, its eyes are too dead".  That bunny isn't cute but sinister. Once seen...

Are there restrictions on the parts and properties repeating? Can you, for instance, always repeat the same part and property six times, while still making it non-deterministic?

@negativeseven I’d say that’s too consistent.

@JonathanAllan from a logic standpoint, I'd say it's possible for there to be a bunny whose eyes are too shiny to be your bunny, even if your bunny's eyes are also very shiny.

@ChrisH many rodents get cataracts later in life, their eyes turn cloudy and they go blind, but they can live a long time after that.

@AJFaraday this one's clearly a zombie bunny. (BTW rabbits are lagomorphs, not rodents - but close enough that your comment is probably still correct)

@ChrisH That's my taxonomical mistake. Although both are classed as Glires, so that's something I've learned today.

@JosephSible I've perhaps misunderstood the term, I'll drop the tag.

Is there any reason you're overriding the site defaults and allowing input via pre-defined variables? It makes a lot of answers stray too close to being snippets, rather than programs or functions

@JoKing I wasn’t aware I wasn’t supposed to. I guess I’m just less interested in how the lists are defined, or in fact what they are. I want the code to work, and I’d be happy for the lists to change.

Is there a graphic design golf site? I'd love to see some people draw some of these. People could use this sort of thing as fictional creature creation ideas. I just had a reindeer with woolly sides, sparkly spots, bumpy wheels, silky spines, velvety bells, and a shiny nose.

05AB1E, 63 bytes
ΩU6F€Ω`XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

Try it online.
68 bytes version which doesn't output duplicated parts nor properties:
ΩUε.r6£}øεXª`N5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

Try it online.
Both programs assumes the list of things is the first input, and a list containing the list of parts and list of properties is the second input.
Explanation:
Ω            # Pop and push a random element of the things-list
 U           # Pop and store it in variable `X`
  6F         # Loop 6 times:
    €Ω       #  Get a random element from both the parts and properties list
      `      #  Push them to the stack
       X     #  And also push variable `X`
             #  (the order on the stack is now: property, part, thing)
    N5Qi     #  If it's the last iteration:
        “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“
            '#   Push dictionary string "that's my ÿ! its ÿ is so ÿ."
       ë     #  Else:
        “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“
            '#   Push dictionary string "that's not my ÿ, its ÿ is too ÿ."
             #  (where the `ÿ` are automatically replaced with the words on the stack)
       }.ª   #  After the if-else: sentence-capitalize the strings
             #  (so the "That's " as well as the "! Its")
          ,  #  And output it with trailing newline

ΩU           # Pop and store a random thing in variable `X`
  ε          # Map the list of lists of parts/properties to:
   .r        #  Shuffle the list
     6£      #  And leave the first six elements
  }ø         # After the map: zip/transpose to create pairs of part & property
    ε        # Foreach over the pairs:
     `XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,
             #  And the rest of the code is the same as above

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ is "that's my ÿ! its ÿ is so ÿ." and “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“ is "that's not my ÿ, its ÿ is too ÿ.".

Python 3, 149 bytes
lambda a,*l:shuffle(a)or["That's "+s%(a[0],*map(choice,l))for s in["not my %s, its %s is too %s."]*5+["my %s! Its %s is so %s."]]
from random import*

Try it online!
-9 bytes thanks to movatica

Nice work! Shorter tuple syntax: 149 bytes

@movatica Ooh, nice. Thanks!

"That's not my reindeer, its ears is too bumpy." - needs something to switch between is/are.

@JohnHunt the rules say to ignore plurals.

My mistake. This is v.impressive

Charcoal, 72 bytes
≔‽θθＦ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»That's my θ! Its ‽η is so ‽ζ.

Try it online! Link is to verbose version of code. Expects the arrays of things, parts and properties to be in the variables θ, η and ζ, which is most easily arranged by providing them in the input rather than the header. Explanation:
≔‽θθ

Pick a random thing.
Ｆ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»

Print five negative sentences.
That's my θ! Its ‽η is so ‽ζ.

Print the positive sentence.

Japt v2.0a0 -R, 73 bytes
ö
6Æ`Tt's {`not `pT=Y<5}my {+`!,`gT} {73dT*H}ts {Vö}  {`tÑ?`ë2!T} {Wö}.

Takes the three lists as U, V, and W. Those are the default input variables anyways, so just put the three lists in the input section.
Try it
ö                         Saves the random object in variable U
6Æ                        Range [0..6), and map each to the following string
`That's                   The string "That's " plus
{`not `pT=Y<5}            "not " if the index is less than 5 (and store that in variable T), else ""
my                        Literal "my " plus
{+`!,`gT}                 U plus ',' if T, else '!'
{73dT*H}ts                "its " if T, else "Its "
{Vö}                      Random item from V
is
{`tsooo`ë2!T}             "too" if T, else "so"
{Wö}.                     Random item from V, plus a period

Very nice trick with "too/so" :)

PowerShell, 147 bytes
This main program will not repeat any part or property in a run, and has reasonable randomization.

$t=$l|Random
$a=$a|Random -c 6
$r=$r|Random -c 6
0..4|%{"That's not my $t, its $($a[$_]) is too "+$r[$_]}
"That's my $t! Its $($a[5]) is so "+$r[5]

Try it online!
Writing get-random so many times costs so many characters! However, unless you are willing to let parts and properties be repeated, I can't see a way to shrink this in powershell any further. Unless you move the first 3 line pipes to the end of the 3 assignment lines in the header. To have something like
# Header
$l = ("dinosaur", "lamb", "princess", "reindeer", "train")|Get-Random
$a = ("back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows")|sort{Get-Random}
$r = ("bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly")|sort{Get-Random}

# Main
(1..5)|%{echo("That's not my $t, its "+$a[$_]+" is too "+$r[$_])}
"That's my $t! Its "+$a[6]+" is so "+$r[6]

But that seems like it's cheating, and still doesn't beat Neil's answer.
Edit: Thanks for the tips Matt, and thanks AdmBorkBork for fleshing them out, removing the 3 sets of get- text reduced it to 159 bytes, then some more golf from Adm got it down to 147. The code I was thinking of which allowed duplicates and contradictory statements was 144 characters after applying the same golf tips.
function n{(random 18)+1}
$t=$l[(n)%5]
0..4|%{"That's not my $t, its $($a[(n)]) is too "+$r[(n)]}
"That's my $t! Its $($a[$(n)]) is so "+$r[(n)]

Try it online!
However, it not only has a tendency to say the same thing multiple times, but it pretty much requires that your inputs be the same number of elements. I believe the pseudo random number generator being used is heavily dependent on the clock, and quick repeated calls to it can often result in the same result. Then it has the condition that it only uses the whole list if all lists are the same length.With only saving 3~5 characters and having so many caveats, I prefer the code at the start of this post.

Welcome to PPCG! Parts and properties can be repeated so that should save you some bytes.

You can drop the Get- from Get-Random. Its the default verb tested when evaluating commands.

Welcome! Some easy golfs gets you down to 147 bytes

Jelly, 72 bytes
XWWẋ6;X€}⁶pʋ€s5“ʠĖµʋb⁵J¥\¢wBD®-Ƥd(CḤ!²kT“Ø!1ẆÑ⁹ṁṾƤṛḄėÄṂMƓṾṖ¿O*½»Ỵ€¤żⱮ"ẎY

Try it online!

C#, 204 203 bytes
()=>{int a(int x)=>new Random().Next(x);var j=t[a(5)];string s()=>$"That's not my {j}, its {p[a(25)]} is too {o[a(19)]}.\n";return s()+s()+s()+s()+s()+$"That's my {j}! Its {p[a(25)]} is so {o[a(19)]}.";};

It is my first answer on this site, so I hope it works well. It also needs those three things, but according to question those do not count:
   var t = new[] { "dinosaur", "lamb", "princess", "reindeer", "train" };
   var p = new[] {"back", "bells", "body", "bows", "crown", "dress", "ears",
          "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
          "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
          "tiara", "wheels", "windows" };
   var o = new[] {"bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
          "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
          "soft", "sparkly", "squashy", "thick", "velvety", "woolly"};

Try it online!
One less byte thanks to Sok.

Welcome to PPCG! I've taken the liberty of editing in a link to TIO into your answer, so that others can easily try your code for themselves - I would have given you the link to it in this comment, but the URI was too long unfortunately! I hope you enjoy your stay :o)

One small golf for you as well - the \r isn't required, which will save you 2 bytes.

JavaScript, 129
(a,b,c)=>(z='',a.forEach((f,i)=>z+=`That's ${q=i!=5?"not ":""}my ${f}${q?", i":"! I"}ts ${b[i]} is ${q?"to":"s"}o ${c[i]}.\n`),z)

input is three arrays, returns string

Ruby, 128 bytes
->a,*l{t=a.sample;6.times{|i|puts"That's#{' not'if i<5} my #{t}#{i<5?', i':'! I'}ts %s is #{i<5?'to':?s}o %s."%l.map(&:sample)}}

Try it online!

Batch File, 434 424 + 7 bytes
Executed via cmd/q/c.
Code not counted
set a=dinosaur lamb princess reindeer train
set b=back bells body bows crown dress ears engine fan flippers funnel hoobes horns neck nose roof sash side spines spots tail teeth tiara wheels windows
set c=bumpy fluffy furry fizzy glittery glossy hair red rough rusty shiny silky slippery soft sparkly squashy thick velvety woolly

Code counted
set q=random
set m=set/ar=1+%%%q%%%%%%%
call %m%5
for /f "tokens=%r%" %%x in ("%a%")do set x=%%x
:a
set/ad+=1
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.
if %d% neq 5 goto a
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's my %x%! Its %y% is so %%z.

I'll go through some challenges you must face and explain/justify what I did so others can improve.
Choose a random element from an array
 I did this by generating a random number between 1 and n where n is the amount of elements in that array. I then used this random number as the token to grab in each for loop (tokens=%r%). Because I did it this way, I could not nest these for loops anymore, as tokens=!r! was not working for me (with delayed expansion). This would've saved quite a few bytes as it would've removed the need to save the tokens as variables (set x=%%x).
Random number generation
m is my random number generation macro. Doing it this way saves 32 bytes over doing it like set/ar=%random%%%n+1 every line. You could semi-cheat and decide that tokens y and z are to be the same element:
call %m%19
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.

This would, while still retaining some randomness, exclude the final 6 elements of c. This would save a minimum of 20 bytes, but I don't think this is true to the op's requirements.
Theoretical Improvements
I spent quite a while trying to make this "pseudo-code" work, while still saving bytes:
set 1-5=echo That's not my %x%, its %y% is too %%z.
set 6=echo That's my %x%! Its %y% is so %%z.
...
set/ad+=1
for /f "tokens=%r%" %%z in ("%c%")do call %%d%%

Unfortunately the setup for this is proving to take up way too many bytes to be profitable (have to implement in < 144 bytes) but I can't shake the feeling that adding the last 4 lines of code are superfluous and janky.

You're not allowed to take inputs via pre-defined variables. You'll have to take it in as actual input through any of the standard IO methods

@JoKing From the challenge: The lists of source words are not part of your answer (in TIO they can be added to the header).

I'm unsure if it is allowed or not as I have seen it done both ways in other answers, but for those of you curious it would add 29 bytes to my answer in the form of set a=%~1, etc.

Pyth, 88 78 76 bytes
JONj_ms.ic"That's
 my

ts
 is
o
."b[?d" not"kJ?d", i""! I"OG?d\s"to"OH)6

Try it online!
The code presented above requires the following header:
=N["dinosaur""lamb""princess""reindeer""train")=G["back""bells""body""bows""crown""dress""ears""engine""fan""flippers""funnel""hooves""horns""neck""nose""roof""sash""side""spines""spots""tail""teeth""tiara""wheels""windows")=H["bumpy""fluffy""furry""fuzzy""glittery""glossy""hairy""red""rough""rusty""shiny""silky""slippery""soft""sparkly""squashy""thick""velvety""woolly")

There's a small issue with using the 'Header' feature in TIO with Pyth, as it looks like TIO joins the code blocks on newlines, and newlines are significant in Pyth. Here is a link to the same code using the 'Header' block, with a junk line in the output.
JONj_ms.ic"That's¶ my ¶¶ts ¶ is ¶o ¶."b[?d" not"kJ?d", i""! I"OG?d"to"\sOH)6   Newlines replaced with ¶
                                                                               Implicit: k="", b=newline
                                                                               From header: N=things, G=parts, H=properties
JON                                                                            Choose a random element from N, store in J
     m                                                                     6   Map [0-6), as d, using:
                                        ?d" not"k                                If d is truthy (i.e. not 0), yield " not", else ""
                                                 J                               J (the chosen thing)
                                                  ?d", i""! I"                   ", i" if d else "! I"
                                                              OG                 Random element from G
                                                                ?d"to"\s         "to" if d else "s"
                                                                        OH       Random element from H
                                       [                                  )      Wrap the previous 6 results in an array
         c"That's¶ my ¶¶ts ¶ is ¶o ¶."b                                          Split the template string on newlines
       .i                                                                        Interleave the template string elements with the previous list
      s                                                                          Concatenate
    _                                                                          Reverse lines
   j                                                                           Join on newlines, implicit print

Edit: Rewrite to golf 10 bytes, previous version: J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH

APL (Dyalog Unicode), 117 bytesSBCS
↑('That''s not my ',(t←T⊃⍨?5),', its ')∘,¨P[5?25],¨' is too '∘,¨V[5?19]
'That''s my ',t,'! Its',P[?25],'is so',V[?19]

Try it online!
?N generates a random index among the first N indices.
M?N generates M random indices (without replacement) among the first N indices.
, is concatenation
t←T⊃⍨… picks a random thing and calls it t for reuse in the last line.
∘,¨ concatenates the string on the left to each string on the right.
,¨ concatenates each string on the left to each string on the right.
↑ changes the list of strings into a character matrix so it prints right.

JavaScript ES6, 149 (+15?) bytes

a = ["dinosaur", "lamb", "princess", "reindeer", "train"]
b = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
c = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

// r=x=>x[parseInt(Math.random()*x.length)] 164 for better random on fast pc

r=x=>x[new Date%x.length]
s=r(a)
g=j=>console.log(`That's ${j?`not my ${s}, its ${r(b)} is to`:`my ${s}! Its ${r(b)} is s`}o ${r(c)}.`)
a.map(g)
g()

Welcome to Code Golf! Good work!

Thank's AJ! Appreciate the welcome :)

Perl 5.10, 127 bytes
Run with perl -M5.010 -f filename.pl.
my @t = qw(dinosaur lamb princess reindeer train);
my @r = qw(back bells body bows crown dress ears engine fan flippers funnel
           hooves horns neck nose roof sash side spines spots tail teeth tiara
           wheels windows);
my @p = qw(bumpy fluffy furry fuzzy glittery glossy hairy red rough rusty shiny
           silky slippery soft sparkly squashy thick velvety woolly);

sub r{rand@_}$a=" my $t[r@t]";say"That's not$a, its $r[r@r] is too $p[r@p]."for(1..5);say"That's$a! Its $r[r@r] is so $p[r@p]."

ink, 119 bytes
~a=LIST_RANDOM(a)
-(l)That's{l<6: not} my {a}{l<6:, i|! I}ts {LIST_RANDOM(b)} is {l<6:to|s}o {LIST_RANDOM(c)}
{l<6:->l}

With the lists defined as
LIST a=(dinosaur),(lamb),(princess),(reindeer),(train)
LIST b=(back),(bells),(body),(bows),(crown),(dress),(ears),(engine),(fan),(flippers),(funnel),(hooves),(horns),(neck),(nose),(roof),(sash),(side),(spines),(spots),(tail),(teeth),(tiara),(wheels),(windows)
LIST c=(bumpy),(fluffy),(furry),(fuzzy),(glittery),(glossy),(hairy),(red),(rough),(rusty),(shiny),(silky),(slippery),(soft),(sparkly),(squashy),(thick),(velvety),(woolly)

Try it online!

Though depending on what counts as a list, there are other approaches. If a list can be a function that randomly returns a list item, the following approach is only 91 bytes:
~temp t=u()
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {p()} is {l<6:to|s}o {q()}
{l<6:->l}

(with the "lists" defined as follows)
==function u
~return "{~dinosaur|lamb|princess|reindeer|train}"
==function p
~return "{~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows}"
==function q
~return " {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}."

Try it online!

There's also the following approach.
~temp t="{~dinosaur|lamb|princess|reindeer|train}"
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows} is {l<6:to|s}o {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}
{l<6:->l}

Try it online!
This solution is 389 bytes, but if the shuffle literals (which in this scenario can't really be moved) count as list definitions and can be excluded from the byte count, this drops to 80 bytes.

Bash +awk, 209 bytes
T=$(shuf $1|head -1)
join <(sed "s/.*/$T\t&/" $2) <(sed "s/.*/$T\t&/" $3)|shuf|awk 'NR<6{printf "That'\''s not my %s, its %s is too %s.\n",$1,$2,$3}NR==6{printf "That'\''s my %s! Its %s is so %s.\n",$1,$2,$3}'

Try it online!
Accepts inputs as things parts properties where each is a file with one item per line of the desired type.
This is a file-centered approach. May try an array-centered approach later to see if it can be improved.

Python 3, 130 bytes
Taking your requirements literally, and taking carriage returns to be one byte each:
y=0
def x():
    global y
    y=1-y
    print(("That's not my lamb, it's "+b[0:1][y]+" is too red\n")*5+"That's my lamb! Its fan is so red")

"It must not consistently reproduce the same text." From what I can tell, your code will always alternate between one of two options, which seems like consistent output to me. Also, this case of always using the same properties on every single line has been explicitly disallowed in the comments clarifications.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Print "N NE E SE S SW W NW"
This seems almost trivial, but since after some effort I was not able to beat the literal solution in J, I thought it might make a decent challenge (though, to be clear, this is not a J-specific challenge).
Title says it all.  You simply need to write a program, or function (taking no arguments) that returns or prints:
N NE E SE S SW W NW

You may use newlines in place of spaces.
A no-argument function returning an array of strings such as
['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']

is also acceptable.
The letters may be upper or lower case, but may not be mixed.

Perhaps allowing them to be output in any order would be slightly more interesting

@JoKing Sure, I'll remove that.  Honestly, I didn't expect anyone to submit answers that used the full literal value -- that's not in the spirit of the question.  As I state, it came up because I wasn't able to beat the literal in J, despite the string having regularity and structure of a sort.  The whole point is to exploit that regularity to beat a literal answer.  Bad on me for not being more explicit.  Allowing them any order defeats that as well, so I don't want to make that change.

Well, even though everything's been a literal, compressed literal, or base conversion, I do still like the idea here... maybe a new challenge with the cardinal directions spelled out could do better? I feel like raw dictionary compression, or maybe base conversion with dictionary compression, would probably end up being the shortest, but at least languages without good compression tools would be able to go algorithmic with it.

@UnrelatedString The most promising idea I've had is to note that the directions correspond to i raised to the powers 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5.  Unfortunately the J code required to then map those results into letters ended up being more expensive than a literal.

Ah, smart! I wonder if the mapping might work better for the Gaussian integers 1, 1+i, i, -1+i, -1, -1-i, -i, 1-i so you've got one real or imaginary part per cardinal direction instead of two. It's probably harder to generate those though, unless there's some way you could round those powers of i away from 0? I don't know how easy or hard that would be in J, but it's an idea.

If returning an array of strings, are spaces acceptable in those strings? e.g. [' W', ' E', 'N ', 'NW', 'NE', 'S ', 'SW', 'SE']

May we have additional spaces between directions, e.g. N  NE  E  SE  S  SW  W  NW?

@Adám Sorry on further consideration I think that should be illegal

@Sok Sorry yours isn’t allowed either (but nice answer if it has been)

It feels like entries should also show the naive "echo this string" version in their language for comparison, and judging be done on the % shortened?

Canvas, 12 bytes
＞X½+Ｔ）ＡuS{⁹‟

Try it here!
The string, simply compressed.

Can you explain how this works in a little more detail?

@Dillanm there isn't much more to say - Canvas has a built-in compressor (should be accessible with ctrl+o → string compress) that, here, simply stores the characters needed ("NESW ") and then in base-5 stores the individual characters.

bash (24 bytes)
using brace expansion
echo N {N,,S}E S {S,,N}W

is the same length as hard coding
echo N NE E SE S SW W NW

however it becomes more interesting when outputing more points of the compass
echo N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW

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

otherwise if order could be changed, (17 bytes), the trick is that without quotes the empy string parameter disappears
echo {N,,S}{W,,E}

That is interesting, I didn't know that you could have empty position is the brace expression!

@flawr Useful when chrooting: mount -t proc{,,}

Or cp file{,.bak}

Mornington Crescent, 4395 3823 bytes
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

Try it online!
Since it's a bit much to expect you to read all that, let me give a quick overview of my approach. The main idea is to store 3 copies of the characters N,E,S,W at various stations on the Circle line, via Bank - Hammersmith. These characters are constructed from the start of a station name at Charing Cross. Then, construct   from the middle of a well-chosen station name using Mile End and Charing Cross, and store it at Bank so that it can be collected at Hammersmith in the concatenation. Finally, concatenate the characters one by one at Paddington, copying them again via Bank - Hammersmith if they are need to be reused later.

I think the current solution is fairly close to optimal with this strategy, at least in terms of number of stations visited: just 2 times I used a station only for transit:

to get to Seven Sisters (via Victoria station)
and to get back to Mornington Crescent (via Bank).

All other station visits were, if I didn't forget one, either storing/retrieving something useful or (part of) using the stations ability.
As for the line lengths, I've tried to pick the shortest names on Circle Line, but there may be a minor improvement there. It's possible that storing something on District can shave off a few bytes.

Two ideas to golf this some more: 1. take 'NE', 'SW', 'NW', 'SE' from a single station (Using e.g. Neasden, Swiss Cottage, Acton Town and Mansion House) 2. Try to exploit the fact that Paddington makes it easier to concatenate W rather than W . This does require some more overhead to 'refresh' Paddington, so it may not gain anything.

Does this use Dollis Hill loop rules? If so, I think it can be improved by use of an Argyle Street parabola, and maybe even a slightly modified version of the Webb-Ellis protocol.

PHP, 19 bytes
N NE E SE S SW W NW

Try it online!
Getting this out of the way. Someone will do it eventually.

Also works for HTML+JS.

Polyglot with ///.

brainfuck, 142 139 131 119 bytes
++++++++++[>+++>+++++++>++++++++>+++++++++<<<<-]>>>--.<<++.>>.<-.<.>.<.>>+++++.<.<.>>.<<.>>.>---.<<<.>>>.<<<.>>-----.>.

Try it online!
Simply loops 10 times to fill the cells with 30, 70, 80 and 90 then steps backward and forwards and adjusts the cell values to print out the required characters. Not much different from the standard "Hello world!".

Lol I've never understood how anyone can "golf" these obscure languages.  Its hard enough to understand what the code does in the first place (this is said coming from C++ / Java background)

@mackycheese21 what? C++ didn't teach you to love pointer manipulation?

brainfuck might be esoteric, but I sure wouldn't call it obscure

@candied_orange C++ taught me to hate pointer manipulation and run away whenever someone mentioned std::   :)

@UnrelatedString obscure, no. Obtuse, yes.

check out my answer with 118 :)

Brain-Flak, 204 bytes
((((((((((((((((()()()){}()){}){}())){}{}))<([([][]){}()]{})(([][]){}[])>)<([][]
()())>)[[]]()())<([]()()())>)<((([]())[][]){}[][()])>)<([][()()])>[[]()])<([][((
)()){}])>)((()()())){}{})<((()()()()()){})>)

Try it online!

Points deducted for wrapping.

MarioLANG, 249 221 bytes
+
+
+
+
+
+
+
+
+  ((+++++++++)))<
+>==============="
)++++++++)+++((-[!)--.)++.(.---------.).(.).)++.((.).).(.).++++.(.).(.(+++++++++.))
=================#================================================================.

Try it online!

Excel Formula, 59 57 bytes
The following should be entered as an array formula (Ctrl+Shift+Enter):
=SUBSTITUTE(ADDRESS(1,{14,369,5,499,19,517,23,387},4),1,)

After entering the formula as an array formula, highlight it in the formula bar and evaluate it using F9 to return the result, for example:
Before:

After:

How it works
The ADDRESS function returns a string representing a reference based on two parameters, row and col. The third parameter controls what type of reference is returned, an absolute or relative reference. For example, =ADDRESS(1,2,4) returns "B1".
We can supply an array to ADDRESS and use it as an array formula to return multiple results, for example =ADDRESS(1,{1,2,3},4) returns "A1","B1","C1".
Therefore, in my answer, the array supplied to ADDRESS are just the column numbers relating to the required compass points, e.g. Column 14 is column N, Column 369 is column NE.
However, we are not finished here since all the returned references have the row included, for example, N1, NE1. Therefore, we simply use SUBSTITUTE to remove the 1 from all references.

Would =IF(1,"N NE E SE S SW W NW") be valid?

@squid Yes it would indeed! However, I was going for an alternative which didn't require the string to be quoted verbatim.

How does this work?

@anatolyg I've added an explanation section, hope it's understandable.

the CSE keystrokes are no longer as of Excel 2021; also the poster has removed the requirement that output be in order, so you may be able something along the lines of ={"","N","S"}&{"";"E";"W"} now

Deadfish~, 188 183 bytes
-5 thanks to squid
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

Try it online!

{i}dc at the end for 183

Triangularity, 71 bytes
..... .....
...."W"....
..."W N"...
.." SW "+..
." SE S"++.
"N NE E"+

Try it online!
There are two spaces on the last line to hit the byte count Triangularity requires.

brainfuck, 117 bytes
+++++[>++++++>+>+++>>++++>+++++<<<<<<-]>++[>++>++>+>++>++[<]>-]>>-.>.<.<.>>.<<.>>.>-.<<<.>>.>.<.>.>--.<<.>>.<<.<.>>>.

Try it online!
This code will first create the characters "EN SW" into the memory and then move back and forth to print them. The space is in the middle, because it is printed most often. N and S and W and E never appear together so they are on opposite sides of the memory.
For optimization some of the final decrements happen during the output phase.

OK, that's a cool answer. Guess you beat me on this one. +1 for -1 :-)

BTW, forgot to say, welcome to the Code Golf site. Looking forward to competing with you in the future ☺

Welcome! Consider adding an explanation or a link to an online interpreter for the program. See other answers for examples. Short code-only answers tend to get automatically flagged as low-quality.

Thanks, I can add a explanation of my code. I will also try to understand how the online links work.

@Helena For the link you can check out the "Try it Online" link on my answer. If you paste your code in and run it you can then click on the link icon and get a perfectly formatted code golf answer that you can simply copy and paste here. Works like magic and supports many languages. Well worth a try.

Python 2, 62 61 58 53 bytes
i=8
while i:print'NESESWNW'[~i+(i==4):][:1+i%2],;i-=1

Try it online!
Not great, but at least not a plain print..

Charcoal, 14 bytes
”{⊟“�_Ｚn↖⦄ＲüΦ≦

Try it online! Link is to verbose version of code... which is just the string to be printed, as the auto-deverbosifier takes care of the string compression.
Printing the string uncompressed takes 19 bytes, since Charcoal prints printable ASCII literally. The best algorithmic answer I could come up with unfortunately takes 20 bytes:
Ｅ⁸ΦSNWE›³﹪⁻﹪⁺⁵×⁶μχι⁸

Try it online! Outputs using array format (would cost two bytes to join the elements on spaces). Works by noticing that the letters of the string SNWE are used only when the current outer index equals or is 1 away (modulo 8) in either direction from the corresponding element of the list of indices 4,0,6,2.

Jelly,  16  15 bytes
“¤œỵpq⁵’ṃ“NESW

A full program printing the text
Try it online!

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

A niladic Link which yields a list of lists of (lowercase) characters.
Try it online!

Alternative 15 as a niladic Link which yields a list of (lowercase) characters (with spaces): “¡XÇŀqỵÑ’ṃ“¡⁴ṁ».

Commodore BASIC (TheC64Mini, C64, C128, VIC-20 etc.) 28 Tokenized BASIC bytes used
 0 PRINT"N NE E SE S SW W NW

In Commodore BASIC, you do not require the closing quotation mark on PRINT or LET statements as the interpreter will auto-close it, this saves one BASIC token.
Alternatively, one may simply use direct mode as follows:
Commodore BASIC 23 PETSCII characters (+ RETURN to execute)
?"N NE E SE S SW W NW

I'm not sure how to count the number of bytes used in this instance as according to the interpreter ? and PRINT use the same number of bytes, and there is no program stored in memory.

PRINT can be replaced with ? as well, saving four bytes.

No, that's not true; PRINT and ? use the same amount of BASIC tokens. I'm not counting PETSCII characters as it's not very representative of how much of the available memory is being used by the interpreter.

After all of these years I'm still learning new stuff about the Commodore. Thanks Shaun!
https://www.c64-wiki.com/wiki/BASIC_token

Here's one I made earlier (for the C64) -> https://pastebin.com/NMYzTC7k

Vyxal, 13 bytes
«ƛ.←√Fǎ⁰ɾ@=½•

Try it Online!
-1 thanks to AaronMiller
Vyxal forever lads, it has crushed 05AB1E and Jelly I am so proud

Why settle for a tie with 05AB1E when we can beat it?

I wholeheartedly approve of this

Deadfish~, 138 bytes
{{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

Try it online!
So, outputting in lower-case with newlines is better than default (upper-case with spaces).
This code was generated by my optimizer, written in C++ (thanks to squid for another optimization idea!):
#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';
}

155

Batch File, 19 bytes
The question never stated that you had to output N NE E SE S SW W NW and nothing else, nor that it couldn't exit due to error after doing so this code only throws an error but does not exit due to it.
N NE E SE S SW W NW

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

Batch File, 25 bytes
Only N NE E SE S SW W NW output with no errors or crashes.
@echo N NE E SE S SW W NW

You could save a byte replacing cd with just quotes, like 'N NE E SE S SW W NW' - you'll get something like:
N NE E SE S SW W NW - command not found

MathGolf, 20 17 bytes
ÿnesw▒∙╫m+mÉîÄ╪^─

-3 bytes thanks to @maxb.
Try it online.
Explanation:
ÿ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)

17 bytes. This was a fun challenge. I tried it before, but ended up where you did. I think the most you could do from this is 1 byte more, but I couldn't find a shorter way.

@maxb Ah nice approach. I must admit that those code of block-size X (É and Ä in this case) still confuse me a bit sometimes.. Sometimes I'm not sure when I do or don't have to use those code-blocks. Your m+ doesn't use one for example. But your Ä is a code-block of size 1. I tried mÅî╪ just yet to see what happened, which is why I now understand why there is a code-block of size 1 Ä to begin with. :) ) Thanks for the -3 bytes, though. Still a lot to learn I see.

Nice explanation! I tried doing a solution without converting it to a list of chars, but the zip command was a bit wonky. For the code blocks, think of them as replacements, used instead of {}. mÅî╪ creates the mapping, but it doesn't have a for-loop inside the mapping. If you write m{î{╪}}, it is perhaps easier to see that the code is "map to: loop  times, and rotate the string each loop". The reason why m+ does not have one is that certain commands have implicit 1-byte blocks (map, filter, reduce, etc), but î is not a command meant to be used in combination with a block.

@maxb I indeed knew the code-blocks were a shorter variant of {...}, but I kinda forgot integer{ is a for-loop. :) Now the îÄ╪ makes a lot more sense. Thanks for the explanation!

Whitespace, 151 bytes
[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]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs, and new-lines only).
Explanation:

Push the unicode values minus constant 84 for the characters "WN W WS S ES E EN N" to the stack (note that the string is pushed in reversed). In addition, I use a few copies of previously pushed values to save bytes where possible.
Then start an infinite loop, which does the following:

Add the constant 84 to the current unicode value
Print it as character to STDOUT

The constant 84 is generated by this Java program which I wrote for another challenge I answered in Whitespace.

CSS, 42 39 bytes
(thanks to a stone arachnid for the revised version)

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

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

Oh I forgot, that's valid as well ofc, updated :)!

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

The magic number is the joined three-bit indexes into the character string, reverse order so we can start iterating at the LSB.

I spent a while trying to shrink the magic number, but repeating the character string via multiply to allow for extra indexes doesn't work out due to needing to encode for space - best I got for overlapping indexes in the lookup added more characters to the string than digits removed from the magic number (including a couple of unfortunate don't-cares in the middle):
''.join('WN S ES W xxE '[0x423659711>>i*2&15]for i in range(19))

Why make ir simple when you can make it complicated? :-)

Japt, 16 bytes
Returns an array of lowercase strings. The compressed string was 18 bytes but using a as the delimiter instead and then splitting on that worked out shorter.
`nÂà!Z°°nw`qa

Try it - footer formats the output.

K (ngn/k), 23 22 bytes
-1 byte thanks to ngn!
"WNES"@5\7108085518230

Try it online!
J, 34 30 bytes
echo(#:3510)<;.1'NNEESESSWWNW'

Try it online!

Galen, for J echoing the literal would be shorter.  I would love to see that beat... I haven’t managed to do it

Yes, echoing would be be 4+19 bytes. I don't have any better ideas to.

for k: if we swap " "<->"W" (0<->4 in base 5), the space will be at the end and we can remove it because out-of-bounds string indexing gives a space anyway: "WNES"@5\7108085518230

@ngn Good design choice for the out-of-bounds string indexing resulting in a space (at least for codegolf :) )

@GalenIvanov good for top-performance databases too :) arthur designed k as the underlying language for kdb+

Can you explain how the ngn/k answer works? I can't get it to work in the k interpreter that comes with q.

Nevermind, got it, you're representing the big number in base 5. ngn doesn't need the column for 5/:bla. Neat.

@HenryHenrinson Yes, I index into the string of characters with indeces "packed" into a big number in base 5. ngn made his version of K to return as many positions as needed in the respective number base.

@HenryHenrinson : in k4 (q), \ in k5, \ in k6, and it looks like it's gonna be : again in k7 (shakti). my dialect is close to k6 mostly

Seed, 4251 bytes
27 [encoded data, 4248 characters]

Try it online!

-1724 bytes.

@awi I golfed it with my current generator even further. now my solution is 20 bytes smaller than yours.

now 40 bytes smaller.

How long does it take for your generator to find these solutions? Mine takes 1-10 minutes.

@awi around a minute.

Hodor, 177 bytes
hodor.hod("HoOodoOorhodor  HoOodoOorhodor HooodorrHodor  HooodorrHodor  HODOR?!? HooodorrHodor  HODOR?!?  HODOR?!? Hooodorrhodor  Hooodorrhodor  HoOodoOorhodor Hooodorrhodor ");

Try it online!

05AB1E, 14 bytes
.•2Àβ‡yÞJŒ¾oÒ8

Try it online!
This prints out the string except lowercase.

Just remove the final • for -1

Brachylog, 18 bytes
"NeSw"it;?↺₍h₂a₀oụ

Try it online!
Semi-port of my Jelly solution. Generates each direction.
"NeSw"                Let the input variable be "NeSw".
      i               Take a pair [element, 0-index] from it,
       t              extract the index,
        ;?↺₍          and rotate the input variable left by that many places.
            h₂        Keep only the first two elements of the rotation,
              a₀      take a prefix (nonempty, shortest first) of it,
                o     sort (putting uppercase before lowercase),
                 ụ    and fold to uppercase.

Barely beats my original...
Brachylog, 19 bytes
"NNEESESSWWNW"ḍ₄ḍᵐc

Try it online!
Outputs as a list. ḍ₄ḍᵐc saves two bytes over writing out seven spaces and making the entire predicate a string literal, so at least it ties PHP...
"NNEESESSWWNW"         The string "NNEESESSWWNW"
              ḍ₄       split into quarters
                 ᵐ     with each quarter
                ḍ      split in half
                  c    and concatenated
                       is the output.

JSFuck, 8529 bytes
[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[!+[]+!+[]])+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]])()([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[])[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(+[![]]+[])[+[]]+(!![]+[])[+[]]+[+!+[]]+[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+[]]+(+[![]]+[])[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]])[(![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]]((!![]+[])[+[]])[([][(!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]](([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+![]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]])()[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]])+[])[+!+[]])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]])())

Just for the fun of it

PowerShell, 21 bytes
'N NE E SE S SW W NW'

Try it online!

Same in Swift Playground, with "N NE E SE S SW W NW", if you want. But too trivial to post.

this is code golf. see not trivial in the edit history.

Assembly (x86, Linux), 68 bytes
$ 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$

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 mostly taken from Shortest ELF for "Hello world\n"?

A0A0, 69 bytes
P78P32P83
P32P83P87
P78P69P32
P69P32P87
P32P83P32
P69P32P78
G-6G-6P87

Not much to this one, Px prints the character corresponding to ascii value x, so we just print the correct values. G-6 jumps back to the top. Splitting the code into three columns is optimal for saving bytes on new lines, while not using too many bytes on additional jumps. Two columns gives the same amount of bytes, but three columns is nicer to display on this site.

Pip -s, 20 bytes
Just barely shorter than printing the literal string.
"NESW"WV<>"NESESWNW"

Attempt This Online!
Explanation
"NESW"WV<>"NESESWNW"
      WV              Weave
"NESW"                the characters of this string
                      with
          "NESESWNW"  this string
        <>            taken in blocks of 2 characters each
                      Result: ["N";"NE";"E";"SE";"S";"SW";"W";"NW"]
                      Autoprint, space-separated (-s flag)

I added the unary version of <> because of this challenge, although I'm sure it will be useful elsewhere too.

Malbolge, 151 126 118 115 bytes
(&<`@#!\}5Y9z1Uv4tQsr)M-n%I#"!&DBe/R-`_<ts[Jp$5WUk1ShmPkd*uts%G#bE`lkW\>-Y+:utT`R5P2HMk/-h++@d'&%;:^8~6}Y32V0T.uQ+N

Try it online!

Well done! (Fill)

As input to Commodore BASIC, you can get it even shorter: (23 bytes)
0 ?"N NE E SE S SW W NW

? is shorthand for PRINT.

? and PRINT use the same number of BASIC tokens so you are not saving any memory in your stored symbolic listing.

><>, 25 24 bytes
This is a pretty simple answer. Push the string in reverse, then print the stack. Exits with an error due to stack underflow.
"WN W WS S ES E EN N">o<

Try it online!

You can remove the skip and it still works, doesn't it?

@squid Indeed. I originally was using | instead of the arrows.

If superfluous spaces are allowed, you can shave off one more byte "WN WWS SES EEN N">ooa<.

@PidgeyUsedGust https://codegolf.stackexchange.com/questions/186582/print-n-ne-e-se-s-sw-w-nw/186704?noredirect=1#comment447191_186582

Assembly (MIPS, SPIM), 71 70 bytes
.data
t:.ascii"N NE E SE S SW W NW"
.text
main:li $2,4
la $4,t
syscall

Try it online!
I haven't done anything with MIPS in a while, so if there's a shorter way please tell me!
Edit: used an ascii and not an asciiz string

Jelly, 16 bytes
“æṖØq’ḃ⁴ḃ4ị“NESW

Try it online!
With footer to print separated by space
A niladic link which returns a list of strings. 2 bytes shorter (and arguably more interesting) than the compressed string in Jelly.

Java, 24 bytes
Quick, gotta do it before anyone else
v->"N NE E SE S SW W NW"

Null is equivalent to no input
TIO

According to the meta it indeed is allowed to take an unused null argument when a challenge states no input. I suggest using the Void class as input, since it has no useful static calls nor purposes. Try it online. EDIT: Ah, I see you had that initially, so you could roll-back and perhaps add the meta-post. ;)

@KevinCruijssen I rolled it back

C# (Visual C# Interactive Compiler), 24 bytes
_=>"N NE E SE S SW W NW"

Try it online!

This also works in Javascript.

Polyglot with Foo.

what other characters are allowed besides '_' ?

R, 26 bytes
cat('N NE E SE S SW W NW')

Try it online!

k, 23 bytes
1_,/'$,/``N`S,/:\:``E`W

Keg, 19 bytes
Simply hard-coding the answer.
N NE E SE S SW W NW

SQL, 28 26 bytes
On behalf of BradC:
PRINT'N NE E SE S SW W NW'

SELECT 'N NE E SE S SW W NW'

You can save 2 bytes with PRINT'N NE E SE S SW W NW'

@BradC: Also thought about this, but I am not sure it matches the rules, because, yes, it prints desired result, but in principle returns nothing. But you may be right.

We pretty routinely use whichever of PRINT or SELECT is shorter/more useful for SQL-language challenges on CodeGolf, see the SQL language tips thread. Either way you can drop the space before the quote.

Stax, 16 bytes
Ä\8←ΘåÑ¥▒Nx╚ø┼Çt

Run and debug it

Perl 5, 21 bytes
<N {N,,S}E S {S,,N}W>

Standard glob function emulating *nix shell. See perldoc -f glob for more details.
Alternative, 21 bytes
<N NE E SE S SW W NW>

Didn't need to use qw since glob splits on whitespace and treats each pattern separately.

This doesn’t appear to be in the correct order

I thought your comment alluded to relaxing that requirement

It’s a bit confusing, but read the last two sentences of the comment and it should be clear.

The first part of that was referring to a now deleted comment about disallowing snippets

How is this 14 bytes?

Not sure how that happened, fixed

Jelly, 14 bytes
8ḶHị“eSwN”Ṣ€Œu

Try it online!
Niladic link returning a list of strings.
  H               Halve
8Ḷ                each number in 0 .. 7,
   ị“eSwN”        and modular 1-index each into “eSwN”.
                  Not only is ị modular, but it also handles fractional indices by flooring and ceiling them, returning a list of both elements.
          Ṣ€      Sort each, placing lowercase letters after uppercase.
            Œu    Uppercase.

Come to think of it, this returns a ragged array of characters, rather than a real list of strings, so I guess you can slap a K on the end and call it a full program if that’s an issue. I guess the Ṣ actually does wrap non-list arguments.

Thunno 2, 13 bytes
“£ḂA⁷<ọŒ⁼Ẓ2Ẏ®

Simple compressed string. Add the Ụ flag if you want it in uppercase.
Screenshot

Ruby, 22 bytes
p'N NE E SE S SW W NW'

Try it online!

One more Python example:
for i in range(8):print''.join(c*((i+m)%8<3)for c,m in zip('NSEW',(1,5,7,3))),

I tried to use no cryptic operations, just normal math + boolean logic.
Try it

Haskell, 21 bytes
I don't think it gets any shorter than this in Haskell.
"N NE E SE S SW W NW"

Try it online!

Stax, 16 bytes
Æ+góïr!½*ÄJ╓╨°╩Æ

Run and debug it

Assembly (x86, GCC), 151 bytes
$ cat foo.s
.global _start
.text
_start:mov $1,%rax
mov $1,%rdi
mov $m,%rsi
mov $19,%rdx
syscall
mov $60,%rax
xor %rdi,%rdi
syscall
m:.ascii "N NE E SE S SW W NW"
$ gcc -c foo.s && ld foo.o && ./a.out
N NE E SE S SW W NW$

Suggest mov $60,%al

lea can save you some $. (e.g. lea 1,%eax)

DC, 79 bytes
78sn7Dss69se87swAsblblwlnlblwlblwlslblslblelslblelblelnlblnPPPPPPPPPPPPPPPPPPPP

It loads the characters NESW and newline into registers, then loads them onto the stack and prints them all

Underload, 22 bytes
(N NE E SE S SW W NW)S

Pretty self explanatory
Try it online!

Befunge-93, 45 bytes
"WN W":" "\"S":" "\" ES E":" "\"N":" "\>:#,_@

Try it online!

Or just hardcode the string

@JoKing I am aware that this is an option, but I didn't want to just hardcode it

Red, 25 bytes
prin"N NE E SE S SW W NW"

Try it online!
My first Red answer and first answer this month.

Already beating your python answer ;)

Python 2, 26 bytes
print'N NE E SE S SW W NW'

Try it online!
Why make things complicate when we can do simple??

Smalltalk, 37 bytes
Transcript show:'N NE E SE S SW W NW'

26 bytes if you don't mind surrounding quotes:
'N NE E SE S SW W NW'print

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Generate Aheui Number
Make a Number Expression is related : actually, it is also about Aheui. But it just made number expression, but this made real Aheui code.

Aheui is esolang written in only Korean character. Because of its nature, Aheui can't use Arabic numbers.
But, of course, there is way to generate number.
Brief introduction to Aheui
Reading the link above is best, but put it shortly : Aheui is befunge-like esolang : have cursor, every character is instructor, and using stack.
One instructor, looks like 박, have three part : Initial consonantㅂ, vowelㅏ, final consonantㄱ.
First part, initial consonant, determine what to do.
Here is table of initial consonant that can be useful here:

ㅇ : no operation.
ㅎ : terminate.
ㄷ : pop two number from current stack, than add them, and push to current stack.
ㄸ : same as ㄷ, but multiply instead of add.
ㄴ : pop two number from current stack, push second // first to current stack.
ㅌ : same as ㄴ, but subtract instead of divide.
ㄹ : same as ㄴ, but modulo instead of divide.
ㅂ : push number to current stack. Number is given by final consonant.
ㅃ : duplicate top of current stack.
ㅍ : swap top two value of current stack.

Second part, vowel, determine momentum. Maybe you just need ㅏ, go to next.
Last part, final consonant, determine number to used in ㅂ commend.
Here is list of final consonant and number.

Nothing
ㄱ, ㄴ, ㅅ
ㄷ, ㅈ, ㅋ
ㅁ, ㅂ, ㅊ, ㅌ, ㅋ, ㄲ, ㄳ, ㅆ
ㄹ, ㄵ, ㄶ
ㅄ
ㄺ, ㄽ
ㅀ
ㄻ, ㄼ

Finally, 망 is printing operator. Your code have to print 망희 or 망하 or whatever after calculation, to print and terminate the program.
Korean Character
Every Aheui instructor is Korean character.
As I mentioned above, Korean character has three part : Initial consonant(choseong or 초성), Vowel(jungseong or 중성), Final consonant(jongseong or 종성).
Every character has initial consonant and vowel, but final consonant is option.
Korean character in Unicode is from AC00(가) to D7A3(힣).
For composing Korean character, look at this webpage for help.
Question
Input is an positive integer. Generate aheui code that prints given integer, without hardcode every possibility.
You can test your Aheui code at try it online.
Examples
Input | Output | Discription
1 | 반밧나망희 | Put two 2s in stack, divide, print, and halt.
1 | 반반나망희 | Same as above.
1 | 밪반타망희 | Put 3 then 2 in stack, subtract, print, and halt.
3 | 받망희 | Put 3 in stack, print, halt.
3 | 반밧나빠빠다다망희 | Put two 2s in stack, divide, duplicate two times, add two times, print, halt. This is OK, but won't get good point.
72 | 밢밣따망희 | Put 8 and 9 in stack, multiply, print, and halt.
10 | 박밙따망희 | Put 2 and 5 in stack, multiply, print, and halt.

Scoring
Average length of 101 Aheui codes that prints 100 to 200. If score is same, shorter code wins.

Should probably test on multiple (ideally randomly selected) integers to avoid having people hardcode the n = 100 case.

@bb94 I thought that, but if people hardcode it, code length would be longer. So maybe it would be OK. And I though complicated scoring is not good. But maybe  just adding one more case would be fine.

Which range of integers are we supposed to support?

@Arnauld From 1 to... I actually never thought about that. Every positive integer would be fine.

@LegenDUST I'd assume that it might be more profitable for some languages to hardcode the n = 100 case and have a simple algorithm for the other integers than to code a more complicated algorithm.

@bb94 I got it. Maybe five integers can handle the problem? Like 5, 42, 101, 1000, 2048?

@LegenDUST Maybe it would be better to test every integer from 1 to 65536, though this could be reduced if it's too slow to test that high.

@bb94 Too big, I think. Maybe 100 to 200 can be better, but nice idea. Thank you for your advice/

If you want to get feedback for your challenges before posting them, the sandbox exists for this exact purpose.

@EriktheOutgolfer I actually posted at sandbox for about 2 days ago, but no one had gave me feedback.

That's kind of an eminent problem, yeah. You can ask for feedback over The Nineteenth Byte (our main chat room) if you feel like that's happening.

@EriktheOutgolfer Thank you. I'll keep that in mind.

I would say the category [tag:code-challenge] suits better because of other factors affecting the score other than code length

@ShieruAsakoto Thanks for your advise. Then I'll remove code length completely and use it if score is same.

Wouldn't hardcoding optimal ways to generate 100-200 be optimal for this scoring system?

@attinat One hundred Aheui codes? Hmm. Since it is code challenge now, I can ban hardcoding. I'll fix it.

There are 101 numbers from 100 to 200, inclusive.

@attinat Ah. Hundred one instead of one hundred. My mistake.

Jelly, Score 849/101 = 8.406; 126 bytes of Jelly code
9,`€µŒċZ€ṪḢ,0Ɗ¹E?ṭƊ€ż,ƭ€Ɱ€⁾+×ẎF€€ḢV;Ɗ€;@1ị<ɗƇ201FL$Þµ1ịⱮŒQTịµ$3¡Ṣṫ100Ṫ€F€⁵;‘,@⁾+×¤yⱮị⁽ıaD×588+“Ḥþ’Ḣ;+¥“ƲG~ọ’b21¤;ƲƲ¤;€“ẒP“ṃƓ’Ọ

Try it online!
A niladic link that returns a list of Jelly strings, one for each Aheui number from 100 to 200. The footer on TIO prepends the total length and the mean length.
Note this is equal in score to attinat’s Mathematica answer, but shorter in code length to generate the Aheui numbers. Full explanation to follow. Uses ㅂ (push), ㄷ (add), ㄸ (multiply) and ㅃ (duplicate) for initial consonants.
Output:
8.405940594059405
849
100 - 밖밙빠따따망희
101 - 밖밙따밟빠따다망희
102 - 밨밤밟다따망희
103 - 밙밤따밞밟따다망희
104 - 밤밖밟다따망희
105 - 받밙밞따따망희
106 - 밙빠따밟빠따다망희
107 - 밙밞따밤밟따다망희
108 - 박밨밟따따망희
109 - 밖밞따밟빠따다망희
110 - 바밟다박밟다따망희
111 - 밙밨따밟빠따다망희
112 - 박밞밤따따망희
113 - 밖밤따밟빠따다망희
114 - 밨밞따밤밟따다망희
115 - 받박밞밤따따다망희
116 - 밙밞따밟빠따다망희
117 - 밟밖밟다따망희
118 - 밨밟따밤빠따다망희
119 - 밞밤밟다따망희
120 - 받밙밤따따망희
121 - 박밟다빠따망희
122 - 바박밟다빠따다망희
123 - 밨밞따밟빠따다망희
124 - 박밨밞밤따다따망희
125 - 밙밙빠따따망희
126 - 박밞밟따따망희
127 - 밞밟따밤빠따다망희
128 - 박밤빠따따망희
129 - 밨밤따밟빠따다망희
130 - 바밟다밖밟다따망희
131 - 받박밤빠따따다망희
132 - 박밨따박밟다따망희
133 - 밙박밤빠따따다망희
134 - 박받밤빠따다따망희
135 - 받밙밟따따망희
136 - 밤밤밟다따망희
137 - 밞밤따밟빠따다망희
138 - 박밙밤빠따다따망희
139 - 받밤밤밟다따다망희
140 - 밖밙밞따따망희
141 - 바밖밙밞따따다망희
142 - 박밖밙밞따따다망희
143 - 박밟다밖밟다따망희
144 - 박밤밟따따망희
145 - 밤빠따밟빠따다망희
146 - 박바밤밟따다따망희
147 - 받밞빠따따망희
148 - 바받밞빠따따다망희
149 - 박받밞빠따따다망희
150 - 밙밙밨따따망희
151 - 바밙밙밨따따다망희
152 - 박밖밤밟따다따망희
153 - 밟밤밟다따망희
154 - 박밞따박밟다따망희
155 - 박밟밤밟다따다망희
156 - 박밨따밖밟다따망희
157 - 밖밟밤밟다따다망희
158 - 박밞밤밟따다따망희
159 - 받밖밞빠따다따망희
160 - 밖밙밤따따망희
161 - 바밖밙밤따따다망희
162 - 박밟빠따따망희
163 - 바박밟빠따따다망희
164 - 박바밟빠따다따망희
165 - 박밟다받밙따따망희
166 - 박박밟빠따다따망희
167 - 밙박밟빠따따다망희
168 - 받밞밤따따망희
169 - 밖밟다빠따망희
170 - 바밟다밤밟다따망희
171 - 박밖밟다빠따다망희
172 - 박밙밟빠따다따망희
173 - 밖밖밟다빠따다망희
174 - 박밨밟빠따다따망희
175 - 밙밙밞따따망희
176 - 박밤따박밟다따망희
177 - 박밙밙밞따따다망희
178 - 박밤밟빠따다따망희
179 - 밖밙밙밞따따다망희
180 - 밖밙밟따따망희
181 - 바밖밙밟따따다망희
182 - 박밞따밖밟다따망희
183 - 받밖밙밟따따다망희
184 - 밖바밙밟따다따망희
185 - 밙바밖밟따다따망희
186 - 받밨밞밤따다따망희
187 - 박밟다밤밟다따망희
188 - 밖박밙밟따다따망희
189 - 받밞밟따따망희
190 - 바받밞밟따따다망희
191 - 박받밞밟따따다망희
192 - 받밤빠따따망희
193 - 바받밤빠따따다망희
194 - 박받밤빠따따다망희
195 - 받밙따밖밟다따망희
196 - 밖밞빠따따망희
197 - 바밖밞빠따따다망희
198 - 박밟다박밟따따망희
199 - 받밖밞빠따따다망희
200 - 밙밙밤따따망희

Wolfram Language (Mathematica), score 849/101 = 8.406
g@n_:=f@n<>"망히"
f@n_:=f@n=Switch[n,-1,"밯",1,"반반나",9,"밞",8,"밣",7,"밝",6,"밦",5,"발",4,"밗",3,"받",2,"박",
_,mn@{m@n,a@n,s@n}]
m@n_:=m@n=f@#<>If[# #==n,"빠",f[n/#]]<>"따"&/@Select[Divisors@n,1<# #<=n&]//mn
a@n_:=a@n=f@#<>f[n-#]<>"다"&/@Range[⌈n/2⌉-1]//mn
s@n_:=s@n=m[n+#]<>f@#<>"타"&/@Range[n-1]//mn
mn=First@*MinimalBy[StringLength[""<>#]&]

Try it online!
Builds numbers with 다 (+) 따 (*) 타 (-), and 빠 (duplicate), in addition to literals for 2..9. Doesn't actually make use of 밯=-1.
Paste the tio output (Unicode character codes) into Mathematica to see the result:

100 -> 밗발빠따따망히
101 -> 박밞박밞다따다망히
102 -> 밦밣밞다따망히
103 -> 받밗발빠따따다망히
104 -> 밣밗밞다따망히
105 -> 받발밝따따망히
106 -> 박밗밝빠따다따망히
107 -> 박받발밝따따다망히
108 -> 박밦밞따따망히
109 -> 밗받발밝따따다망히
110 -> 박발박밞다따따망히
111 -> 받박발밝따다따망히
112 -> 박밝밣따따망히
113 -> 발박밦밞따따다망히
114 -> 박받밦밞따다따망히
115 -> 발박받밝따다따망히
116 -> 박박밝밣따다따망히
117 -> 밞밗밞다따망히
118 -> 박받밝밣따다따망히
119 -> 밝밣밞다따망히
120 -> 받발밣따따망히
121 -> 박밞다빠따망히
122 -> 박발밝밣따다따망히
123 -> 받발밗밞따다따망히
124 -> 박밦밝밣따다따망히
125 -> 발발빠따따망히
126 -> 박밝밞따따망히
127 -> 박발발빠따따다망히
128 -> 박밣빠따따망히
129 -> 받받발밣따다따망히
130 -> 박발밗밞다따따망히
131 -> 받박밣빠따따다망히
132 -> 박밦박밞다따따망히
133 -> 밝박밣밞다다따망히
134 -> 박받밣빠따다따망히
135 -> 받발밞따따망히
136 -> 밣밣밞다따망히
137 -> 박받발밞따따다망히
138 -> 박발밣빠따다따망히
139 -> 받밣밣밞다따다망히
140 -> 밗발밝따따망히
141 -> 받박발밞따다따망히
142 -> 박밝밣빠따다따망히
143 -> 박밞다밗밞다따망히
144 -> 박밣밞따따망히
145 -> 발박받밞따다따망히
146 -> 박밞밣빠따다따망히
147 -> 받밝빠따따망히
148 -> 박박밣밞따다따망히
149 -> 박받밝빠따따다망히
150 -> 발발밦따따망히
151 -> 밗받밝빠따따다망히
152 -> 박밗밣밞따다따망히
153 -> 밞밣밞다따망히
154 -> 박밝박밞다따따망히
155 -> 발받밗밝따다따망히
156 -> 박밦밗밞다따따망히
157 -> 밗밞밣밞다따다망히
158 -> 박밝밣밞따다따망히
159 -> 받밗밝빠따다따망히
160 -> 밗발밣따따망히
161 -> 밝박받밝따다따망히
162 -> 박밞빠따따망히
163 -> 받밗발밣따따다망히
164 -> 밗발밗밞따다따망히
165 -> 받발박밞다따따망히
166 -> 박박밞빠따다따망히
167 -> 발박밞빠따따다망히
168 -> 받밝밣따따망히
169 -> 밗밞다빠따망히
170 -> 박발밣밞다따따망히
171 -> 받받밦밞따다따망히
172 -> 박발밞빠따다따망히
173 -> 밗밗밞다빠따다망히
174 -> 박밦밞빠따다따망히
175 -> 발발밝따따망히
176 -> 박밣박밞다따따망히
177 -> 받받밝밣따다따망히
178 -> 박밣밞빠따다따망히
179 -> 밗발발밝따따다망히
180 -> 밗발밞따따망히
181 -> 밦발발밝따따다망히
182 -> 박밝밗밞다따따망히
183 -> 받발밝밣따다따망히
184 -> 밗밗밦밝따다따망히
185 -> 발박발밝따다따망히
186 -> 받밦밝밣따다따망히
187 -> 박밞다밣밞다따망히
188 -> 밗박발밞따다따망히
189 -> 받밝밞따따망히
190 -> 발박밗밞따다따망히
191 -> 박받밝밞따따다망히
192 -> 받밣빠따따망히
193 -> 밗받밝밞따따다망히
194 -> 박받밣빠따따다망히
195 -> 받발밗밞다따따망히
196 -> 밗밝빠따따망히
197 -> 발받밣빠따따다망히
198 -> 박밞박밞다따따망히
199 -> 받밗밝빠따따다망히
200 -> 발발밣따따망히

The lowest number that improves with 타 is 211, with 받밣밞따따발타 (3*8*9-5) beating out 발밠밝따따반반나다 (5*6*7+2/2).
The next lowest, 239 (받밞빠따따밗타=3*9*9-4), didn't require 반반나 in its 다/따-only construction (받밣밞따밝다따박다=3*(8*9+7)+2).
An earlier version of this program generated 다/따-only constructions.

With 밯=-1 (score unchanged)
g@n_:=f@n<>"망히"
f@n_:=f@n=Switch[n,1,"밯",9,"밞",8,"밣",7,"밝",6,"밦",5,"발",4,"밗",3,"받",2,"박",
_,mn@{m@n,a@n,s@n}]
m@n_:=m@n=f@#<>If[# #==n,"빠",f[n/#]]<>"따"&/@Select[Divisors@n,1<# #<=n&]//mn
a@n_:=a@n=f@#<>f[n-#]<>If[#==1,"타","다"]&/@Range[⌈n/2⌉-1]//mn
s@n_:=s@n=m[n+#]<>f@#<>If[#==1,"다","타"]&/@Range[n-1]//mn
mn=First@*MinimalBy[StringLength[""<>#]&]

Try it online!
If the program is given no input, 밯 (read a character from input) returns -1, which allows for a one-character 1 literal.
The lowest number that benefits from this is 269, which improves to 발밦밞따따밯다 (5*6*9+(-1)) from 박받밣밞빠따다따다 (2+3*(8+9*9)).

Whow... I actually never expected someone answer to this, because linked question has only one answer, and answer from asker himself/herself. Great one! But, 밯 is actually 'get one character from input', not -1.

I found bug : 밗밗밠밝따다따망히(output for 184) actually prints 212. It is 4 4 7 7 * + * or (7 * 7 + 4) * 4. ㄽ is 7, not 6. ㅄ is 6.

@LegenDUST Oops. Should be fixed. Given no input, 밯 should be functionally identical to -1, though.

You also use ㅃ (duplicate).

I know 밯 give -1, but not every implement gives it. clever, though.


text:
Parsing text written the millitext font
Reading the text of the millitext font
There is a font here that fits each character into a single, 1x5 pixel block. It does this (assuming you're using an LCD screen) by using the RGB channels of each pixel to expand the one pixel into three subcolumns, one for each channel. Your task is to take in a string of text encoded in this font and 'decode' it.
Millitext Alphabet
CHARACTER: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
ENCODING:  WYWBMRRMMMWYWYWWWMWBMRMYGYGYCWMMMMMW
           MGBWMRRMMMMMRMRRRMGBMRWMMMMMRGMMMMMB
           MGWWWWWBWWWYRMWWMWGBYRWMMYMYGGMMWGGG
           MGRBBBMBMBMMRMRRMMGBMRMMMRWMBGMCWMGR
           WWWWBWWBWWMYWYWRWMWWMWMMGRCMYGWBMMGW

I've abbreviated each color to a one character symbol (R=red, G=green, B=blue, C=cyan, Y=yellow, M=magenta, W=white).
Input Format
The input format for this is pretty open. You can have the input be an array containing each column, an array containing each row, a char[][], or anything like that. You can also choose to use the full words "red", "green", "blue", with uppercase/lowercase of your choice (but it must be consistent for each word! You cannot use "RED" and also do "green" or "Blue").
If your language happens to support it, you can also have input be colors (however that might work, I don't know off-hand).
You can assume that the input will ONLY contain encoded characters in the alphabet above (in particular, there will be no spaces or punctuation in your output).
Output Format
You can either output a string or some sort of character array. You can chose whether the letters are uppercase or lowercase, but they must all have the same case.
Example
MWRRGMGYRY
MRRRMMMMRM
WWRRMWMYRM -> HELLOWORLD
MRRRMWMMRM
MWWWGMGMWY

Rules
This is code-golf, so shortest answer wins!
Test set
WMWGMWWMYYGMYWGMBMMYWYGMWYWMWRWWMYGW
GMRMMGRMMMMMMRMMBMWMRMMMRMGMRRMBMMMR
GWWMMGRYYYMWMWMGBMWYWMMMWYGWWRWGGMMM -> THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOG
GMRWMGRMMMMWMRMMBMMRRMMCRMGMRRMRGMMM
GMWCWWWMYMGMMRGMWWMRWYGBWMGMWWMWGYGW

I feel like you either hardcode all letters or use a Mathematica builtin here.

Thanks for that @Arnauld, guess it didn't like it when I copied my test case

Nice first challenge, BTW!

Your 8 is wrongly encoded as MMWMW instead of WMWMW. Same for 9 (top is M instead of W). This has likely caused answers using the wrong encoding as well.

Here is the fixed font (several other characters are wrong).

I don't know if you wanted your test set to include all letters from the English alphabet or not, but if son that's called a pangram and "THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOG" isn't one as its missing an "S", if you wanted it to be it should be "THEQUICKBROWNFOXJUMPESOVERTHELAZYDOG"

Is it possibile to take a matrix of ASCII code points instead of the characters M,W etc (e.g.  M = 77, W = 87 etc) ?

@MindSwipe small correction: "JUMPES" is not a word, but you could use "DOGS" (sadly, one character longer, 37).  Personally, I like "Jackdaws love my big sphinx of quartz", at 31 letters.

@JonofAllTrades JUMPS is a possibility.And you can lose two characters by changing one of the THEs for A.

JavaScript (ES6),  103 100 93 92  90 bytes
Saved 9 bytes thanks to @ShieruAsakoto
Takes input as an array of columns. Returns an array of characters.
a=>a.map(s=>"H-L-D--VGQ87MR6TZ-KJ9WC05BUXF1YI2EON3S-A-P4"[parseInt(s,35)%1161%219%152%43])

Try it online!

@ShieruAsakoto Thanks! The multiplication was not a good idea. I saved 1 more byte with 3 mod's.

Those are some big modulos over there... maybe you can improve them more so the -s disappear! :D

After a whole night of brute-force I got a 90 with 4 mods: a=>a.map(s=>"H-L-D--VGQ87MR6TZ-KJ9WC05BUXF1YI2EON3S-A-P4"[parseInt(s,35)%1161%219%152%43]).

@ShieruAsakoto Unfortunately, the font described in the challenge is wrong. Waiting for a possible update from the OP.

@Arnauld For the fixed one my progress now is a 93: a=>a.map(s=>"UIR-L68N--W-X7B-FH-D-EZ--902-S4M5GJCQT3PKV-A1-YO"[parseInt(s,35)%464%107%99%52])

Jelly, 50 bytes
Oḅ⁹%211“ẎP\7ßɱðvs*Ḋ⁹UfRMJiẒVƑ).Z½Ƈ"}~ḌyH⁵Ŀ⁶Ṿ‘iⱮịØB

Try it online!
A monadic link accepting the input as a list of columns and outputting a Jelly string of the translation. Full explanation to follow, but relies on the fact that each possible set of 5 letters is unique when converted to code points, converted back from base-256 to decimal and then mod 211.
Alternative using Arnauld’s fixed font (49 bytes and using same principle.)
Explanation
O                   | Convert to code points
 ḅ⁹                 | Convert from base 256 to decimal
   %211             | Mod 211
       “Ẏ...Ṿ‘iⱮ    | Find indices in [209,80,92,55,21,162,24,118,115,42,193,137,85,102,82,77,74,105,189,86,146,41,46,90,10,144,34,125,126,173,121,72,133,199,134,186]
                ịØB | Index into 01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ

dzaima/APL, 80 79 73 72 71 bytes
' P  FL6BDEZQA SY574H TVOK J 08  M  U IC92XW 3G1RN'⊇⍨52|8965|2411⊥¨⎕ucs

Try it online!

what special features does your APL have?

@Jonah Here the only used thing is ⊇ (similar to {⍵[⍺]}), other than that, these two files contain info about it

05AB1E, 45 44 bytes
40ö98%•Wþ@»Ý¢a:µ@,–çòßuÒ¹₃©6µć‚FVÝ∊J?•2ôžLR‡

Try it online!
Takes input as array of columns, and outputs an array of characters.
Explanation:
40ö                       # convert each column from base 40
   98%                    # modulo 98
      •...•2ô             # compressed array: [20, 32, 82, 30, 27, 28, 76, 89, 46, 96, 36, 4, 18, 12, 80, 75, 50, 86, 42, 2, 52, 92, 48, 0, 84, 1, 88, 90, 10, 26, 70, 41, 94, 64, 14, 60]
             žLR          # built-in array 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
                ‡         # transliterate

R, 143 128 bytes
function(v)c(0:9,LETTERS)[match(colSums((sapply(v,U<-utf8ToInt)*194:198)%%45:41),U("#</Eb=,n9J.M4Z+%*V N[Hd\\B?1Oj>KgRYT2")+34)]

Try it online!
Function taking a vector of strings (corresponding to the columns) as input e.g. :
MWRRG
MRRRM
WWRRM -> c('MMWMM','WRWRW','RRRRW','RRRRW','GMMMG') -> HELLO
MRRRM
MWWWG

Explanation :
Performing the following operation for each encoded string (e.g 'CRGBY' = 'S') :
        TO ASCII      MULTIPLICATION             MODULO              SUM &              TO
        CODEPOINT                                                    OFFSET             ASCII
---------------------------------------------------------------------------------------------

'C'        67        67 * 194 = 12998       12998 %% 45 = 38  \
'R'        82        82 * 195 = 15990       15990 %% 44 = 18  |
'G'  --->  71  --->  71 * 196 = 13916  ---> 13916 %% 43 = 27  |---> (140 - 34) = 106 ---> 'j'
'B'        66        66 * 197 = 13002       13002 %% 42 = 24  |
'Y'        89        89 * 198 = 17622       17622 %% 41 = 33  /

we obtain the following string '#</Eb=,n9J.M4Z+%*V N[Hd\B?1Oj>KgRYT2' where each character corresponds to '0123456789ABCDEFGHIJKLMNOPQR'.
So, the code performs the described operations on the input strings, then searches their correspondences inside '#</Eb=,n9J.M4Z+%*V N[Hd\B?1Oj>KgRYT2' obtaining the positions in string '0123456789ABCDEFGHIJKLMNOPQR'.

This looks clever but it’s not clear how to use the code: What shall I pass to the function? Both a list of character vectors and a plain vector fail with “non-conformable argument”. So does a character matrix.

@KonradRudolph: added a minimal explanation of the input (and changed the TIO in order to be more explicit). As soon as I can I'll add an explanation of the code, which I'm sure can be improved by finding an other "hashing" function for the strings returning values in the ASCII range instead of unicode...

@digEmAll yeah I've been playing with modding down the digits to a more reasonable range of distinct characters but nothing yet

@digEmAll Ah that works (I had the data as col-major rather than row-major) but your example results in “HEKKN”, not “HELLO”. I’m very confused that it appears to work on TIO. Different (non-UTF-8) encoding, I guess.

@KonradRudolph: yeah, probably. Consider that there's also a not-printable character among them (ASCII=1) so maybe copying-pasting from TIO doesn't work well...

@KonradRudolph: added a brief explanation (and found a shorter code) ;)

Charcoal, 66 bytes
ＷＳ§”*&_⟲⎇4>υ≧Y⪪ml^π≕t.A；p↶⧴q⊗Ｈε‖r¡¡ºÞd⸿σＣ⁺⮌”﹪﹪﹪⍘ιWMYCBGR³⁶⁰¦¹¹³¦⁷¹

Try it online! Link is to verbose version of code. Takes input as a list of columns terminated with a blank line. Explanation:
ＷＳ

Input strings until one is blank.
§”*&_⟲⎇4>υ≧Y⪪ml^π≕t.A；p↶⧴q⊗Ｈε‖r¡¡ºÞd⸿σＣ⁺⮌”

Cyclically index into the string OV EX8HSCF5IA L TG  17 M P9RB 4  K ZY2 0JW   63Q ND   U which (with trailing space) is 56 characters long.
﹪﹪﹪⍘ιWMYCBGR³⁶⁰¦¹¹³¦⁷¹

Perform base-7 conversion using the alphabet WMYCBGR and then reduce successively modulo 360, 113, 71, and 56 implicitly via the cyclic indexing.
My base 7 approach fared really badly with @Arnauld's fixed font; after some searching I was still at 73 bytes. Using @Grimy's approach cut this down to 67 bytes. However I eventually tracked down a 66 byte solution:
ＷＳ§”*&″ÀＭ↔↓<Ｊ;×⊟ςF,Ｇηe↖ητγ´ＷＩＹ³﹪▶⟧9?δc⁶ＡxDê↷hＰiψ”﹪﹪﹪⍘ι⁴⁷¦²³⁷¦⁷³¦⁶⁷

Try it online! Link is to verbose version of code. Explanation:
ＷＳ

Input strings until one is blank.
§”*&″ÀＭ↔↓<Ｊ;×⊟ςF,Ｇηe↖ητγ´ＷＩＹ³﹪▶⟧9?δc⁶ＡxDê↷hＰiψ”

Cyclically index into the string ID HAM178 VS4F 3R EP6CQ  Z UB O 0  X  9     G     5TNJKL2Y    W which is 63 characters long.
﹪﹪﹪⍘ι⁴⁷¦²³⁷¦⁷³¦⁶⁷

Perform base-47 conversion using the alphabet 0-9A-Za-k and then reduce successively modulo 237, 73, 67, and 63 implicitly via the cyclic indexing.

CJam (63 bytes)
{{Gb"õáÖÅ{a("{i%}/"@/Ö´çýß}yùÜÅ©GôÉç¢"256b43b'0f+=}%}

or in xxd format
0000000: 7b7b 4762 22f5 e1d6 c59f 7b61 2822 7b69  {{Gb".....{a("{i
0000010: 257d 2f22 0b8a 8340 982f d6b4 e793 fddf  %}/"...@./......
0000020: 7d79 f9dc c519 17a9 0e47 0ef4 c9e7 a222  }y.......G....."
0000030: 3235 3662 3433 6227 3066 2b3d 7d25 7d    256b43b'0f+=}%}

This is an anonymous block (function) which expects input as a list of columns. Online demo.
As many of the other answers, this does a base conversion followed by a chain of % to get a short lookup table. In this case I use base 16 and % chain [245 225 214 197 159 123 97 40].

Jelly, 48 bytes
OḌ%⁽qƥ%⁹%53“ð×⁼ẎėWWæ¤jḌṛ>÷ƭÑṙsṛḌz0Ġọµḷ’b51¤iⱮịØB

A monadic Link accepting a list of lists of uppercase characters (each being a column) which yields a list of characters.
Try it online!
How?
OḌ%⁽qƥ%⁹%53“...’b51¤iⱮịØB - Link: columns
O                         - ordinals
 Ḍ                        - convert from base ten
  %⁽qƥ                    - modulo 29415
      %⁹                  - modulo 256
        %53               - modulo 53
                    iⱮ    - map with first index of x in:
                   ¤      -   nilad followed by link(s) as a nilad:
           “...’          -     22270425059867513817410846141176204460122938458128124185752719
                b         -     convert to base
                 51       -       51
                          -     ... = [38,13,19,27,10,16,20,11,35,31,4,17,9,0,50,45,24,25,34,39,22,29,41,32,3,7,46,5,48,18,6,44,28,14,1,8]
                      ị   - index into
                       ØB -   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

Ruby, 109 bytes
->n{n.map{|i|"6&\278$Cc\17Y9\23T\r]{v^Ox\16_+!Qj\fbH
hraD*Ap".index((i.to_i(36)%245%119+8).chr).to_s(36)}*""}

Try it online!

Stax, 46 bytes
é►^njÖ_╪»Θîq╪↨δXû=▀úæ5?ªoéV╫╫╩ßH‼╒C═e┼$⌠°JqUu⌡

Run and debug it
Each column is decoded as base-36.  Successive modulus of 8273, then 95 are applied.  This yields a unique number, looked up in a fixed string.
It takes input exactly in the format specified in the examples, and has to transpose them to get columns.  I will be able to save some bytes by using some different input format, which I may do at some point.


text:
Alphabet without the alphabet
You are tasked with displaying the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ" and only that, except for trailing newlines if they're unavoidable.
You must not output any homoglyphic characters like Cyrillic A. You can use non-Unicode encodings, but just to be sure, only output the Latin letters.
Regardless of the encoding you pick, you must not use the characters from U+0041 to U+005A or from U+0061 to U+007A in your source.
No other cheats or loopholes are allowed.
This is a code golf challenge, so the shortest answer wins. However, I won't pick a winner answer since the shortest answer might change over time.

Can you specify forbidden unicode ranges? Your definition is not really clear; "lookalike" isn't a good criteria (is Æ allowed?)

I can almost do this in Runic, the problem is that I need the k command to convert numbers to characters. Alternatives? w and E. :(

I have used ASCII compatible PETSCII for my answer as unicode wasn't a thing back in 1977 when the Commodore PET set this standard for all proceeding 8-bit Commodore computers.

Only I had already VTCed as unclear before the exact Unicode ranges were added, I would dupe hammer this in favour of https://codegolf.stackexchange.com/q/105781/58974

brainfuck, 35 bytes
+++++++++++++[>++>+++++<<-]>[>.+<-]

Try it online!
This is the first language I thought of because it is really good for no-letter no-number challenges lol.

C64Mini/C64 BASIC (and other Commodore/CBM BASIC variants) 24 BASIC tokenized bytes used
In order to meet the criteria of "Regardless of the encoding you pick, you must not use the characters from U+0041 to U+005A or from U+0061 to U+007A in your source" (even though Unicode isn't a thing on the Commodore 64), you must enter this in "reverse mode" [REVS ON] by pressing CTRL or Control (or the equivalent on your emulator) and 9.
In the screen shot, the screen codes for each character in my program is displayed after running it as I have read the memory from the start of screen RAM (top-left) (at 0x0400 or 1024) + 31 characters
 0FORI=65TO90:?CHR$(I);:NEXT

Simply starts from the 8-bit PETSCII A through to Z printing the character code with the CHR$ command source

Doesn't this use letters...? Doesn't really matter because it's a duplicate challenge but still.

I thought the question was unclear actually if you read it. I read through carefully a few times and it's not clear to me anyway

Yeah, it is really unclear. Not using letters did seem to be a clear requirement though, unless I misinterpreted that as well. The other thing about lookalike characters made zero sense though.

"Regardless of the encoding you pick, you must not use the characters from U+0041 to U+005A or from U+0061 to U+007A in your source." - Unicode isn't a thing on the C64, it uses the PETSCII standard.

Oh hm. Well, ok then lol. Yeah this challenge ended up being more vaguely defined than it used to be somehow...

To make sure, I have used CBM REVS ON when I entered the listing, the characters used are shown in the screen grab.