text:
Make a Lost Compass
Lost is a 2-Dimensional programming language where the instruction pointer starts at a random location, moving in a random direction.  A description of the language can be found at the bottom of the post for completeness' sake and a tutorial for the language can be found in the above link.
The task here is simple to describe: Write a non-empty lost program which when run will output the direction that was selected at the beginning of execution.
The four directions are:

N for north
E for east
S for south
W for west

You may output them with any capitalization you please and with an optional trailing newline.
Description
Lost operates on a grid where each instruction is a character of the source.  Lost's instruction pointer (ip) moves through the grid in one of the four cardinal directions.  When it goes off one side of the grid it wraps around to the other as if the program were written on a torus.
Lost's memory is stored in a main stack and a scope. Both are stacks padded with zeros at the bottom. At the end of execution the contents of the main stack are printed and the scope discarded.  Lost also stores a single value called the "safety", which begins on.
Programs can only terminate when the safety is off.
Doors

[ Reflects the ip if it is moving east; becomes ] if the ip is moving horizontally
] Reflects the ip if it is moving west; becomes [ if the ip is moving horizontally

Jumps

! Skips the next operation
? Pops off the top of the stack and jumps if not zero

Stack manipulation

: Duplicates the top of the stack
$ Swaps the top two items of the stack
( Pops from the stack and pushes to the scope
) Pops from the scope and pushes to the stack

Literals

0-9 pushes n to the top of the stack
" Starts and ends a string literal.  During a string literal commands are not run and instead their character values are pushed to the stack.

Operations

+ Adds the top two numbers
* Multiplies the top two numbers
- Multiplies the top by -1

Control

% Turns the safety off
# Turns the safety on
@ Ends execution if the safety is off (starts on)

The following operations are present in Lost but cannot be used for this challenge, since doing so instantly makes the challenge impossible.

\ Swaps the x and y directions
/ Swaps the x and y directions and multiplies them by -1
| Multiplies the horizontal direction by -1
> Tells the ip to move east
< Tells the ip to move west
v Tells the ip to move south
^ Tells the ip to move north

Does a Lost program have to be a rectangle? Do the unused spaces still count as bytes?

Here's a verifier that people can use to test their code

@xnor Unused spaces only count if they is a used space after them in the same row.  Other unused spaces will be padded automatically by the interpreter and do not need to be counted.

1749 1533 bytes
%(6.99*+@+6*97(((((%#%%%%%%%#%%#%%%%%
%(((((99*6+@+*976((%%(((((((%((%(((((
%((699*+@+6*97(((((%((((((((((((((((((((
%(((((99*6+@+*976((%2(2(2(2(2(2(2(2(2(2(
%((699*+@+6*97(((((%9(9(9(9(9(9(9(9(9(9(
%(((((99*6+@+*976((%9(9(9(9(9(9(9(9(9(9(
%((699*+@+6*97(((((%*9*9*9*9*9*9*9*9*9*9
%(((((99*6+@+*976((%+9+9+9+9+9+9+9+9+9+9
#%(699*+@+6*97((((%#@*@*@*@*@*@*@*@*@*@*
%(((((99*6+@+*976((%+2+2+2+2+2+2+2+2+2+2
%((699*+@+6*97(((((%6+6+6+6+6+6+6+6+6+6+
(#%(((99*6+@+*976(%#*@*@*@*@*@*@*@*@*@*@
%((699*+@+6*97(((((%8+8+8+8+8+8+8+8+8+8+
(%((((99*6+@+*976((%9*9*9*9*9*9*9*9*9*9*
%((699*+@+6*97(((((%(8(8(8(8(8(8(8(8(8(8
(((%((99*6+@+*976((%(9(9(9(9(9(9(9(9(9(9
(((699*+@+6*97(((((%(6(6(6(6(6(6(6(6(6(6
2(((((99*6+@+*976((%((((((((((((((((
((69.9*+@+6*97(((((%((((((((%((%((
%(((%(99*6+@+*976((%%%%%%%%%#%%#
+6.*97%%#%%#%%%%%%%((((699*+@
*976((((%((%((((((((%(((((99*6+@+
((((((((((((((((((((%((699*+@+6*97(
2(2(2(2(2(2(2(2(2(2(%(((((99*6+@+*976(
9(9(9(9(9(9(9(9(9(9(%((699*+@+6*97(((
9(9(9(9(9(9(9(9(9(9(%(((((99*6+@+*976(
*9*9*9*9*9*9*9*9*9*9%((699*+@+6*97(((
+9+9+9+9+9+9+9+9+9+9%(((((99*6+@+*976(%
@*@*@*@*@*@*@*@*@*@*#%(699*+@+6*97(((%#
+2+2+2+2+2+2+2+2+2+2%(((((99*6+@+*976((%
6+6+6+6+6+6+6+6+6+6+%((699*+@+6*97(((
*@*@*@*@*@*@*@*@*@*@#%((((99*6+@+*976(%#
8+8+8+8+8+8+8+8+8+8+%((699*+@+6*97(((
9*9*9*9*9*9*9*9*9*9*%(((((99*6+@+*976((%
(8(8(8(8(8(8(8(8(8(8%((699*+@+6*97(((
(9(9(9(9(9(9(9(9(9(9%(((((99*6+@+*976
(6(6(6(6(6(6(6(6(6(6%((699*+@+6*97((
6(((((((((((((((((((%(((((99*6+@+*97
7.9(((((%((%((((((((#%(699*+@+6*
+*976%(%#((#%(9.9*6+@

Try it online! Verify it!
This works similarly to the one posted in chat, with a shorter execution part and some extra stuff trimmed off the right edge. I've golfed about a hundred bytes off the edges, but perhaps I should look for a shorter inner section before that.
Here is a formatter that takes a few lines and formats them in this square, though some minor edits to the lines/columns with @s in them are necessary to get it actually working.

504 503 bytes
+6*9+ 18((%(( 77*54*+@
6*9+-09((%(( 99*54*+@+
*9+ 18((%(( 77*54*+@+6
9+-09((%(( 99*54*+@+6*
+ 18((%(( 77*54*+@+6*9
-09((%(( 99*54*+@+6*9+
18((%(( 77*54*+@+6*9+
9((%(( 99*54*+@+6*9+-0
((%(( 77*54*+@+6*9+ 18
(%(( 99*54*+@+6*9+-09(
%(( 77*54*+@+6*9+ 18((
(( 99*54*+@+6*9+-09((%
( 77*54*+@+6*9+ 18((%(
 99*54*+@+6*9+-09((%((
77*54*+@+6*9+ 18((%((
9*54*+@+6*9+-09((%(( 9
*54*+@+6*9+ 18((%(( 77
54*+@+6*9+-09((%(( 99*
4*+@+6*9+ 18((%(( 77*5
*+@+6*9+-09((%(( 99*54
+@+6*9+ 18((%(( 77*54*
@+6*9+-09((%(( 99*54*+

Try it online!
After a % is reached, switching off the safety, there are enough (s to empty the stack. Next:
Going east:  99*54*+@  produces 101 (e)
             77*54*+@  produces  69 (E)
Going south: 97*54*+@  produces  83 (S)
             79*54*+@  produces  83 (S)
Going west:  90-+9*6+@ produces  87 (W)
             81 +9*6+@ produces  87 (W)
Going north: 91-+9*6+@ produces  78 (N)
             80 +9*6+@ produces  78 (N)

-1 by removing one (, allowing one more line to be one byte shorter.


text:
Fill the Golfeek gutter
Golfeek is the working name of an esolang I'm occasionally working on. One distinctive feature of this language is that each statement is encoded as a sequence of bits rather than a sequence of bytes.
Instead of just showing a long binary sequence, the 'gutter' of the source editor contains a representation of each statement in a more digest and (slightly) more readable format:

Format

The binary sequence is always read from left to right.
It is first split into nibbles (groups of 4 bits) shown as uppercase hexadecimal between brackets. A space is inserted after each byte, provided that it's followed by another byte or a last lone nibble.
Example:
[1,1,1,1,0,0,0,0,1,0,1,0] --> "[F0 A]"
 \_____/ \_____/ \_____/

If there are more than 14 nibbles, only the first 6 bytes are shown, followed by a space, followed by .., followed by the closing bracket.
If the number of bits is not a multiple of 4, the remaining bit(s) is/are appended as '0' or '1' right after the closing bracket.
Example:
[0,1,1,1,1,0,0,1,0,1] --> "[79]01"
 \_____/ \_____/ \_/

Your task
Given a sequence of bits, return its representation in Golfeek format.
Rules

The sequence of bits may be taken in any reasonable and non-ambiguous format. Please note that the sequence may contain leading zeros, which your format must be able to deal with.
You can assume that there will always be at least 4 bits in the input sequence, and therefore at least one nibble between the brackets.
The output must be a string (or a list of characters) that conforms exactly to the format described above, with uppercase hexadecimal and correct spacing. A trailing linefeed is optional.
This is code-golf.

Test cases
Input
0101
00001
110101
10100111
101001111100
000000000000000
011110101101001110010011000111
11011110101011011011111011101111
11110101000110000001111011001110011100100110111000100000100
111101010001100000011110110011100111001001101110001000001001
1111010100011000000111101100111001110010011011100010000010010

Output
[5]
[0]1
[D]01
[A7]
[A7 C]
[00 0]000
[7A D3 93 1]11
[DE AD BE EF]
[F5 18 1E CE 72 6E 20]100
[F5 18 1E CE 72 6E ..]
[F5 18 1E CE 72 6E ..]0

05AB1E, 36 34 33 31 bytes
Ć4ô¤¨s¨Ch2ôJDg8@i6∍„..ª}ðý"[ÿ]ÿ

Try it online!

Retina 0.8.2, 112 111 bytes
.{4}
$&
(.+)
[$1]
T`d`L`.*]
B
AB
+`BA
ABB
A+(B*)
$.1
T`d`L`1\d(?=.*])
B(.)
$1
T` `_`\w..
(\[.{18})...+]
$1..]

Try it online! Link includes test cases. Edit: Saved 1 byte thanks to @Grimmy. Explanation:
.{4}
$&

Group the nibbles.
(.+)
[$1]

Bracket the nibbles.
T`d`L`.*]

Change the bits used by the nibbles from 01 to AB to distinguish them from the spare bits.
B
AB
+`BA
ABB

Convert from binary to unary.
A+(B*)
$.1

Convert from unary to decimal.
T`d`L`1\d(?=.*])
B(.)
$1

Convert 10-15 from decimal to hexadecimal.
T` `_`\w..

Group pairs of nibbles into bytes.
(\[.{18})...+]
$1..]

Truncate the output if there are more than 14 nibbles.

When converting 10-15 to A-F, \d\d can be 1\d to save a byte: TIO.

Jelly, 35 bytes
s4µLÐṀ©s14Ḅ‘ịØHUḢaȧ⁾..$ƊUs2KØ[j;ḟ®F

A full program which, given a list format of 1s and 0s, prints the result.
Try it online! Or see the test-suite.

JavaScript (Node.js), 129 124 113 bytes
-5 thanks @tsh
11 more thanks @Arnauld
s=>'['+s.replace(/..../g,(x,i)=>(i<56?"9ABCDEF."[x=!s[59]|i<48?"0b"+x-9:7]||x+9:"")+(s[i+7]?i&4&&x-7?' ':'':']'))

Try it online!

Perl 5 (-p), 91, 89 bytes
-2 bytes thanks to Xcali++
s/.{4}/sprintf"%X",oct"0b$&"/eg;$\=$';s/$\$//;s-.{12}\K...+-..-;s-..(?=.)-$& -g;$_="[$_]"

Try it online!

Using $\  instead of $x would allow the last statement to be $_="[$_]", saving 2 bytes.  This, however, would only allow it to process one input per run legibly.

Red, 208 bytes
func[s][r: :rejoin b: parse s[collect[any[keep[4 skip]]copy t to end]]forall
b[b/1: pick form debase/base r["0000"b/1]2 4]b: collect[foreach[x y]b[keep
r[x any[y""]]]]if b/8[clear at b 8 b/7:".."]r["["b"]"t]]

Try it online!

Charcoal, 50 bytes
[≔⪪Ｓ⁴θＦ›⁴Ｌ§θ±¹≔⊟θω≔⪫⪪↥⭆θ⍘↨²ι¹⁶¦² θ⎇‹²⁰Ｌθ⁺…θ¹⁸..θ]ω

Try it online! Link is to verbose version of code.
[

Output the opening [.
≔⪪Ｓ⁴θ

Split the input into nibbles.
Ｆ›⁴Ｌ§θ±¹≔⊟θω

Save the last slice if it's not a whole nibble.
≔⪫⪪↥⭆θ⍘↨²ι¹⁶¦² θ

Convert each nibble into uppercase base 16, joining with alternate spaces.
⎇‹²⁰Ｌθ⁺…θ¹⁸..θ

If the resulting string is greater than 20 characters then truncate it to 18 and add .. otherwise output the string.
]

Output the closing ].
ω

Output any left-over bits.

Japt, 50 bytes
ò4
jJUÌÊ¦4
®n2G uÃò mq
"[]"i1WjT7 ¸h18WÊ?"..":P)+V

Try it
ò4            (Input as a string) partitioned on each 4 bits.

jJ             V = get n elements from last index and remove them
  UÌÊ¦4        n = is last element length != 4 ?

®n2G uÃò mq           Convert each nibble to base 16,
     uÃ        to uppercase,
       ò mq    and join each pair.

"[]"i1         Inserts between squares :
      WjT7      first 7 elements(removing them),
           ¸    joined with space.
h18             Then replace characters at index 18 with :
   WÊ?".."       '..' if not empty
          :P     else empty string.
)+V           Finally appends remaining bits and outputs implicitly.

C (gcc), 194 181 191 190 bytes
Thanks to ceilingcat (-14 bytes) for the suggestions. Fixed an edge case (+10 bytes).
The function takes the input string and builds up byte-sized representations a nibble at a time, outputting the results until the sixth byte, and changing the [ to a space after the first byte output (if there is one). The buffer is reset after each output.
After the sixth byte, nothing is output until the entire string is processed, but if the length exceeds 59 bytes (7 bytes + 3 bits), the stored representation changes to .., which is then output at the end. Excess bits that don't fit in a nibble are printed from the end of the input string. There is an edge case that I had to specifically check for, which is an input between 49 and 51 bytes (6 bytes + 3 bits), as an extra space would normally get printed before the ending bracket.
c,t;f(char*s){char u[4]="[";for(t=c=0;*s;c++>58?u[1]=u[2]=46:0)t+=t+*s++-48,c%4>2?u[c%8/4+1]=t+48+7*(t>9),t=0:0,c%8>6&c<48?printf(u),*(int*)u=32:0;printf("%s]%s",u+(c%8<1|c-48U<4),s---c%4);}

Try it online!

189 bytes

Burlesque, 48 bytes
4co{L[4.<}ptl_FLjb2b62co)++sa7.>{6.+".."[+}if+]Q

Try it online!
4co       #Split into nibbles
{L[4.<}pt #Partition into those whose lengths >4 and those <4
l_FL      #Take the remainder as a flat list
jb2b6     #Convert the main block into base 16 (via binary)
2co)++    #Join as pairs
sa7.>     #Length greater than 7
{
 6.+      #Take first 6 discarding remainder
 ".."[+   #Append ".."
}if       #If length > 6
+]        #Append remainder bits
Q         #Prettify

source: Stack Exchange

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

sort: votes


text:
Even and Odd Numbers
Sandbox
Adapted from exercise 4 of 100 little Keg exercises
The ability to repeat chunks of code within a program is an important part of any programming language. Also just as important is the ability to make decisions based on different values.
The Challenge
I want you to write a program that:

Starts at the number 0, and:
For each number from 0 to 100 (inclusive):
If the number is even, print the letter E (uppercase or lowercase)
Otherwise: print the number

Keeping in the spirit of this challenge, your source code must fit the pattern of having characters with an odd ordinal value followed by characters with an even ordinal value. Note that ordinal value is defined here as if I called python's ord() function on the character using your language's prefered code page. In other words, the code points of your program should be as such:
Odd Even Odd Even Odd Even ...

or
Even Odd Even Odd Even Odd ...

More concisely, the code points of your program must alternate between being odd and even.
Example Output
E 1 E 3 E 5 E 7 E 9 E 11 E 13 E 15 E 17 E 19 E 21 E 23 E 25 E 27 E 29 E 31 E 33 E 35 E 37 E 39 E 41 E 43 E 45 E 47 E 49 E 51 E 53 E 55 E 57 E 59 E 61 E 63 E 65 E 67 E 69 E 71 E 73 E 75 E 77 E 79 E 81 E 83 E 85 E 87 E 89 E 91 E 93 E 95 E 97 E 99 E

Output can be in any other convenient format with any other separator.
Leading and trailing whitespace is acceptable.
Script Validation (UTF-8 only)
Here is a Keg script to see if your program fits the parity pattern requirement
Note that this can only be used for languages that use utf-8 as their codepage.
Here is an alternate Haskell script written by @WheatWizard which can handle newlines and shows which characters are invalid.
Here is a Python Script that tells you where you need to insert extra characters. (As well as the binary codes and the ord code of the characters)
Scoring
This is code-golf so the answer with the fewest amount of bytes wins.
Let it be known that flags don't count towards being in the pattern. They also don't count towards byte count in this challenge.
Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=197210;
var OVERRIDE_USER=78850;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="
"+q.body.replace(OVERRIDE_REG,"")+"
")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery(""+n.language+"").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
  <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654">

Winners by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}

{{LANGUAGE}}	{{NAME}}	{{SIZE}}

You say "100 (inclusive)", but the sample output only goes up to 99

@cairdcoinheringaahing Fixed.

Why is this a decision problem?

@xnor because you have to decide if integers are odd or even.

... That's not what a [tag:decision-problem] is. Decision problems check whether the input meets a certain criteria and outputs based on that

Are we allowed to output a lowercase e instead of uppercase one? Also, are we allowed to output as a list (instead of a string so I could save on the additional join)?

It should be noted that the Keg script in the question only checks the first line if you input more than one.

Here is a version that handles bad lines and also highlights the wrong characters

I don't fully understand what the source restriction on this challenge is. Is it possible to explain it more clearly?

@Skoddie the code points of your program must alternate between being odd and even. I don't really see how that is hard to understand. Codepoints are the ordinal value of a character in an encoding (usually UTF-8). For example a space has the codepoint 32, which is even. Your code must alternate between odd and even, starting with either. This means that a lot of commonly used function names, like print, range or any of the same character in a row (&& or ||) cannot be used in your program, since they violate that rule

@JoKing That makes sense. That does disqualify languages that don't have alternatives to certain keywords. Oh well.

Python 3, 72 bytes
x="E";z= 1
while 	z	<101:	x=x+ ["E"	,	f' {z} ' ] [z%2] ;z=z+ 1
exit	(	x)

Try it online!
Just by coincidence, exit and while are both available. The rest is just the program separated by spaces and tabs to make it alternate.
I'm hoping it's forgivable to output as an exit code, since print is unavailable.

I'm perfectly happy with output being given as an exit code.

@Jono2906 Great, that's good!

Output as exit code is in the list of standard I/O

this isn't an "exit code", it's printed to stderr - but that's also valid by our rules

I was messing with your tio.run instance and I was able to shave several bytes off your code by removing tabs and it still worked.

@JoelTrauger Did it still met restricted source condition?

@valsaysReinstateMonica Oh I did not see that condition. I was wondering why it seemed too easy... Fortunately Python is forgiving of whitespace as long as certain code block constraints aren't violated.

JavaScript (ES6), 42 bytes
Contains a literal Tab.
f= y =>y>98? ' E ':' E ' + -~y +f   (1 -~y )

Try it online!

Ruby, 41 bytes
n= 1
eval'puts"E";p	n;n=n+2; '*50;puts"E"

Try it online! (with parity check)
This builds a string that contains the code to output "E" and n, then add 2 to n. Then it multiplies the string by 50 (repeating it 50 times) and evals it. Finally, it prints the last "E" at the end.

05AB1E, 15 11 9 bytes
т Ýxт>çÞ‡

-2 bytes thanks to @Grimmy.
Outputs as a list with lowercase e.
Try it online.
Explanation:
Shortest base version I could find was 8 7 bytes: тÝx'EÞ‡ (Outputs as a list with uppercase E.)
-1 byte thank to @Grimmy.
т        # Push 100
 Ý       # Pop and push a list in the range [0, 100]
  x      # Push a list with each value doubled (without popping the original list)
   'E   '# Push "E"
     Þ   # Pop and push an infinite list of "E": ["E","E","E",...]
      ‡  # Transliterate each doubled number to "E" in the original list
         # (after which this list is output implicitly as result)

The codepoints of this 7-byter are [15,221,120,39,69,222,135] / [1,1,0,1,1,0,], which is already pretty good.
So I now have this:
т          # Push 100
           # No-op space
  Ý        # Pop and push a list in the range [0, 100]
   x       # Push a list with each value doubled (without popping the original list)
    т      # Push 100
     >     # Increase it by 1 to 101
      ç    # Convert this integer to a character with this ASCII codepoint: "E"
       Þ   # Pop and push an infinite list of "e": ["e","e","e",...]
        ‡  # Transliterate each doubled number to "e" in the original list
           # (after which this list is output implicitly as result)

This 9-byter has the codepoints: [15,32,221,120,15,62,231,222,135] / [1,0,1,0,1,0,1,0,1].

Here's a shorter base: тÝx'EsǝJ. Also 8 bytes: тÝx'EÞ‡J.

Here's a 10 that complies with the source restriction but outputs lowercase es.

@Grimmy Nice. I've asked OP if a lowercase e (or an output as list) is allowed. I'll wait for his reaction before changing it. Thanks, though! :)

Lowercase is now allowed. Golf away!

@Jono2906 And my other question? Are we allowed to output as a list (i.e. ["E",1,"E",3,...] instead of a joined string?

The challenge already says it can be in any other convenient format so yes, you can.

Haskell, 112 105 99 bytes
The code produces a string as in the example.
[ c|s<-"E 1 E 3 E 5 E 7 E 9 E"	:[ ' ':k:m:' ':	"E"	|k<-"123456789"	,m<-"1 3 5 7 9"	,m>' ' ],c<- s ]

I was not able to find a way to print an integer or convert it to string. This is why the solutions looks like this.
Try it online!

MATL, 14 bytes
69H!Vo:E q"c@y

Try it online!
MATL uses ASCII encoding. The code points of the source code are
54  57  72  33  86 111  58  69  32 113  34  99  64 121

How it works
69    % Push 69. This is the code point of 'E'
H     % Push 2
!     % Transpose: does nothing to 2
V     % Convert to string: gives '2'
o     % Convert to double: gives code point of '2', which is 50
:     % Range. Gives [1 2 ... 50]
E     % Multiply each element by 2. Gives [2 4 ... 100]
      % (Space:) Does nothing
q     % Subtract 1 from each element. Gives [1 3 ... 99]
"     % For each k in [1 3 ... 99]
  c   %   Convert to char. In the first iteration the top of the stack contains 69,
      %   which is converted into 'E'. In subsequent iterations the top of the stack
      %   contains 'E', which is left as is
  @   %   Push current k
  y   %   Duplicate from below: pushes another copy of 'E'
      % End (implicit)
      % Display stack, botom to top (implicit)

C (gcc) with -trigraphs flag, 161 141 bytes
Thanks to WheatWizard for the validation script, which revealed that I mistakenly identified line endings as CR instead of LF! The fix didn't change the byte count, however.
To get this to even work, in addition to the many spaces and tabs, I used a macro that uses digraphs and token-pasting to generate the disallowed function names (main and printf). As Unix line endings are LF (decimal 10), I had to add a space at the end of the first line to continue the odd/even pattern. Saving some more space, I could coalesce in because the two letters fit the odd/even pattern.
Parity verification
#define y(a,c,g,i ) a %:%:c %:%:	 in%:%:g %:%:i
	b; y(m,a,	,	 )() {for	(; 	b	<101 ;b	 = 	b+ 1 ) y(	p	,	r	,	t	,	f)(	b%2?"%d	"	:	"E 	"	,	b) ; }

Try it online!

Pyth, 16 bytes
V101p? %N/T5NK\E

Try it online!
Verify it online!
Separated by ""
How it works:
V101p? %N/T5NK\E
V101                  - For 'N' in 0..100
     ? %N/T5        - If N modulo (10÷5) (or N%2) is truthy...
            N       - ...return N
             K\E    - Otherwise, return 'E' (K here is just a separator)
    p               - Print the result

Jelly, 13 bytes
³Ż¹⁾E Ḥ‘{$¦ K

Code-points: [131, 210, 129, 142, 69, 32, 175, 252, 123, 36, 5, 32, 75]
A full program, which given no arguments prints the result.
Try it online!
(As a bonus given a non-negative integer argument it will print the sequence for that number, e.g.)
How?
³Ż¹⁾E Ḥ‘{$¦ K - Main Link: no arguments
³             - literal 100 (if there are arguments provided, this is the 1st)
 Ż            - zero-range = [0,1,2,3,...,100]
  ¹           - identity (no-op)
          ¦   - sparse application...
         $    -   ...to indices: last two links as a monad:
      Ḥ       -      double = [0,2,4,6,...,200]
        {     -      use left argument as input to:
       ‘      -        increment = [1,3,5,7,...,201]
                     (note Jelly uses 1-based indexing)
   ⁾E.        -   ...what: literal character pair =  ['E', ' ']
           .  - no-op
            K - join with spaces
              - implicit, smashing print

R, 35 bytes
Thanks to ErikF for correcting a bug.
x=0	:{ 98+2} ;x[ c(	T	,!T) ] ="E";x

Try it online!
Defines x as the vector of integers from 0 to 100, then replaces all the even values with "E" and outputs x.
Previous, quite different version:
R, 42 bytes
for	(i in	 1:50) write(c(i*+2- 1,	"E"),1 )

Try it online!
Includes a few tabs instead of spaces. Uses newlines as separators.
cat and print are unusable, but luckily write is OK. I had to resort to i*+2 -1 instead of i*2-1 to keep the alternation.

Ahh right my bad

Python 3, 65 bytes
exit	([ ["E"	,	j] [j%2]for	j	 in	 eval	('ran' +"g"+"e")(101 ) ] )

Try it online!
This submission was built on using tabs and spaces, as well as a Very Clever™ abuse of eval.
Edit: Fixed program to adhere to restricted-source (I had an extra space by mistake).

Jelly, 18 bytes
ØA 5ị¶ 101Ḷ× Ḃ$oÑK

Try it online!
In the Jelly code page, these character have the byte values of
12 41 20 35 D8 7F 20 31 30 31 B2 11 20 BF 24 6F 10 4B

which follows the pattern Even Odd Even Odd ...
How it works
Removing the extra spaces we get:
ØA5ị
101Ḷ×Ḃ$oÑK

which is:
ØA5ị       - Helper link: Yield "E"
ØA         - Yield the upper case alphabet
  5ị       - Take the fifth element ("E")

101Ḷ×Ḃ$oÑK - Main link: Yield "E 1 E 3 ... E 99 E"
101        - Yield 101
   Ḷ       - Lowered range:            [0, 1, 2, ..., 99, 100]
     Ḃ$    - Take the parity of each:  [0, 1, 0, ..., 1, 0]
    ×      - Multiply each together:   [0, 1, 0, 3, ..., 99, 0]
        Ñ  - Call the helper link:     "E"
       o   - Replace the 0s with "E"s: ["E", 1, "E", ..., 99, "E"]
         K - Join with spaces:         "E 1 E 3 ... E 99 E"

Runic Enchantments, 32 bytes
>'D1+k$1:/$'D1+k$/2+:1.C(1+?.;8?
EOEOEOEOEOEOEOEOEOEOEOEOEOEOEOEO

Try it online!
EO sequence above just indicates whether each byte is even or odd.

GolfScript, 18 bytes
I didn't expect such a small amount of whitespace ...
101,{.3(%\"E"if} %

Try it online!
Explanation
101,               # Generate range [0 1 2 ... 99 100]
    {          } % # Map every item using this scheme
     .             # Copy the item
      3(%          # Modulo by 3-1 (2)
         \         # If modulo-ing by 2 is truthy: return the item
          "E"if    # Otherwise, return "E"

1{"E".2+}51*;; does what you did but 2 byes shorter (15, since the space before % isn't needed).

W z, 19 bytes
10#0#.a2m a&#"E"#|M

Pretty much the same as below. 100.a2ma&"E"|M The only difference is the 0-range (which does no good for the program).
W, 19 bytes
101 a2m"E"#&a 1 -|M

Explanation
Pretty simple: # and  are both readability characters here and have no result on the stack.
101a2m"E"&a1-|M

101           M % Foreach the range 1 -> 101
   a2m          % Modulo the current item by 2
      "E"&      % If true, return "E" (Because odd-1 -> even)
          a1-|  % Otherwise, return a-1

Japt, 15 bytes
ò#d_v) ?"E"):»Z

Test it
ò#d               range [0-100]
   _              passed through
    v) ?          divisible by 2?
        "E"):»Z   replace with 'E' else replace with number

Layout  : [242,35,100,95,118,41,32,63,98,69,98,41,58,187,90]

Haskell, 296 bytes
w = k 1
a(c:e ) = c
i =(id)
e a =(a:)
m 1 =(a"1")
m 3 =(a"3")
m 5 =(a"5")
m 7 =(a"7")
m 9 =(a"9")
m c|c<1 = '0'|c<3 = '2'|c<5 = '4'|c<7 = '6'|c<9 = '8'
m c =(m$c - 10)
q 1 =0;
q c|m c98= e(a"E")$e(a"9")$e(a"9")$i"E";
k c = e(a"E")$e(m$q c )$e(m c )$k$c +2

Try it online!
This was pretty hard since show and print are both unusable, so I had to convert integers to strings on my own.

Jelly, 15 bytes
101Ḷ¹⁾E Ḃ ?€Ḣ€K

Try it online! Try it online with parity!
A full program that takes no argument and prints the desired output. The footer demonstrates both the parity and result.

MathGolf, 20 bytes
"E"q♀{î♥☻/÷i¿{"E"}îq

Try it online!
Very similar to the FizzBuzz example. Uses the MathGolf codepage, can verify parity with this script.
"E"q                # Push and output "E"
    ♀               # Push 100
     {              # Loop from 1 to 100
      î             # Push loop counter
       ♥☻/          # Push 32, 16, and divide (basically pushes 2)
         ÷          # Is the loop counter divisible by 2?
          i         # Convert to integer (does nothing)
           ¿{"E"}   # If so, push "E"
                 î  # If not, push the loop counter
                  q # Output

Ruby, 50 bytes
Adaptation of the Python answer. Unlike Python, however, Ruby puts is valid code to use for output, eliminating the need for exit hacks.
I didn't want to do a direct port, but map, each, upto, and times are all forbidden by the spec...
x=0;(	puts ["E"	,	x] [x%2] ;x=x+ 1 ) while 	x	<101

Try it online!

PowerShell, 72 bytes
for`t(`t`$i =0;`$i -le 101 - 1 ;`$i =`$i + 1 ) {`$ab=(' e ',`t`$i ) ;`$ab[`$i %2] }

For testing:
$a = "for`t(`t`$i =0;`$i -le 101 - 1 ;`$i =`$i + 1 ) {`$ab=(' e ',`t`$i ) ;`$ab[`$i %2] }"

# Even/odd ok?
0..($a.Length-1) | % { [char]$a[$_] + "  " + ([byte][char]$a[$_] % 2)}
$a.Length

Invoke-Expression $a

Missed the even-odd part in the code, thanks for pointing it out!
Try It Online

Vyxal HM, 5 bytes
r⁽\EẆ

Try it Online!
This works in both the  Vyxal codepage and UTF-8. -2 thanks to pacman256.
The H flag can be removed if you place a ₁ at the start, although it only works with UTF-8 then.

5 bytes, works in vyxal and UTF-8

Pip, 16 bytes
1 +2	*	,50	JW"E"

Try it online!
Outputs without separators.
Spaces and tabs are no-ops, so this boils down to:
    ,50       Range(50)                                               0, 1, ..., 49
  2*          Multiply each by 2                                      0, 2, ..., 98
1+            Add 1                                                   1, 3, ..., 99
       JW"E"  Join with "E", wrapping the outside with "E"s as well   E1E3E...E99E

Charcoal, 24 18 bytes
Ｆ¹⁰¹«¿⊗﹪⊕ι²E↥Ｉ⌈ι⁰→

Try it online! Link is to verbose version of code. Here are the 18 hex codes in Charcoal's code page:
C6 B1 B0 B1 A8 BF 9E A5 9C E9 B2 45 18 C9 1A A9 B0 13

Explanation:
Ｆ¹⁰¹«

Loop from 0 to 100.
¿⊗﹪⊕ι²

Test whether the index is even. The index is incremented to comply with the source code restriction, which reverses the sense of the test. The result of the test is doubled to comply with the source code restriction, but this doesn't change the outcome of the decision.
E

If the number was even then output an E.
↥Ｉ⌈ι

Otherwise take the ceiling of the number to comply with the source code restriction, cast the result to string, and uppercase the result to comply with the source code restriction.
⁰

Print 0 -s to comply with the source code restriction.
→

Leave a space between successive outputs.
Note: If a trailing space is acceptable, then the last two characters can be replaced with a space for 17 bytes, although there are alternative solutions, such as this:
Ｆ¹⁰¹«¿⊗﹪⊕ι²E ⁺⌈ι

Try it online! Link is to verbose version of code. Here are the 17 hex codes in Charcoal's code page:
C6 B1 B0 B1 A8 BF 9E A5 9C E9 B2 45 20 AB 1A E9 20

Explanation: Much like the above, except that in the even case we directly include the space in the literal while in the odd case the ceiling of the number is concatenated with a space.

Zsh, 50 30 34 bytes
Bug fix: I was checking each pair of letters to make sure it had a character of each parity, instead of ensuring it alternated.
"e"cho E"	"{"1"'.'.9"9"'.'.'0'2} E

Try it online!
Try it online!
Try it online!
Self-tests. Contains a literal tab.
I couldn't figure out a way to finagle the most straightforward echo E\ {1..99..2} E into anything, mostly due to the double period. EDIT: I did it. Turns out in normal expressions, quotes inside brace ranges don't really matter.

Perl 5 + -p, 55 bytes
} {do {$_.=$- %2?$-.' ':q(E ) } while(+$- =$- + 1 )<101

Try it online!

Stax, 13 bytes
101rm2% _"E"?

Run and debug it
The program has these ASCII codes.
49 48 49 114 109 50 37 32 95 34 69 34 63

Ly, 36 34 bytes
"E"' _&s&o '2_R_r_p[:+,u>' _l_&o<]

Try it online!
At a high level, this one works like this...

print the initial E

generate the sequence 1..49

loops over that list printing the N*2-1 plus E

Here's the decimal codepoints for the source:
34 69 34 39 32 95 38 115 38 111 32 39 50 95 82 95 114 95 112 91 58 43 44 117 62 39 32 95 108 95 38 111 60 93

The code uses a couple of Ly specific tricks to achieve the even/odd sequence.  First spaces can be added most places and are ignored, which allows for an "even" no-op.  And _ (underscores) work as "odd" no-op's the same way.  Finally, quoting characters can be done using double quotes (even) or as a series of single characters after single quotes (odd).
And the gory details:
"E"'                               - push "E " on stack
     _&s                           - stash a copy of the stack
        &o                         - print "E "
         '2                        - push 50 on the stack
             _R                    - gen seq 0..49
               _r                  - reverse stack
                 _p                - pop 0 (first entry) off stack
                   [             ] - loop while stack not empty
                    :+,            - calc: <TOP>*2-1
                       u           - print as number
                        >          - switch to new stack
                         '         - push space
                           _l      - push "E " from stashed stack
                             _&o   - print stack
                                <  - switch back to original stack

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


text:
Decode ascii and reversed words sentence
In a challenge of CodingGame, there is a challenge that ask you to decode a string composed by reversed words ('Hello world' > 'olleH dlrow') then each characters converted into ascii value separeted by space:
>>> decode('111 108 108 101 72 32 100 108 114 111 119 32 41 58')
Hello world :)

The challenge is to be the fastest to write the decode function, but I later tried to write it with the fewest character possible.
Here is my result (104 characters):
def decode(m,s=' '):return s.join([w[::-1]for w in(''.join([chr(int(c))for c in m.split(s)]).split(s))])

The name of the function doesn't matter, it can be shorter, but only rename variable isn't good enough for an answer.
Is it possible to improve this result ?

Does the function have to be called decode? Is a specific version required? Can the output contain whitespace that isn't spaces, and if so, how should it be handled?

This part is obviously longer than a 'd' or something else, and does not required any knowledge, so I don't care (the "Take input from STDIN and output to STDOUT" part of the Jo King answer is pertinent). It must contain the ascii character '32'.

To clarify, is this challenge limited to only Python?  Also is I/O restricted to a function that takes as input an ASCII space character delimited string?  Not Default I/O methods?

This challenge is ok for default I/O method, but I'm new to this SE, sorry. I will edit the questions since all answer provide the default solution too. And thanks for the link about "default I/O methods!

Python 3, 75 bytes
lambda a:' '.join(''.join(map(chr,map(int,a.split())))[::-1].split()[::-1])

Try it online!
Python 3, 70 bytes
If taking input from STDIN and outputing to STDOUT is fine then it takes only 70 bytes this is mostly because the spread operator (*) is shorter than ' '.join()
print(*''.join(map(chr,map(int,input().split())))[::-1].split()[::-1])

Try it online!

Your solution in 70 bytes works, also, for your lambda in 75 is good too.

Use lambdas
def f(a,b):return c

can be shortened to
f=lambda a,b:c

(the f= can also be removed per CGCC site standards)
Remove excess []s
x.join([a for b in c])

can be
x.join(a for b in c)

since join can take a generator instead of a list
Split is on spaces by default
Thanks ElPedro for reminding me about this
So the split(' ')s can be shortened, which in turn means the s=' ' doesn't help (and it only broke even in the first place).
Take input from STDIN and output to STDOUT
print will automatically print arguments with space as a separator if you use * to unpacks the sequence/collection into positional arguments, and taking input via input() is shorter. Also, setting s to space doesn't actually save any bytes.
Altogether, this is 79 bytes:
print(*[w[::-1]for w in(''.join(chr(int(c))for c in input().split()).split())])

Try it online!
or, if you're dedicated to having a function, 82 bytes:
lambda m:' '.join(w[::-1]for w in(''.join(chr(int(c))for c in m.split()).split()))

Try it online!
plus seven or so characters if you really need the function to be called decode

Python splits on space by default so you can lose another 6 Try it online! :)

The actual challenge works with input() and print(), so in fact, this problem can be solved in 79 bytes on CodingGame.

Python 2, 78 bytes
lambda m:' '.join(x[::-1]for x in''.join(map(chr,map(int,m.split()))).split())

Try it online!
Edit changed to a Python 2 answer as the lambda is shorter than the print/input version in Python 2.
This uses a couple of maps to get the list of characters which we then join on "", split again on space, reverse each element then rejoin again on space for 78. Also works in Python 3.
Just a pity that it needs so many brackets :-(

and 75 with print and input: print(*[x[::-1]for x in''.join(map(chr,map(int,input().split()))).split()])

I missed that as I am more familiar with Python 2 in which the print and input version comes out at 79 Try it online!

80 in fact as I had missed out the space Try it online!


text:
Two stack sorting
This challenge is inspired by the same task I read some time ago in CACM.
There are many ways to sort stuff. Most attempt to sort in as few operations as possible (= as fast as possible). However, it is also possible to consider how few resources you might require to sort stuff, which seems more fitting for a codegolf challenge.
You have a stack of cards, numbered from 1 to N (or 0 to N-1 or a to zzz if you prefer). You do not know N. All you have available are two additional stacks, where one of them has capacity for just a single card. At any point, you see just the top of those stacks and you have no memory what was there even a single step before.
Your task is to write a function (or whatever) that would take top of those 3 stacks as input in some convenient form and return operation that has to be performed - eg 2,3 meaning card has to move from stack 2 to stack 3. Please note that one stack has capacity for a single card. Input given when stack is empty is arbitrary.
Initial state of sorting is one stack with all the cards in arbitrary mixed order and two empty stacks, one of the two with capacity for a single card (and the other is unlimited). After executing your function (and performing the operation returned) finitely many times on arbitrarily mixed initial cards, cards have to be guaranteed to be sorted on any of the stacks. Saving previous state or checking non-top numbers in any way is prohibited. As are all other loopholes.

What is the input if a stack is empty?

What are we told for the "top card" if a stack is empty? When you say that one stack has capacity for one card, does that mean we have the input stack where things stack, an initially empty stack that can hold any number of cards, and also an initially empty stack that can hold only one card?

I think this question is more of a puzzle than a code golf challenge, as the challenge here is to figure out the algorithm, and the implementation itself is trivial. Of course, after the first answer appears, the optimal algorithm to figure out the algorithm is to copy it from someone else.

@JoKing whatever you want. It can be an empty array, a number not in bounds or something else.

@xnor 1. Whatever you want. 2. Yes. One stack that is initially full of mixed cards. One stack that can hold whatever number of cards and is initially empty. And one stack that can hold a single card.

Do we know which stack is the one that can only hold one card?  it seems like we would have to so that we don't make an invalid move.

Jelly, 9 8 bytes
ṖM⁸aḢ;‘$

Try it online!
A monadic link taking a list of three integers representing the top of the three stacks, or zero for an empty stack. The three stacks are [single card, destination, source]. Returns a pair of integers indicating which stack to move from and to. In keeping with Jelly’s indexing of lists, the third stack can be referred to either as 3 or 0.
Inspiration taken from @Arnauld’s JavaScript answer so be sure to upvote that one!
Explanation
Ṗ         | Remove last list item
 M        | Indices of maximum
  ⁸a      | Original argument and with this
    Ḣ     | Head
     ;‘$  | Concatenate to itself plus 1

JavaScript (ES6), 23 bytes
Uses 1-indexed cards and stacks. The initial stack is the 1st one. The single-card stack is the 3rd one. Expects \$0\$ for an empty stack.
Returns a 2-digit number, where the 1st digit is the source stack and the 2nd digit is the destination stack.
(a,b,c)=>c?b>c?21:32:13

Try it online!
Commented
(            // input:
  a,         //   a = top card in the primary stack
  b,         //   b = top card in the secondary stack
  c          //   c = card in the temporary stack
) =>         //
  c ?        // if there's already a card in the temporary stack:
    b > c ?  //   if there's a card in the secondary stack and it's
             //   greater than the temporary card:
      21     //     move from secondary to primary
    :        //   else:
      32     //     move from temporary to secondary
  :          // else:
    13       //   move from primary to temporary


text:
Print the twelve days of Christmas
The goal is simple, print out each day of the twelve days of Christmas, the text should match this exactly
On the first day of Christmas my true love gave to me
A partridge in a pear tree

On the second day of Christmas my true love gave to me
Two turtle doves, and
A partridge in a pear tree

On the third day of Christmas my true love gave to me
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the fourth day of Christmas my true love gave to me
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the fifth day of Christmas my true love gave to me
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the sixth day of Christmas my true love gave to me
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the seventh day of Christmas my true love gave to me
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the eighth day of Christmas my true love gave to me
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the ninth day of Christmas my true love gave to me
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the 10th day of Christmas my true love gave to me
10 lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the 11th day of Christmas my true love gave to me
11 pipers piping
10 lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree

On the 12th day of Christmas my true love gave to me
12 drummers drumming
11 pipers piping
10 lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves, and
A partridge in a pear tree


text:
Play flip--flop
Flip flop is a memory / arithmetic game that I played in high school. Some number of players stand in a circle. The players take turns. On the nth turn, the current player checks:

What is the largest power of 7 dividing n?
How many instances of the digit 7 does the decimal representation of n contain?
What is the largest power of 8 dividing n?
How many instances of the digit 8 does the decimal representation of n contain?

Let FLIPS(n) be the sum of the power of 7 dividing n and the number of 7's n contains. For example, FLIPS(7)=2 (divisible by 7 once, contains one 7), FLIPS(14) = 1 (divisible by 7 once, contains zero 7's), FLIPS(17)=1 (not divisible by 7, contains one 7).
Let FLOPS(n) be the sum of the power of 8 dividing n and the number of 8's n contains.
On a player's turn, if FLIPS(n)=FLOPS(n)=0 they say n. Otherwise, they first say "flip" FLIPS(n) times and then say "flop" FLOPS(n) times.
If FLIPS(n) is odd, the direction of play swaps (from counterclockwise to clockwise or from clockwise to counterclockwise). The next FLOPS(n) players in the new play order are skipped.
Task
Write a program that takes a pair of integers (num_players, turns) and plays Flipflop with a group of num_players players for turns turns. Output should be a list of the current_player on the nth turn. The players are numbered 1 through num_players. The player to the left of player 1 is player num_players. (If it's more convenient to label the players 0 to num_players - 1, that is fine too.) Play begins with player 1 in counterclockwise order.
Example:
I'll give an example with 5 players. For the first 6 turns nothing interesting happens:

Player 1 says "1" (CCW)
Player 2 says "2" (CCW)

...

Player 5 says "5" (CCW)
Player 1 says "6" (CCW)
Player 2 says "flipflip" (still CCW FLIPS(7)=2 is even)
Player 3 says "flopflop" (CCW, skip players 4 and 5)
Player 1 says "9" (CCW)

...

Player 1 says "flip" (now CW play order)
Player 5 says "15"   (CW)
Player 4 says "flop" (CW)
Player 2 says "flip" (now CCW)
Player 3 says "flop" (CCW)
Player 5 says "19"   (CCW)

The 70's and 80's have a lot of activity. When trying to actually play this game, it is hard to remember where in this 20 digit sequence you are (though 700 / 800 is much worse).

Player 4 says "69" (CW)
Player 3 says "flipflip" (still CW)
Player 2 says "flip"     (CCW)
Player 3 says "flipflop" (CW)
Player 1 says "flip"     (CCW)
Player 2 says "flip"     (CW)
Player 1 says "flip"     (CCW)
Player 2 says "flip"     (CW)
Player 1 says "flipflipflip"(CCW)
Player 2 says "flipflop"  (CW)
Player 5 says "flip"      (CCW)
Player 1 says "flopflop"  (CCW)
Player 4 says "flop"      (CCW)
Player 1 says "flop"      (CCW)
Player 3 says "flop"      (CCW)
Player 5 says "flipflop"  (CW)
Player 3 says "flop"      (CW)
Player 1 says "flop"      (CW)
Player 4 says "flipflop"  (CCW)
Player 1 says "flopflopflop"(CCW)
Player 5 says "flop"      (CCW)
Player 2 says "90"        (CCW)

Scoring
This is code golf, so shortest answer in bytes wins.
Test Cases:
[2,100] => {1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,1,1,2,1,2,1,2,2,1,2,1,1,2,1,2,2,1,2,1,2,1,1,2,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,1,2,2,1,2,1,2,1,2,1,2,1,1,2,1,2,2,1,2,1,2,1,1,2,1,1,1,1,1,1,1,1,1,1,2,1,2,1,2,1,1,2,2,1}
[3,100] => {1,2,3,1,2,3,1,2,2,3,1,2,3,1,3,2,3,1,3,1,2,1,3,2,3,2,1,2,3,2,1,3,1,3,2,3,1,3,1,3,1,3,1,2,3,1,2,1,1,3,2,1,3,2,1,3,2,1,2,1,3,2,1,2,2,3,1,3,1,3,2,3,1,2,1,2,1,2,3,1,1,3,2,1,2,3,1,3,1,3,1,3,2,1,3,2,3,1,3,1}
[4,100] => {1,2,3,4,1,2,3,4,3,4,1,2,3,4,3,2,4,1,3,4,1,4,3,2,4,3,2,3,1,4,3,2,4,3,2,3,4,3,1,4,2,1,2,3,4,1,2,1,2,1,4,3,2,1,4,3,1,4,2,1,4,3,2,3,2,3,4,3,1,4,3,4,2,3,2,3,2,3,1,2,1,3,1,3,1,3,1,3,3,1,2,1,4,3,2,1,3,4,2,3}
[5,100] => {1,2,3,4,5,1,2,3,1,2,3,4,5,1,5,4,2,3,5,1,2,1,5,4,2,1,5,1,4,3,2,1,4,3,2,3,4,3,1,5,3,2,3,4,5,1,2,1,3,2,1,5,4,3,2,1,3,2,5,4,3,2,1,2,5,1,2,1,4,3,2,3,1,2,1,2,1,2,5,1,4,1,3,5,3,1,4,1,5,2,3,2,1,5,4,3,1,2,4,5}
[6,100] => {1,2,3,4,5,6,1,2,5,6,1,2,3,4,3,2,6,1,3,4,5,4,3,2,6,5,4,5,3,2,1,6,4,3,2,3,4,3,1,6,4,3,4,5,6,1,2,1,4,3,2,1,6,5,4,3,5,4,2,1,6,5,4,5,2,3,4,3,1,6,5,6,4,5,4,5,4,5,3,4,1,3,5,1,5,3,1,3,1,3,4,3,2,1,6,5,3,4,6,1}
[7,100] => {1,2,3,4,5,6,7,1,4,5,6,7,1,2,1,7,5,6,1,2,3,2,1,7,5,4,3,4,2,1,7,6,4,3,2,3,4,3,1,7,5,4,5,6,7,1,2,1,5,4,3,2,1,7,6,5,7,6,4,3,2,1,7,1,4,5,6,5,3,2,1,2,7,1,7,1,7,1,6,7,3,5,7,2,7,5,3,5,2,4,5,4,3,2,1,7,5,6,1,2}

A picture
I had 100 players play the game for \$200^2\$ steps, made it into a 200 by 200 square and colored the squares by hue. Made with Mathematica.

@Arnauld I will add largest e.g., "What is the largest power of p dividing n?" but 1 is p^0, so that would be the zeroth power.

Jelly, 35 22 bytes
Dċ¥+ọɗþ7,8Ä-*Ɗ‘ƭ€P1;Ä%

Try it online!
A dyadic link that takes the number of turns as the left argument and number of players as the right. Players and numbered from 0 to number of players - 1 and play starts with player 1. Currently returns the start player and the current player after each turn (so 101 players in total); this could easily be changed to omit the final one at the cost of a byte.
As a bonus, here's a version that prints the player and what they say.
Explanation
     ɗþ7,8              | Outer table using the following as a dyad and [7,8] as the rught argument (and 1..number of turbs as left argument)
  ¥                     | - Following as a dyad
D                       |   - Convert to decimal digits
 ċ                      |   - Count (right argument)
   +                    | - Add to
    ọ                   |   - Order (power of right argument that exactly divides left argument)
             ƭ€         | Alternate between the following:
           Ɗ            | - For first list (flips), following as a monad:
        Ä               |   - Cumulative sum
         -*             |   - -1 to the power of this
            ‘           | - For second list (flops) add 1
                 P      | Product (flips × flops)
                  1;    | Prepend 1
                    Ä   | Cumulative sum
                     %  | Modulo number of players

JavaScript (ES6),  121 117  115 bytes
Takes input as (players)(turns). The output is 0-indexed.
P=>T=>(F=p=>++t>T?[]:[p%P,...F(p+(g=(x,n=t)=>n%x?(t+g).split(x).length:1+g(x,n/x))(8)*(d*=g(7)&1||-1)+P)])(t=0,d=1)

Try it online! (raw output)
Try it online! (post-processing for 1-indexed output)
Commented
P => T => (                   // P = number of players, T = number of turns
  F = p =>                    // F = recursive function taking the current player ID p
    ++t > T ?                 // increment the turn ID; if it's greater than T:
      []                      //   stop recursion
    :                         // else:
      [                       //   update the output array:
        p % P,                //     append the current player ID
        ...F(                 //     append the result of a recursive call:
          p + (               //       update p ...
            g = (x,           //         g is a helper function taking x = 7 or 8
                    n = t) => //         and a counter n initialized to t
              n % x ?         //         if x is not a divisor of n:
                (t + g)       //           coerce t to a string
                .split(x)     //           and count the number of occurrences of x
                .length       //           plus 1
              :               //         else:
                1 +           //           increment the result
                g(x, n / x)   //           recursive call with n / x
          )(8) * (            //       invoke g(8) = FLOPS(t) + 1
            d *= g(7) & 1     //         leave d unchanged if g(7) = FLIPS(t) + 1 is odd
                 || -1        //         otherwise, update d to -d
          ) + P               //       make sure that p remains positive
        )                     //     end of recursive call
      ]                       //   end of output update
)(t = 0, d = 1)               // initial call to F with p = t = 0 and d = 1

Python 2, 143 bytes
def f(P,m):r=[];p=0;d=i=1;exec"r+=[p%P];d*=g(i,7)%2*2-1;p+=d*g(i,8);i+=1;"*m;return r
g=lambda n,b,k=1:n%b**k<1and g(n,b,k+1)or`n`.count(`b`)+k

Try it online!
Input in P number of players, m rounds. Output is 0 indexed.
The function g(n,b) returns flips(n)+1 or flops(n)+1 with b=7,8, respectively. That +1 saves a byte or three...

Charcoal, 64 bytes
Ｎθ≔⁰ε≔¹δＦＮ«⟦Ｉ﹪εθ⟧≦⊕ιＦ⁺№Ｉι7№Ｅ↨ι⁷﹪ιＸ⁷⊕λ⁰≦±δ≧⁺×δ⊕⁺№Ｉι8№Ｅ↨ι⁸﹪ιＸ⁸⊕λ⁰ε

Try it online! Link is to verbose version of code. Players are 0-indexed. Explanation:
Ｎθ

Input the number of players.
≔⁰ε

Set the current player to player 0.
≔¹δ

Set the initial direction of play.
ＦＮ«

Loop for the given number of turns.
⟦Ｉ﹪εθ⟧

Output the current player.
≦⊕ι

1-index the current turn.
Ｆ⁺№Ｉι7№Ｅ↨ι⁷﹪ιＸ⁷⊕λ⁰

Count the number of flips.
≦±δ

Reverse the direction of play for each flip.
≧⁺×δ⊕⁺№Ｉι8№Ｅ↨ι⁸﹪ιＸ⁸⊕λ⁰ε

Calculate the next player to play.
Bonus 91-byte version outputs what each player says too:
Ｎθ≔⁰ε≔¹δＦＮ«≦⊕ι≔⁺№Ｉι7№Ｅ↨ι⁷﹪ιＸ⁷⊕λ⁰η≔⁺№Ｉι8№Ｅ↨ι⁸﹪ιＸ⁸⊕λ⁰ζ⟦⪫⟦⊕﹪εθ∨⁺×flipη×flopζι⟧:⟧≧×Ｘ±¹ηδ≧⁺×δ⊕ζε

Try it online! Link is to verbose version of code.

Vyxal, 26 bytes
ƛ78fMƛ÷₍ǑO∑;;∩÷›u„¦e*¦Ȯ%0p

Try it Online!
Pretty much a port of Nick Kennedy's Jelly answer. First argument turns-1, second argument num_players, players are zero-indexed.
How?
                           #                 e.g. stack (top ->)
ƛ78fMƛ÷₍ǑO∑;;∩÷›u„¦e*¦Ȯ%0p #                      100
ƛ                          # for i = 1..turns     77
 78f                       #   push, split        77 [7,8]
    M                      #   pair               [77,7] [77,8]
     ƛ                     #   for [i,7] [i,8]    [77,7]
      ÷                    #     split            77 7
       ₍                   #     parallel apply
        Ǒ                  #       multiplicity   1
         O                 #       count          2
                           #     end              [1,2]
          ∑                #     sum              3
           ;               #   end                [3,0]
            ;              # end                  [[0,0],[0,0],[0,0],...]
             ∩             # transpose            [[0,0,0,...],[0,0,0,...]]
              ÷            # split                [0,0,0,...] [0,0,0,...]
               ›           # increment            [0,0,0,...] [1,1,1,...]
                u          # push -1              [0,0,0,...] [1,1,1,...] -1
                 „         # rotate left          [1,1,1,...] -1 [0,0,0,...]
                  ¦        # prefix sum           [1,1,1,...] -1 [0,0,0,...]
                   e       # exponent             [1,1,1,...] [1,1,1,...]
                    *      # multiply             [1,1,1,...]
                     ¦     # prefix sum           [1,2,3,...]
                      Ȯ    # over                 [1,2,3,...] 3
                       %   # modulo               [1,2,0,...]
                        0p # prepend 0            [0,1,2,...]


text:
Linear dependences over the field with two elements
The \$d\$-dimensional vector space \$\mathbb{F}_2^d\$ over the field with two elements \$\mathbb{F}_2\$ is the set of vectors of \$d\$ bits. Addition of vectors is bitwise xor. A linear dependence is a set of vectors whose total (xor them all together) is \$0\$. Every set of \$d+1\$ vectors in \$\mathbb{F}_2^d\$ contains a linear dependence. We will represent the elements of \$\mathbb{F}_2^d\$ as the integers \$0\$ through \$2^{d}-1\$ using the binary expansion.
Task
Input: a positive integer \$d\$ and a list of \$d+1\$ positive integers between \$1\$ and \$2^{d}-1\$. You may assume that the list is sorted and you may assume that the entries are distinct.
Output: A nonempty subset of the \$d+1\$ numbers whose bitwise xor is zero.
Scoring:
This is code golf so shortest answer in bytes wins.
Examples:
Input: (3, [1,3,4,7])
Output: [3, 4, 7]

In binary, these are 001, 011, 100, and 111. We see that 100 xor 011 xor 111 = 000. In this case this is the only solution, so we must output [3, 4, 7].
Test cases:
Input: (3, [1,3,4,7])
Output: [3, 4, 7]

Input: (4, [1, 2, 6, 10, 30])
Output: Behavior undetermined because 30 > 15 = 2^4 - 1.

Input: (5, [3, 5, 6, 9, 14])
Output: [3, 5, 6]

Input: (5, [4, 8, 10, 12, 14])
Output: [4, 8, 12] or [4, 10, 14], or [8, 10, 12, 14].

Input: (6, [4, 15, 17, 21, 49, 51, 57])
Output: [4, 17, 21]

Input: (6, [1, 7, 8, 15, 39, 55, 57])
Output: [7, 8, 15] or [1, 15, 55, 57] or [1, 7, 8, 55, 57]

Input: (6, [13, 14, 24, 33, 35, 36, 63])
Output: [13, 14, 24, 36, 63]

Input: (6, [10, 11, 25, 28, 40, 59, 62])
Output: [10, 25, 40, 59] or [10, 28, 40, 62], or [25, 28, 59, 62]

Input: (6, [1, 3, 5, 11, 19, 32, 63])
Output: [1, 3, 5, 11, 19, 32, 63]

May we return all solutions?

You may want to clarify that the empty set is not an acceptable solution.

Must the answer be a list of the entries, can it be a bitmask with the ith bit set iff item[i] is in the set?

@harold Yes, the bitmask sounds fine to me.

@Arnauld I think returning all solutions should be fine. I agree it would be good to clarify on the empty set, I meant to do that when writing the question but forgot.

May we assume the entries are distinct?

@xnor Yes, will add that.

What is the maximum value for $d$?

@qwr I guess you are asking because harold's answer only handles $d\leq 32$? I think that's alright, certainly it's larger than any of my test cases. Many of the other solutions use brute force and would never finish if $d=32$. Plus it's nice for people to have fun and it doesn't seem like all that many people golf assembly language.

Jelly, 7 bytes
ŒPḊ^/ÞḢ

A monadic Link accepting the list of distinct integers representing the vectors which yields a subset representing the linear dependence. (May be employed as a dyadic Link also accepting the number of dimensions on the right.)
Try it online!
How?
ŒPḊ^/ÞḢ - Link: list of distinct integers   e.g. [1,3,4,7]
ŒP      - power-set                              [[],[1],[3],[4],[7],[1,3],[1,4],[1,7],[3,4],[3,7],[4,7],[1,3,4],[1,3,7],[1,4,7],[3,4,7],[1,3,4,7]],[3,4,7],[1,3,4,7]]
  Ḋ     - dequeue                                [[1],[3],[4],[7],[1,3],[1,4],[1,7],[3,4],[3,7],[4,7],[1,3,4],[1,3,7],[1,4,7],[3,4,7],[1,3,4,7]],[3,4,7],[1,3,4,7]]
     Þ  - sort by:
    /   -   reduce by:
   ^    -     XOR                              ( [1,3,4,7,2,5,6,7,4,3,6,5,2,0,1] )
        - }                                      [[3,4,7],[1],[1,3,4,7],[1,3],[1,4,7],[3],[4,7],[4],[3,7],[1,4],[1,3,7],[1,7],[1,3,4],7,[3,4]]
      Ḣ - head                                   [3,4,7]

Perl 6, 39 bytes
{first {![+^] $_},.combinations(1..$_)}

Try it online!
Returns the first combination of the input that is zero when reduced XOR. I wish {![+^] $_} could be changed to !*.&[+^].

Pyth, 6 bytes
hxFDty

Try it online!
To explain, back to front:

y generates all subsets of the input.
t (tail) removes the first, empty subset.
D means order by the following function:
F means reduce on:
x is the xor function.
h (head) takes the first element of the sorted list.

The lists that xor to 0 will be sorted to the front.

Haskell, 79 bytes
import Data.Bits
p[a]=[[a]]
p(a:b)=map(a:)(p b)++p b
filter((1>).foldl xor 0).p

Try it online!
Defines the power set (ignoring the empty set) as p, then our solution is:
filter((1>).foldl xor 0).p

Or in english:

Get the power set and then select all the members whose xor sum is less than 1 (i.e. zero).

05AB1E, 8 bytes
æ¦.Δ.»^>

Try it online!
How?
æ¦.Δ.»^> - implicitly take input
æ        - power-set
 ¦       - tail
  .Δ     - keep first which is 1 under:
    .»   -   reduce by:
      ^  -     XOR
       > -   increment
         - implicit print

Python 3.8, 74 bytes
f=lambda a,s=[],v=0:s*(v<1)or a and(f(n:=a[1:],s+a[:1],v^a[0])or f(n,s,v))

Try it online!

JavaScript (ES6),  84 60  58 bytes
Ignores \$d\$. Returns \$0\$ if there's no solution.
f=([v,...a],x,o=[])=>x<1?o:v?f(a,x,o)||f(a,x^v,[...o,v]):0

Try it online!
Commented
f = (                        // f is a recursive function taking:
  [v,                        //   v   = next value from the input set
      ...a],                 //   a[] = array of remaining values
  x,                         //   x   = 'XOR total', initially undefined
  o = []                     //   o[] = output subset
) =>                         //
  x < 1 ?                    // if x is defined and equal to 0:
    o                        //   success: return o[]
  :                          // else:
    v ?                      //   if v is defined:
      f(a, x, o) ||          //     try a recursive call where v is ignored
      f(a, x ^ v, [...o, v]) //     try a recursive call where v is used
    :                        //   else:
      0                      //     failed

Ruby, 78 bytes
f=->a{(1..a.size).map{|x|a.combination(x).map{|x|return x if x.reduce(:^)<1}}}

Try it online!
:^)
Probably golfable.

74 bytes: replaced the return with a find/compact structure, and then cheesed out the reduce with an eval.

J, 36 bytes
0-.~1{ ::0[:(#~0=XOR/"1)]#~2#:@i.@^#

Try it online!

Mathematica, 61 bytes
f[d_,l_]:=NullSpace[IntegerDigits[#,2,d]&/@l,Modulus->2][[1]]

This gives a bitmask (well a list of zeros and ones) of which elements of the list are in the set, as was allowed by the OP.

Mathematica, 38 bytes
Select[Rest@Subsets@#,BitXor@@#==0&]&

Returns the list of solutions or an empty list if no solutions exist.
Try it online!

x86 machine code, 27 bytes
578B7C240831C04031D231C90FA3C8730333148F67E2F575EE5FC3

Iterating through bit masks and XORing together the items as selected by the mask. In MASM-format assembly:
_lindep PROC
    push edi
    mov edi, [esp + 8]
    xor eax, eax
_loop:
    inc eax
    xor edx, edx
    xor ecx, ecx
_inner:
    bt eax, ecx
    jnc _skip
    xor edx, [edi + 4 * ecx]
_skip:
    byte 67h
    loop _inner
    jnz _loop
    pop edi
    ret
_lindep ENDP

It's a cdecl function, not stdcall.
There is an odd requirement: the input array must be padded to 65536 items long, but only 32 items are actually used. That's because I used a 16-bit loop and relied it on it wrapping from 0 to 65535, The padding has to exist in order to make the program not die with an access violation.
Using loop this way, in addition to gaining the benefit from it being small, means the zero flag is not modified between the xor and the jnz of the outer loop. Almost any other construct would need an extra instruction just to re-test whether edx is zero, except using lea to increment the loop counter and bt ecx, 5 to stop when it hits 32, which is bigger.
Driver program in case you want to run it:
#include <iostream>
extern "C" int lindep(int* vecs, int d);
int vecs[65536] = { 1, 3, 4, 7 };
int main()
{
    std::cout << lindep(vecs, 3) << "\n";
}

why are only 32 items used? and the requirement to pad the input array is stretching the I/O rules too far IMO.

@qwr the bitmask only has 32 bits in it so more than that doesn't work.

Charcoal, 32 bytes
ＩΦＥＸ²ＬθΦθ﹪÷ιＸ²μ²∧ι⬤↨⌈θ²¬﹪Σ÷ιＸ²μ²

Try it online! Link is to verbose version of code. Outputs all matches. Explanation:
    ²                               Literal 2
   Ｘ                                Raised to power
      θ                             Input array
     Ｌ                              Length
  Ｅ                                 Map over implicit range
        θ                           Input array
       Φ                            Filtered where nonzero
           ι                        Outer index
          ÷                         Integer divide by
             ²                      Literal 2
            Ｘ                       Raised to power
              μ                     Inner index
         ﹪                          Modulo
               ²                    Literal 2
 Φ                                  Filter powerset where
                 ι                  Current subset (is not empty)
                ∧                   Logical And
                     θ              Input array
                    ⌈               Maximum
                   ↨                Convert to base
                      ²             Literal 2
                  ⬤                 Has all values where
                           ι        Current powerset
                          ÷         Vectorised integer divide by
                             ²      Literal 2
                            Ｘ       Raised to power
                              μ     Inner index
                         Σ          Sum
                        ﹪           Modulo
                               ²    Literal 2
                       ¬            Is zero
Ｉ                                   Cast to string
                                    Implicitly print

Burlesque, 16 bytes
peR@{{$$}r[n!}fe

Try it online!
Takes arguments as d {1 2 3 4...}
pe      # Read vals and push to stack
R@      # Generate all subsets
{
 {$$}r[ # Reduce by xor
 n!     # Boolean not
}fe     # Find first element


text:
Integer Interpretator
The Challenge
Given a finite list of integers, split it into the fewest partitions possible such that no partition contains a number more than once.
Rules
Input can be in any format and any order.
Output can be in any format, as long as it's clear that each group is separate.
This is code-golf, so lowest score wins!
Example I/O
Input: [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]
Output: [[1,2],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1]]

Input: [1,3,4,2,6,5,1,8,3,8]
Output: [[1,3,4,2,6,5,8],[1,3,8]]

Input: [5,9,12,5,2,71,23,4,7,2,6,8,2,4,8,9,0,65,4,5,3,2]
Output: [[5,9,12,2,71,23,4,7,6,8,0,65,3],[5,4,8,9,2],[4,5,2],[2]]

Could you clarify a bit what you mean by splitting?  Does it matter the order of the original list when splitting?

The order of the original list does not matter. I'm not quite sure how I can make "splitting" any clearer; the Example I/O may help you understand what I mean.

You can just mention that the order of the original list does not matter.  The test cases do preserve order to some extent so they are not really helpful in the deduction.  Plus a clear spec is always better than examples.

Is it interpretator or interpreter?

Also, how big do the integers have to be? Can we restrict them to a certain size?

This should work with any size integer.

Jelly, 3 bytes
ĠZị

A monadic Link accepting a list, which yields a shortest set-wise partition such that each part is a set.
Try it online!
How?
ĠZị - Link: list, L                      e.g. [8,2,4,2,9,4,1]
Ġ   - group indices of L by their values      [[7],[2,4],[3,6],[1],[5]]
 Z  - transpose                               [[7,2,3,1,5],[4,6]]
  ị - index into L                            [[1,2,4,8,9],[2,4]]

We had the same idea. I was sure there was a way to do it in 3. I’d thought of Ġị⁸Z but not of swapping the Z and ị.

Yeah, I saw just after I posted - good job, I prepped a list-partition version, and then saw the examples.

Python 2, 50 bytes
l=input()
while l:s=set(l);print s;map(l.remove,s)

Try it online!
Repeatedly prints the unique of elements of the list, then removes one of each such element. A rare imperative use of map.

Haskell, 39 bytes
First we collect all equal elements in separate lists using sort and then group.  By transposeing the resulting list of lists we get at most one of each of those elements in the resulting lists.
import Data.List
f=transpose.group.sort

Try it online!
Example
                     [1,2,3,2,4,2,1,5] --input
                sort$[1,2,3,2,4,2,1,5] --[1,1,2,2,2,3,4,5]
          group.sort$[1,2,3,2,4,2,1,5] --[[1,1],[2,2,2],[3],[4],[5]]
transpose.group.sort$[1,2,3,2,4,2,1,5] --[[1,2,3,4,5],[1,2],[2]]

You don't need to count the f=

J, 20 17 bytes
_<@-."1~0|:1%%/.~

Try it online!
             %      divide 1 by each, 0 becomes infinity
              /.~   group equal values, every group gets padded with zeroes
           1%       invert back
        0|:         transpose
_<@-."1~            remove the infinities, put each row in a box

I suspect 0|:1%%/.~ is acceptable, we get
5 9 12 2 71 23 4 7 6 8 0 65 3
5 9  _ 2  _  _ 4 _ _ 8 _  _ _
5 _  _ 2  _  _ 4 _ _ _ _  _ _
_ _  _ 2  _  _ _ _ _ _ _  _ _

Peak J, I played around trying to get the transpose trick to work, but it’s bulky without this clever 0/inf trick

Jelly, 4 bytes
¹ƙ`Z

Try it online!
A monadic link that takes a list of integers and returns a list of lists of integers. Simply groups identical numbers and then transposes.

Haskell, 54 bytes
(a:b)%n|elem n a=a:b%n|s<-n:a=s:b
_%n=[[n]]
foldl(%)[]

Try it online!
We define a function % which takes a single number and adds it to a partition scheme and we fold it across the input starting with an empty partition scheme.

Japt, 3 bytes
ü y

Try it
Sorts & partitions by value and then transposes the result.

JavaScript (ES6), 59 bytes
a=>a.map(o=n=>b[i=o[n]=-~o[n],--i]=[...b[i]||[],n],b=[])&&b

Try it online!

Perl 6, 30 bytes
{roundrobin map &[xx],.Bag.kv}

Try it online!
Inspired by the Jelly answers.
Explanation
{                            }  # Anonymous block
                      .Bag      # Convert to Bag (multiset)
                          .kv   # Key-value sequence
            map &[xx],  # Repeat each key n times
 roundrobin  # Transpose

Old solution, 32 bytes
{(.Bag,{$_∖.Set}...^!*)>>.Set}

Try it online!
Explanation
{                            }  # Anonymous block
      ,         ...^    # Create sequence
  .Bag                  # starting with input converted to Bag (multiset)
       {$_∖.Set}        # Decrease weights by one each iteration
                    !*  # Until bag is empty
 (                    )>>.Set  # Convert all bags to sets

R, 54 bytes
for(i in 1:max(t<-table(scan())))print(names(t)[t>=i])

Try it online!
Builds a table of the counts of the values. For input 1 3 4 2 6 5 1 8 3 8, this gives
t = 1 2 3 4 5 6 8
    2 1 2 1 1 1 2

where the first row is names(t) (the different values in the input) and the second is the counts in t.
Then in the for loop, at iteration i, print only the names corresponding to counts ≥i.

41 bytes and returns integers to boot!

@Giuseppe Very nice! You should post it separately. (Along with an explanation, as I'm still unclear how it works!)

J, 23 bytes
(}:,(~:</.])&>@{:)^:_@<

Try it online!

Pyth, 4 bytes
.T.g

Try it online!

Burlesque, 6 bytes
rasgtp

Try it online!
ra # Read input as array
sg # Sort and group like values
tp # Transpose

Red, 67 61 bytes
func[b][until[print a: unique b foreach e a[alter b e]b =[]]]

Try it online!
Inspired by xnor's Python answer - don't forget to upvote it!
This was a rare opportunity to use alter-  If a value is not found in a series, append it; otherwise, remove it

Charcoal, 17 bytes
ＩＥ⌈Ｅθ№θιΦθ⁼№…θμλι

Try it online! Link is to verbose version of code. Explanation:
    θ               Input array
   Ｅ                Map over elements
     №              Count of
       ι            Current element in
      θ             Input array
  ⌈                 Maximum
 Ｅ                  Map over implicit range
         θ          Input array
        Φ           Filter elements where
           №        Count of
               λ    Current element in
             θ      Input array
            …       Truncated to length
              μ     Inner index
          ⁼         Is equal to
                ι   Outer index
Ｉ                   Cast to string
                    Implicitly print

C (gcc) with -m32 flag, 231 213 210 209 bytes
Thanks to ceilingcat (-22 bytes) for the suggestions.
The function goes through the list of values and builds a reverse list of the unique values, incrementing its count on a match. After the list has been built, the function then goes through the list again, printing any values that have a non-zero count and decrementing the count: It repeats this until all values have a zero count.
g(v,c,p)int*v,*p;{int*i=p,w[3]={p,*v,!c};if(c){for(;i&&i[1]-w[1];i=*i);2[i=i?:w]++;g(++v,--c,p=i-w?p:i);}else for(;w[2];p=*w)for(w[2]=!puts("");p;p=*p)p[2]?printf("\t%d",p[1]),p[2]-=w[2]=1:0;}f(v,c){g(v,c,0);}

Try it online!

Perl 6, 25 bytes
*.classify({%.{$_}++}){*}

Try it online!
Groups each element of the input by how many times it has appeared in the sequence so far, then take only the values

Nice! {*} instead of .values saves 4 bytes.

C (gcc), 114 bytes
W;*P;S(D,E)int*D,*E;{do for(P=D;P<E;*P==W?printf("%d ", W),*P=*D,*D++=W,P=E:++P);while(++W);puts("");D-E&&S(D,E);}

This solution takes a while to run because it iterates over all possible integer values from -2^31 to 2^31-1.
Here is a TIO link to a slightly longer solution that runs a lot faster, the only difference is, that it uses short instead of int. Groups are separated by line breaks.
Try it online!
How does it work?
For every possible integer value
    if value in array
        print value
        remove found value entry from list
print endline
if array is not empty
    recursively call function on remaining array

int W;
int *P;

S(int* D, int* E)
{
    // this loop will run once for every possible integer value
    do
    {
        // search for the integer value W
        for(P=D;P<E;++P)
            // if the value is found
            if (*P == W)
            {
                // output the value, can happen only once per integer value
                printf("%d ", W);
                // overwrite the found value with the first value of the array
                // because we have to output the first value later
                *P = *D;
                // reduce the size of the remaining array by one
                D++;
                // jump out of for loop to seach for next possible value of W
                P = E;
            }
    }
    while(++W); // after the while loop W==0 again

    puts("");   // output new line

    if (D!=E)
        S(D,E); // if end is not reached, search again in ramaining array
}

Suggest *P-W?++P:printf("%d ",*D++=W,P=E,*P=*D) instead of *P==W?printf("%d ", W),*P=*D,*D++=W,P=E:++P

Zsh, 58 bytes
for x (${(u)@})<<<$x&&argv[$@[(i)$x]]=
<<<"
${*:+`$0 $@`}"

Try it online!
Yay, recursion!
For each element $x of (u)nique ${@}rguments, print it, and set the first (i)nstance of it to the empty string.
Finally, print a newline as a list delimiter, and if the remaining arguments are nonempty, substitute $0 $@, which is this program, called with all remaining nonempty elements.

R, 41 bytes
split(sort(s<-scan()),sequence(table(s)))

Try it online!
Like Robin Ryder's answer, this makes use of table to get counts of the unique elements in the input.
A fuller explanation to follow.

05AB1E, 4 bytes
{γζþ

Try it online or verify all test cases.
Explanation:
{     # Sort the (implicit) input-list
      #  i.e. [5,9,12,5,2,71,23,4,7,2,6,8,2,4,8,9,0,65,4,5,3,2]
      #   → [0,2,2,2,2,3,4,4,4,5,5,5,6,7,8,8,9,9,12,23,65,71]
 γ    # Group it into chunks of the same subsequent value
      #  → [[0],[2,2,2,2],[3],[4,4,4],[5,5,5],[6],[7],[8,8],[9,9],[12],[23],[65],[71]]
  ζ   # Zip/transpose; swapping rows/columns, with a space character as filler by default
      #  → [[  0, 2,   3,   4,   5,   6,   7,   8,   9,  12,  23,  65,  71],
      #     [' ', 2, ' ',   4,   5, ' ', ' ',   8,   9, ' ', ' ', ' ', ' '],
      #     [' ', 2, ' ',   4,   5, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
      #     [' ', 2, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']]
   þ  # Remove all spaces by only keeping digits
      #  → [[0,2,3,4,5,6,7,8,9,12,23,65,71],[2,4,5,8,9],[2,4,5],[2]]
      # (after which the result is output implicitly)

C++ (clang), 230 \$\cdots\$ 198 162 bytes
Saved 11 bytes thanks to @ErikF!!!
Saved 8 a whopping 44 bytes thanks to ceilingcat!!!
#import<bits/stdc++.h>
void f(std::vector<int>v){for(;v.size();puts(""))for(int e:std::set<int>(&v[0],&*end(v)))printf("%d ",e),v.erase(find(begin(v),end(v),e));}

Try it online!
Basic port of @xnor's algorithm without the clever stuff.

Husk, 3 bytes
TkI

Try it online!
Key on value, then transpose.

Perl 5 -a, 46 bytes
say%k=()while s/\d+/$k{$&}++?$&:(say$&)&&''/ge

Try it online!
Input is on one line, whitespace separated.
Output is one element per line with a blank line between groups.


text:
2D Path Drawing
(This is not a duplicate of Follow the path, as this challenge have invalid path detection and use ><^v in the output.)
Task
So your task is to take in the description of the path and draw it out in a "Befunge(or a lot of other 2D esolangs)-like" format, and detect if it is invalid. Note that if the path is invalid, you shall not output anything except a printable custom character which cannot be one of ><^v or space.

The path would be invalid if the path is crossed.
Or, if you moved off the top or left edge.

You begins at the top-left corner.

>n moves you right n characters. Your trail is >.
^n moves you up n characters. Your trail is ^.
<n moves you left n characters. Your trail is <.
vn moves you down n characters. Your trail is v.

Test Cases
Input: >3v3

Output:
>>>v
   v
   v

Input: v4>1^2>3

Output:
v
v
v>>>
v^
>^

Input: >5<3

Output:
!

(Or any character you want, except ><^v and space.)

Input: [NONE]

Output: [NONE]

Input: >4v2<2^2

Output:
>>>>v
  ^ v
  ^<<

Input: >4v2<2^3

Output:
!

(Or any character you want, except ><^v and space.)

Input:
>3v3<6

Output:
!

(Or any character you want, except ><^v and space.)

Rules

Standard loopholes are forbidden.
Least bytes wins.
This was written in a hurry.

@JonathanAllan Well, >4v2<2^3 crosses itself and is thus... invalid, so I outputted a ! (or custom character). I didn't get what you mean?

Just noticed I read above rather than below, sorry!

Can we input an array/list of (direction, number) tuples/arrays/lists?

@mypronounismonicareinstate Yes.

May i throw an exception instead of return !?

@tsh Uh... Oh, yeah! I guess you could output any nonsense here, except incomplete path... Wait a minute. I'm going to say you can output anything instead of returning ! or other "one characters", but you must output the same thing for any invalid input.

@mypronounismonicareinstate Ummmm... 1. Input seperator 2. The treasure mark 3. Invalid detection

(Maybe I should ask the question as invalid detection and not drawing the path?)

@HighlyRadioactive I'm pretty sure requiring different IO, removing the last-character-must-be-X requirement and requiring input validation doesn't make this less of a duplicate, as the only reason the answers can't ported from that question trivially is the input validation requirement, and that is boring

@mypronounismonicareinstate Invalid input is actually the point of this challenge, as it's not simply the kind of "wrong input"; The detection is nicely done in the only answer of this question.

@mypronounismonicareinstate And the "you must not output anything except your invalid msg" needs effort; You have to either do the detection before the drawing process or use clever methods like the only answer.

@mypronounismonicareinstate If that still didn't keep it from duplicating, are there anything that could be add or modified or deleted to make it non-trivially different from that challenge? Deleting the drawing part, I guess?

Charcoal, 46 bytes
≔⁰ηＦ⪪Ｓ²ＦＩ§ι¹«≧⁺℅ＫＫη✳⊗⌕>^<§ι⁰§ι⁰≧⁺∨‹ⅈ⁰‹ⅉ⁰η¿η«⎚!

Try it online! Link is to verbose version of code. Explanation:
≔⁰η

Assume everything is OK.
Ｆ⪪Ｓ²

Loop over the instructions.
ＦＩ§ι¹«

Loop over the number of steps.
≧⁺℅ＫＫη

Check whether the path has crossed.
✳⊗⌕>^<§ι⁰§ι⁰

Output each character in the appropriate direction.
≧⁺∨‹ⅈ⁰‹ⅉ⁰η

Check whether the path has moved off the top or left edge.
¿η«⎚!

If something went wrong, replace the output with a !.

I like how you make use of the feature that you can "clean" the output. Neat!


text:
Define the finite field GF(9)
\$GF(9)\$ or \$GF(3^2)\$ is the smallest finite field whose order isn't a prime or a power of two. Finite fields of prime order aren't particurlarly interesting and there are already challenges for \$GF(2^8)\$ (link) and \$GF(2^{64})\$ (link).
Challenge
First define nine elements of the field. These must be distinct integers from 0 to 255, or the one-byte characters their code points represent. State in your answer which representation you choose.
Then implement two binary operations, addition and multiplication, satisfying the field axioms:

Both operations must be commutative and associative.
Addition has the identity element \$0\$ and an additive inverse for each element.
Multiplication has the identity element \$1\$ and a multiplicative inverse for each element except \$0\$.
Multiplication distributes over addition: \$a·(b+c) = (a·b)+(a·c)\$

Addition and multiplication can be implemented as functions or programs taking two field elements and producing one field element.
Since the field is really small, you can test the axioms exhaustively to check your implementation or verify the addition and multiplication tables.
Mathematical construction
Elements of \$GF(3^2)\$ can be interpreted as polynomials of the form \$P(x)=a x+b\$ over \$GF(3)\$. (Addition and multiplication in \$GF(3)=\{0,1,2\}\$ are the standard integer operations modulo 3.)
Then addition in \$GF(3^2)\$ is simply the addition of two polynomials. Multiplication is defined by the product of two polynomials, reduced modulo a polynomial of degree 2 which is irreducible over \$GF(3)\$.
Example
Mapping polynomials to integers with \$n=3a+b\$ and using the irreducible polynomial \$x^2+1\$ yields the following addition and multiplication tables. Note that there are other possible isomorphisms of these tables.
+   0 1 2 3 4 5 6 7 8   *   0 1 2 3 4 5 6 7 8
   ------------------      ------------------
0 | 0 1 2 3 4 5 6 7 8   0 | 0 0 0 0 0 0 0 0 0
1 | 1 2 0 4 5 3 7 8 6   1 | 0 1 2 3 4 5 6 7 8
2 | 2 0 1 5 3 4 8 6 7   2 | 0 2 1 6 8 7 3 5 4
3 | 3 4 5 6 7 8 0 1 2   3 | 0 3 6 2 5 8 1 4 7
4 | 4 5 3 7 8 6 1 2 0   4 | 0 4 8 5 6 1 7 2 3
5 | 5 3 4 8 6 7 2 0 1   5 | 0 5 7 8 1 3 4 6 2
6 | 6 7 8 0 1 2 3 4 5   6 | 0 6 3 1 7 4 2 8 5
7 | 7 8 6 1 2 0 4 5 3   7 | 0 7 5 4 2 6 8 3 1
8 | 8 6 7 2 0 1 5 3 4   8 | 0 8 4 7 3 2 5 1 6

Test of distributivity using the tables above:
$$5 · (2 + 7) = 5 · 6 = 4$$
$$(5 · 2) + (5 · 7) = 7 + 6 = 4$$
Note that simply using addition and multiplication modulo 9 won't work.
Scoring
This is code golf. Your score is the sum of bytes of the functions (or programs) for addition and multiplication. Lowest number of bytes wins.

What exactly does the output have to be? Can we return two functions? Do we have to return the integers we used to represent the field elements? Can we output two tables like iny our example?

@flawr You have to write two functions or programs for addition and multiplication that take two field elements and return one field element (typically integers).

ok then I would suggest clarifying that in your specs - for me at least it was not obvious.

The modular operation is equivalent to setting $x^2+1=0$, which as we all know has the solution $x=i$, so the values $(-1..1)+(-i..i)$ form a field GF(9) under balanced modulo 3.

Would it be possible to not have links with purely MathJax in them? Using such links stops the default right-click behaviour so opening it in a new tab is annoying. (E.g. consider $GF(2^8)$ vs. GF(2⁸).)

May we produce one function that outputs both the sum and the product? Alternatively, one function that also takes a Boolean parameter that tells it which one to output?

05AB1E, 24 17 16 bytes
Uses 0, 1, 2, 10, 11, 12, 20, 21, 22 as the 9 field elements.
Addition, 5 bytes:
OS3%J

Try it online! or print the entire table.
O             # sum of the inputs
 S            # split to a list of digits
  3%          # mod 3 each digit
    J         # join

Multiplication, 11 bytes:
PƵÈ%98%S3%J

Try it online! or print the entire table.
P             # product of the inputs
 ƵÈ%          # mod 300
    98%       # mod 98
       S3%J   # split, mod 3 each digit, join

Haskell, 118 112 107 bytes
Here I use the numbers \$n= 0,1,2,\ldots,8\$ to represent the field elements. Internally these are converted to a list \$[a,b]\$ that represents a polynomial \$aX+b\$, (using \$a = \lfloor n/3 \rfloor\$ and \$b = n \bmod 3 \$, or \$n=3a+b\$), and we then proceed using the usual arithmetic using these polynomials in \$(\mathbb  Z / 3\mathbb Z)[X]/(X^2+1)\$. In this case we have
$$(aX+b) + (cX+d) = (a+c)X + (b+d)$$
and similarly
$$\begin{align*}
(aX+b) \cdot (cX+d) &= acX^2+(ad+bc)X + bd
\\
& \equiv ac(-1) +(ad+bc)X + bd \pmod {X^2+1} \\
& \equiv (ad+bc)X+(bd-ac)
\end{align*}$$
Thanks for -6 bytes @WheatWizard!
i x=[div x 3,x]                --conert integer to polynomial/list representation
j[a,b]=mod(a*3+mod b 3)9       --inverse of i
s=(.i).(j.).zipWith(+).i       --"sum"
m[a,b][c,d]=j[a*d+b*c,b*d-a*c] --core function of "product"
p=(.i).m.i                     --"product"

Try it online!

Retina 0.8.2, 53 + 111 = 164 23 + 61 = 84 bytes
Edit: Saved 80 bytes by switching to @Grimmy's I/O format. However, the provided links include a footer which converts the output back to 0-8 format and formats the results into a square.
Addition (53 23 bytes):
\d+
$*
M`1
3$
0
T`34`_1

Try it online! Link includes test suite. Explanation:
\d+
$*

Convert both arguments to unary.
M`1

Take the sum and convert to decimal.
3$
0
T`34`_1

Modulo the last digit by 3, and modulo by 30.
Multiplication (111 61 bytes):
\d+
$*
1(?=1*;(1*))|.
$1
1{300}|1{98}|1{30}

M`1
T`3-8`012012

Try it online! Link includes test suite. Explanation:
\d+
$*

Convert to unary.
1(?=1*;(1*))|.
$1

Take the product.
1{300}|1{98}|1{30}

Modulo by 300, 98 and 30.
M`1

Convert to decimal.
T`3-8`012012

Modulo the last digit by 3.

MATLAB, 106 104 102 bytes
We encode \$\operatorname{GF}(9)\$ as \$\{0,\ldots,8\}\$ and map to \$\mathbb{Z}[i]/\langle 3\rangle\$ in order to add and multiply:
e=@(x)mod(x,3)+i*fix(x/3)
d=@(x)[1 3]*mod([real(x);imag(x)],3)
a=@(x,y)d(e(x)+e(y))
m=@(x,y)d(e(x)*e(y))

@A.Rex pointed out this clever improvement:
e=@(x)mod(x,3)+i*round(x/3)
d=@(x)mod(real(x)^3+3*imag(x),9)
a=@(x,y)d(e(x)+e(y))
m=@(x,y)d(e(x)*e(y))

Pari/GP, 88 bytes
Uses numbers 0 to 8 to represent the elements. Uses Pari/GP's built-in polynomial arithmetic.
f(a)=a%3+a\3*x
g(a)=Vecrev(a%(x^2+1),2)%3*[1,3]~
s(a,b)=g(f(a)+f(b))
p(a,b)=g(f(a)*f(b))

Try it online!

Pari/GP, 86 bytes
Inspired by Dustin G. Mixon's answer.
f(a)=a%3+a\3*I
g(a)=[real(a),imag(a)]%3*[1,3]~
s(a,b)=g(f(a)+f(b))
p(a,b)=g(f(a)*f(b))

Try it online!

x86 32-bit machine code, 21 16 bytes
f7 e2 28 e0 01 d0 27 2c 03 a8 08 75 f9 d4 30 c3

-5 with another shorter way to reduce the coefficients modulo 3.
Uses polynomials modulo \$X^2 + 1\$, represented by integers by substituting \$ X = 16 \$. The selected values correspond to canonical forms \$ aX + b\$ for \$a,b \in \{0,1,2\}\$ – hexadecimal 00, 01, 02, 10, 11, 12, 20, 21, 22.
Uses the regparm(2) calling convention – arguments in EAX and EDX, result in AL. The multiplication function begins at the start of the code, and the addition function begins after the first four bytes.
Try it online!
Explanation
gf9_multiply:
    mul edx

Multiply the given polynomials (which are in EAX and EDX). Put the product in EDX:EAX – the value is small enough to fit in EAX, so EDX becomes 0.
    sub al, ah

Subtract AH (the second-lowest byte of EAX) from AL (the lowest byte of EAX). This reduces the polynomial modulo \$ X^2 + 1 \$: AL now represents a polynomial equivalent to the result modulo 3, of the form \$ aX+b \$ for \$ 0 \le a \le 8, -4 \le b \le 4 \$.
gf9_add:
    add eax, edx

Here, the two functions merge.
For gf9_add, this adds EDX and EAX (the arguments), so that AH represents a polynomial equivalent to the result modulo 3, of the form \$ aX+b \$ for \$ 0 \le a \le 4, 0 \le b \le 4 \$.
For gf9_multiply, EDX will be 0 when we get here, and this instruction leaves EAX unchanged.
repeat:
    daa

This is one of several x86 instructions designed for handling numbers in binary-coded decimal.
daa stands for Decimal Adjust (AL) after Addition. "Decimal" in these instruction names refers to packed BCD, which puts one decimal digit in each nybble. As the instruction's name indicates, its intended purpose is to be used after a regular add or similar instruction, to correct the result for BCD.
So what correction is needed?
Consider the simple example of adding 2 (binary 00000010) and 8 (binary 00001000).
The result of regular addition is regular 10 (binary 00001010), but the BCD sum should be BCD 10 (binary 00010000). The result thus has to be increased by 6, to change 10 to 16. That is one of the things that daa does.
But how does it know whether this +6 should be applied? In this case, it is obvious from the value itself, because binary 1010 is not a valid BCD digit. But if the calculation were instead 8 plus 8, the result would be binary 00010000, which is valid BCD for 10, but the correct BCD sum is 16.
This is where the "auxiliary carry flag" (AF) comes in. It is set by the add instruction based on whether it results in a carry across the centre of the byte, which covers the cases where the low nybble reaches 16 or higher and wraps back around to a valid BCD digit. The instruction daa adds 6 to AL if the low nybble of AL is 10 to 15 or AF is 1.
daa also makes a similar adjustment for the high nybble of AL: if the high nybble's original value is 10 to 15, or the carry flag (CF) is 1 (which is based on carries off the top of the number), it adds 6 to the high nybble.
Here, the flags AF and CF come from the preceding add, which always sets them to 0 here. The low nybble is 10 to 15 iff, in the current polynomial \$ aX+b \$ (with \$ 0 \le a \le 8, -4 \le b \le 4 \$), \$ b \$ is -4 to -1, in which case adding 6 results in \$ b \$ being 2 to 5. The high nybble is 10 to 15 only if \$ a \$ is 0 in addition to \$ b \$ being negative, in which case adding 6 to the high nybble makes \$ a \$ 6.
Thus, after the daa, AL still represents a polynomial equivalent to the result modulo 3 of the form \$ aX+b \$, but now with \$ 0 \le a \le 8, 0 \le b \le 5 \$.
    sub al, 3

Subtract 3. Again, AL represents a polynomial equivalent to the result modulo 3 of the form \$ aX+b \$, and this time \$ 0 \le a \le 8, -3 \le b \le 2 \$.
    test al, 8

Look at the eights bit of AL, which is 1 if \$ b \$ is negative and 0 otherwise.
    jnz repeat

Jump back if \$ b \$ is negative (-3 to -1). If that is the case, next daa adds 6 to \$ b \$ while possibly changing \$ a \$ from 0 to 6, similarly to before, and then sub takes 3 from \$ b \$, leaving it with a net +3, which puts it in the range 0 to 2, and then test sees that the eights bit is 0, and the jump does not happen again.
In either case, AL now represents a polynomial equivalent to the result modulo 3 of the form \$ aX+b \$ with \$ 0 \le a \le 8, 0 \le b \le 2 \$.
If it were possible to jump conditionally based on AF, the test could have been omitted for -2 bytes.
    aam 0x30

This is another BCD instruction. In its default form, aam converts a regular number in AL to an unpacked BCD (one byte per decimal digit) number in AH and AL, which is done by setting AH and AL to the quotient and remainder, respectively, of AL divided by 10. However, the instruction allows that number 10 to be changed. We set it to 0x30; the important part is that AL is reduced modulo 0x30, which means \$ a \$ is reduced modulo 3.
At last, the polynomial has been reduced modulo 3 to its canonical form.
    ret

Return.
Previous solution, also 16 bytes
f7 e2 d5 02 01 d0 99 d4 30 c0 c0 04 4a 7a f8 c3

Try it online!
Assembly:
.text
.global gf9_multiply
.global gf9_add
.intel_syntax noprefix

gf9_multiply:
    mul edx     # Multiply EAX by EDX, placing the product in EDX:EAX.
    aad 0x02    # AL := 2 * AH + AL (AL is the low byte of EAX; AH is the next byte.)
                # AH := 0             Reduces the polynomial modulo X^2 - 2.
gf9_add:        # When falling through, EDX=0; the next instruction will do nothing.
    add eax, edx# Add EDX to EAX. Coming from either start point,
                #  this produces in EAX a polynomial equivalent to the result mod 3.
    cdq         # Set each bit of EDX to the high bit of EAX, here 0.
repeat:
    aam 0x30    # (AH, AL) := (quotient, remainder) of AL / 0x30
                # Reduces the coefficient of X modulo 3.
    rol al, 4   # Rotate left by 4 places, swapping the positions of the coefficients.
                #   Next, we need to execute the same two instructions again,
                #    to reduce the other coefficient modulo 3 and swap them back.
                #   Simply repeating those instructions would take 5 bytes.
                #   It is instead done in 4 bytes, including the earlier cdq:
    dec edx     # Decrement EDX, to -1 the first time and -2 the second time.
    jpe repeat  # Jump back if the sum of the eight low bits is even.
                #  This is true for -1 (...11111111) but not for -2 (...11111110).
    ret         # Return.

Haskell, 83 bytes
This is a straightforward adaptation of 05AB1E's answer. This function accepts 0, 1, 2, 10, 11, 12, 20, 21, and 22.
k=flip mod
q=l.k 30
l a=a-z+k 3 z where z=k 10 a
p=((q.k 98.k 300).).(*)
s=(q.).(+)