text:
Compactify the input
Given a word, your task is to compact it by saving its first character and removing any other vowel (aeiou).
Input
Your input can be the word in STDIN, a function argument or any other input format that doesn't break the standard loopholes.  You can assume the input only consists of lower characters.
Output
Your output must be the word, compacted.
Examples
i -> i
ate -> at
potato -> ptt
ksboejqfgcrauxpwivtzndlhmy -> ksbjqfgcrxpwvtzndlhmy

Score
This is a code-golf, so shortest answer in bytes wins, good luck!

05AB1E, 6 bytes
ćsžMм«

Try it online!
Explanation
       Input (e.g.). potato
ć      Head extract. otato, p
 s     Swap        . p, otato
  žM   Vowels      . p, otato, aeiou
    м  Remove      . p, tt
     « Concatenate . ptt

Implicit output    .

Retina, 15 13 8 bytes
0T1,`v`_

Transliterates lowercase vowels into nothing (_) in the 0th in 0-indexing match of the implicit regex that matches the entire string, after index 1 (1,).
Try it online!

C (gcc), 57 56 52 bytes
Time to roll out some magic numbers!
Thanks @Arnauld for even better magic numbers!
f(char*a,char*b){for(*b++=*a;*b=*++a;)b+=4373%*a&1;}

Try it online!

so those magic numbers check if something is a vowel?

[repost] Yes. I found that by enumerating those constants.

52 bytes

Thanks! Very nice. @Arnauld

J, 15 bytes
{.,'aeiou'-.~}.

Try it online!
Straightforward:

{. head...
, catted with...
'aeiou'-.~ vowels, set minused from...
}. tail

sed, 14 bytes
s/\B[aeiou]//g

Try it online!

Bash + Core utilities, 19 bytes
sed s/\\B[aeiou]//g

Try it online!

sed solution is nice.

Python 2, 43 bytes
Another 43-byte solution in Python.
lambda s:s[0]+s[1:].translate(None,'aeiou')

Try it online!

Ruby, 31 bytes
->x{x[0]+x[1..].tr('aeiou','')}

Needs to be run on Ruby 2.6 or above, since it uses an endless range.
(TIO is on 2.5.5, so it doesn't work there.)

Excel, 87 bytes
=LET(q,SEQUENCE(LEN(A1)),x,MID(A1,q,1),CONCAT(IF(ISERROR(FIND(x,"aeiou"))+(q=1),x,"")))

Hopefully this link works.
Try it here

Is there an online Excel simulator to run this?  My own (outdated) Excel version doesn't seem to have functions like LET or SEQUENCE....

Added link.  Hopefully, it works.

Python 3, 44 43 bytes
lambda a,*s:[a]+[c[c in"aeiou":]for c in s]

Try it online!
Input: Characters of the word. E.g f("a", "t", "e")
Output: A list of characters.

Alternative 43 bytes using regex

@CommandMaster nice! Since the approach is quite different from mine, why don't you post this as a separate answer?

Jelly, 6 bytes
Ḣ;ḟØẹ$

Try it online!
How?
Ḣ;ḟØẹ$ - Link: list of characters, W
Ḣ      - head & yield
     $ - last two links as a monad - i.e. f(rest of W)
  ḟ    -   filter discard:
   Øẹ  -     lower-case vowels
 ;     - (head of W) concatenate (f(rest of W))

I just arrived at the exact same solution before noticing this one. I think the one thing worth mentioning in the explanation is that Ḣ mutates the input

Yep - "head & yield" and "rest of W".

naz, 102 bytes
2x1v2a6m8m1a2x2v4a2x3v4a2x4v6a2x5v6a2x6v1x1f1r3x1v2e3x2v1e3x3v1e3x4v1e3x5v1e3x6v1e1o1f0x1x2f0a0x1r1o1f

Works for any null-terminated input string.
Try it online!
Explanation (with 0x instructions removed)
2x1v                                           # Set variable 1 equal to 0
2a6m8m1a2x2v                                   # Set variable 2 equal to 97 ("a")
4a2x3v                                         # Set variable 3 equal to 101 ("e")
4a2x4v                                         # Set variable 4 equal to 105 ("i")
6a2x5v                                         # Set variable 5 equal to 111 ("o")
6a2x6v                                         # Set variable 6 equal to 117 ("u")
1x1f                                           # Function 1
    1r                                         # Read a byte of input
      3x1v2e                                   # Goto function 2 if it equals variable 1
            3x2v1e3x3v1e3x4v1e3x5v1e3x6v1e     # Jump back to the start of the function
                                               # if it equals variable 2, 3, 4, 5, or 6
                                          1o1f # Otherwise, output it, then call the
                                               # function again
1x2f                                           # Function 2
    0a                                         # Add 0 to the register
1r1o                                           # Output the first byte of input
1f                                             # Call function 1

Erlang (escript), 26 bytes
f([H|T])->[H]++T--"aeiou".

Try it online!
Explanation
f([H|T])->       % Match the head & tail of the input string.
[H]              % Wrap the head in a list,
   ++T           % Append the tail
      --"aeiou". % with all vowels removed.

APL (Dyalog), 14 bytes
⊃,'aieou'~⍨1∘↓

Try it online!

Haskell, 34 bytes
f(a:s)=a:[x|x<-s,notElem x"aeiou"]

Try it online!

You can do all(/=x) for notElem x.

Perl 5 -p, 18 bytes
s/(?<!^)[aeiou]//g

Try it online!

Hey, came up with prety much the same! You can remove < from the lookbehind for one, or if you use the regex as the arg to -F you can have a 5 byte solution: Try it online!

APL (NARS2000 0.5.13.0), 20 unicode char (so 20 byte or 40 byte?)
(↑,((~∘'aeiou')1∘↓))

Sample output:
      (↑,((~∘'aeiou')1∘↓)) 'i'
i
      (↑,((~∘'aeiou')1∘↓)) 'ate'
at
      (↑,((~∘'aeiou')1∘↓)) 'potato'
ptt
      (↑,((~∘'aeiou')1∘↓)) 'ksboejqfgcrauxpwivtzndlhmy'
ksbjqfgcrxpwvtzndlhmy
      (↑,((~∘'aeiou')1∘↓)) ''

Thanks to the tacit feature added lately.
Since APL code chars are unicode chars, I am not sure if one char should be counted as two byte or not.

I think those are 28 UTF8-bytes.

PHP, 41 bytes
<?=preg_replace("/\\B[aeiou]/","",$argn);

Try it online!
I wanted to find an original solution but it ends up like everyone's regex.. Deception is my middle name

PowerShell, 33 30 bytes
-3 bytes thanks to @CommandMaster
$args-split"(.)[aeiou]"-join''

Try it online!

never used powershell, but $args-split"(.)[aeiou]"-join'' seems to work for -3

@CommandMaster wow, wouldn't expect that to work, thank you ;)

? Try it online!

@mazzy 24 bytes: $args-replace'\B[aeiou]'

Brachylog, 7 bytes
h|b;Ḅ∋ᵛ

Try it online!
Generator.
 |         The output is
h          the first element of the input,
 |         or
     ∋ᵛ    some shared element of
 |b        the input without its first element
   ;Ḅ      and the lowercase consonants.

Factor, 31 bytes
[ 1 cut "aeiou"without append ]

Try it online!
Explanation
It's a quotation (anonymous function) that takes one string as input and leaves one string as output. Assuming "potato" is on top of the data stack when this quotation is called...

1 Push one to the data stack. Stack: "potato" 1
cut Cut a sequence into two pieces at a given index. Stack: "p" "otato"
"aeiou" Push a string to the data stack. Stack: "p" "otato" "aeiou"
without Remove elements from NOS (next on stack) that are in TOS (top of stack). Stack: "p" "tt"
append Concatenate two strings. Stack: "ptt"

Red, 33 bytes
func[s][trim/with next s"aeiou"s]

Try it online!

Python 3, 57 55 bytes
Saved 2 bytes thanks to ovs!!!
lambda s:s[0]+''.join(c for c in s[1:]if{c}-{*'aeiou'})

Try it online!

if c not in'aeiou' can be 2 bytes shorter with set difference: if{c}-{*'aeiou'}

@ovs That's clever - thanks! :-)

JavaScript (ES6),  27  26 bytes
Saved 1 byte thanks to @Neil
Returns a list of characters.
s=>s.match(/^.|[^aeiou]/g)

Try it online!

Why not use ^ instead of \b?

@Neil I saw your comment a while ago and forgot about it. Thanks!

Is this valid? An array of characters isn't the same thing as a string, in JavaScript.

K (oK), 20 bytes
{(*x),(1_x)^"aoeiu"}

Try it online!

Python 3, 61 bytes
lambda s:s[0]+''.join(filter(lambda x:x not in'aeiou',s[1:]))

Try it online!

Welcome to the site.  This repeats the first character if it is a consonant.  You should change the s to s[1:] to prevent this.

@AdHocGarfHunter Thank you! :)

Charcoal, 12 bytes
ΦＳ¬∧κ№aeiouι

Try it online! Link is to verbose version of code. Explanation:
 Ｓ              Input string
Φ ¬             Exclude characters where
     №aeiouι    Character is a vowel
   ∧κ           And index is not zero
                Implicitly print

Keg -ir, 34 16 bytes
Huge saving thanks to Lyxal.
,(:⅍`aeiou`-[,|_

Try it online!

16 bytes with -ir and some other shenanigans.

Pyth, 12 bytes
+hQ-tQ"aeiou

Explanation
+hQ-tQ"aeiou
    tQ        : Everything except first element of evaluated input
   -  "aeiou  : Remove all occurrences of a, e, i, o and u from the string
+hQ           : Prepend first element of evaluated input

Try it online!

Ruby -p, 22 19 bytes
gsub /\B[aeiou]/,''

Try it online!
Thanks to Command Master for -3 bytes.

19 chars: gsub /\B[aeiou]/,''

JavaScript (V8), 42 bytes
s=>s[0]+s.substr(1).replace(/[aeiou]/g,'')

Try it online!

Replace substr with slice to save 1 byte

Stax, 5 bytes
ö¶╫♂.

Run and debug it

Japt v2.0a0, 7 bytes
Î+UÅr\v

Try it

Arturo, 29 bytes
$[s][replace s{/\B[aeiou]}""]

Try it

Vyxal s, 5 bytes
ḣkvF"

Try it Online!
Port of the 05Ab1e answer but one less byte because flags are cool

SNOBOL4 (CSNOBOL4), 66 bytes
 INPUT LEN(1) . F REM . I
V I ANY('aeiou') =:S(V)
 OUTPUT =F I
END

Try it online!

CJam, 15 bytes
l_0=\1>"aeiou"-

Try it online!
It's 15 bytes because there is no better way to push all those vowels.
Explained
l_0=\1>"aeiou"-
l_                  e# Take the input and duplicate it: [input, input]
  0=                e# From the input, take the first character: [input, input[0]]
    \               e# Swap the top two items: [input[0], input]
     1>             e# Drop the first character: [input[0], input[1:]]
       "aeiou"      e# Push the string "aeiou": [input[0], input[1:], "aeiou"]
              -     e# Remove all occurances of the above string from the input[1:] and print.

TI-Basic, 58 bytes
Input Str1
sub(Str1,1,1
For(I,2,length(Str1
If not(inString("AEIOU",sub(Str1,I,1
Ans+sub(Str1,I,1
End
Ans

Takes input as all capital letters (which is hopefully allowed).

Uiua, 16 bytes
⍜↘(▽¬∊,"aeiou")1

Try it!
⍜↘(▽¬∊,"aeiou")1
⍜↘(           )1  # apply (...) to the input except the first letter
   ▽¬∊,"aeiou"    # remove vowels


text:
Find acronym-like words in a sentence
Let's say you have a sentence like:
this is a very long sentence with several words of no significance

It contains only the 26 lowercase letters of the alphabet and spaces.
And you have a dictionary, where each word contains any number of the 26 lowercase letters and nothing else:
henge
renton

Then the output should contain, among others:

tHis is a vEry long seNtence with several words of no siGnificancE
tHis is a vEry long senteNce with several words of no siGnificancE
this is a veRy long sENTence with several wOrds of no significaNce

So, every line of the output is the original sentence, but if only the uppercase letters of a line are taken, they should form a dictionary word. The program should find all possible such lines.

I have attempted to paraphrase certain parts of the question so that somebody like me can read them easier; I hope I haven't failed; feel free to rollback my edit if I have.

Is the dictionary necessary? This doesn't make the challenge more interesting than just having a sentence and a single word as input.

Also, more test cases would be appreciated.

Might want to add something about the dictionary word being formed in or out of sequence. I assume you meant in sequence but it's not stated.

May I assume there are at least one sentence output for each word in the dictionary? If not so, I would suggest adding another testcase.

JavaScript, 474 bytes
k=((e,r)=>{for(o=[],e=[...e],r=[...r],w=r.reduce((r,h,n)=>!(r[n]=e.map((e,r)=>h==e?r:"").filter(Number))||r,[]),[z]=w,h=[],x=0;x<w.reduce((e,r)=>e*=r.length||e,1);x++)z.forEach((e,r)=>{for(g=[z[r]],j=1;j<w.length;j++)for(n=w[j],y=0;y<n.length;y++)if(g.slice(-1)[0]<n[y]&&!h.some(e=>e.toString()==[...g,n[y]].toString())){g.push(n[y]);break}h.push(g)});return h.filter(e=>e.length==w.length).forEach(r=>{d=[...e],r.forEach(e=>d[e]=d[e].toUpperCase()),o.push(d.join(""))}),o})

Live example:

k=((e,r)=>{for(o=[],e=[...e],r=[...r],w=r.reduce((r,h,n)=>!(r[n]=e.map((e,r)=>h==e?r:"").filter(Number))||r,[]),[z]=w,h=[],x=0;x<w.reduce((e,r)=>e*=r.length||e,1);x++)z.forEach((e,r)=>{for(g=[z[r]],j=1;j<w.length;j++)for(n=w[j],y=0;y<n.length;y++)if(g.slice(-1)[0]<n[y]&&!h.some(e=>e.toString()==[...g,n[y]].toString())){g.push(n[y]);break}h.push(g)});return h.filter(e=>e.length==w.length).forEach(r=>{d=[...e],r.forEach(e=>d[e]=d[e].toUpperCase()),o.push(d.join(""))}),o})

console.log(k('this is a very long sentence with several words of no significance', 'henge'));

Explanation:
For each letter in the word, an array of indices is constructed corresponding to every position of that letter in the sentence.
Then inside a nest of 4 for loops, every possible path from the first array to the last array is computed, where each step is into an element with greater numeric value in the next array.
This produces an array of paths whose length is equal to the maximum possible paths, which is the product of multiplying the length of each letter indices array (this number gets big real quick as the length of the word increases).
Then all paths whose length is smaller than the word are excluded, since they failed to find a valid step between each array.
You can see the unminified logic at this stackoverflow answer.
I am confused by this line (even though it's my code), whose intent is to check the existing paths before adding a step to the current path to make sure its constructing a unique path:
if (!paths.some(p => p.toString() == [...path, arrays[j][y]].toString())) {
  path.push(arrays[j][y]);
  break;
}

It seems to me like this should erroneously prevent construction of multiple paths who share any beginning steps.  But it actually works as intended.  So I am stumped.

Python 3, 169 bytes
a=lambda c,w:(([c[0]+k for k in a(c[1:],w)]+([c[0].upper()+k for k in a(c[1:],w[1:])]if c[0]==w[0]else[]))if c else[])if w else[c]
lambda c,d:sum((a(c,w)for w in d),[])

Takes as input the sentence as a string and the dictionary as a list of strings. Uses a recursive helper function a(c,w) to compute the output for each word in the dictionary at a time, then sums the lists together to get the final output. The helper function works through the sentence/word one character at a time, and has several cases:

No more characters in the word, return what's left of the sentence

No more characters in the sentence, return empty list

Characters left in both, return same results as a(c[1:],w), with c[0] prepended to each result.

Characters left in both, and beginning characters match, return (3.) in addition to a(c[1:],w[1:]), with c[0].upper() prepended to each result.

There's definitely a few bytes of savings to be had in the helper method; I wasn't being super careful with my parentheses around the inline if-expressions (and the precedence is slightly confusing) -- I might take a closer look tomorrow to see if I can shave off a few bytes.

Perl 5 -pF, 96 bytes
Takes the sentence as the first input and all subsequent inputs are treated as the dictionary. Could produce the strings in the reverse order for +1 byte. I still feel there's room to golf this...
$"=").*(";m#(@{[<>=~/./g]})(?{$a=%h=();$h{$_}++for@-;map$\.=$h{$a++}?uc:lc,@F})(?!)# while!eof}{

Try it online!
Explanation
This script uses Perl's regex engine to perform the matching.
First $" is set to ).*(, this is the separator that's used when lists are interpolated. A m//atch is then started (with # as the delimiter) which contains the current input dictionary word (<>), interpolated (@{[...]}) into the match as as a list (=~/./g). Example.
The next part of the m// operation is a zero-length code block. In here there is access to all the magic variables associated with regex ($&, $1, etc). $a and %h are initialised as empty (() - technically $a is set to the length, which is 0) and @-, which contains the start of each matched group, is used to populate the indices of %h with 1 (++) for the position of all the matches.
Finally, @F (which is automatically filled with the chars from the input via -F) is looped over while there's still input (!eof), checking %h's key $a (incremented for each char in @F) to see if it's truthy (1) or not (undef for missing key). If it's truthy uc returns (its operand, or $_ if none passed, which is set for each item in @F via map{...}@F) the item uppercased, otherwise lc returns it lowercased. This is appended to $\ which is implicitly output after anything is printed, which because -p is specified, will happen after the (implicit - from -p) input loop exits. Due to this, it's also necessary to break out of the surrounding loops with }{ so that we don't get an unmodified copy of the input printed too.

source: Stack Exchange

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

sort: votes


text:
Chase the Easter Bunny and collect his eggs
Chat room: https://chat.stackexchange.com/rooms/106513/easter-bunny-challenge
Git repo: https://github.com/AJFaraday/easter_bunny_hunt
The garden is a 2-dimensional grid with 49 rows and 49 columns.
The Easter Bunny™ is in the center of the garden, minding his own business, holding on to 100 Easter eggs. He'll hop away from where the most people are.
When the Easter Bunny™ hops, we all know he'll leave behind an Easter egg.
Grab an Easter egg for 1 point.
Grab the Easter Bunny for 10 points.
The game starts with 4 kids, one in each corner of the garden.
The kids can take 1 step each turn, in one of the 4 cardinal directions (North, South, East or West). When they've each taken a step (or decided not to), the bunny will take a move.
The bunny can hop to any position up to 4 spaces away in both the x and y axes. It will decide where it will hop to by the position of the kids.
The bunny can see kids within 5 spaces of it in any direction (I'm using square distances for simplicity).
For each axis, (ignoring the kids in a line with it) it will move away from the most kids it can see. e.g.

If it can see 1 kid to the right, and none to the left. it will hop 1 step to the west.
If it can see 3 below, and 1 above, it will hop 2 step north.
If there are 2 north, 1 south, and 2 west. it will hop directly to a space 1 step south and 2 steps west.

Important quirks:

The bunny ignores kids on the same row when working out it's north/south hop, and in the same column for it's east/west.
If it can't see any kids, it will stay still until it can.
If the left/right and up/down counts are equal, it will reamin rooted to the spot, like a rabbit in the headlights.

The game ends when:

The Easter Bunny™ leaves the garden.
The Easter Bunny™ drops his last egg.
The kids catch the bunny.
The game reaches the configurable turn limit

Config
You can edit conig.js to change two things about the run:

match_limit will allow you to end the game when you decide (competition will use 1,000 turns)
turn_time (ms) will set the interval when the game is rendering.

How to hunt the bunny?
Your code will take the form of an array of 4 JS functions, which will each control a kid starting in these positions (in this order):

North West (0, 0)
North East (0, 48)
South East (48, 48)
South West (48, 0)

The functions should each have this fingerprint:
function(api) {
}

api is your function's interface to the game (see below).
The API
The api object presents these four movement functions:

api.north()
api.east()
api.south()
api.west()

If any of these are called during your function, the kid will take one step in that direction (or the last called of these four directions).
If none of thess are called during your function, the kid will stand still.
It also provides information about the state of the game with these methods:

api.my_storage() - an object you can use to store data and functions for just this kid.
api.shared_storage() - an object you can use to store data and functions for the whole team.
api.turn() - Returns a number of turns taken in this game so far.
api.bunny() - Returns an object of bunny-related info
{
  x: 24,
  y: 24,
  eggs_left: 100
}
api.kids() tells you where all the kids are
[
  {x: 0, y: 0, me: true}.
  ...
]
api.eggs() tells you qhere all the eggs are
[
  {x: 25, y: 25}
]

Template
Teams.push(
  {
    name: 'template',
    shared_storage: {},
    functions: [
      function(api) {
        // NW kid
      },
      function(api) {
        // NE kid
      },
      function(api) {
        // SE kid
      },
      function(api) {
        // SW kid
      }
    ]
  }
);

name must be a single-word identifier, if you want to run just a single entry.
shared_storage sets the initial state of api.shared_storage, it can be used to set data and functions for your team.
The array functions is the behaviour of the 4 kids chasing the bunny.

How to participate
Change my_entry to your own team name.

git clone https://github.com/AJFaraday/easter_bunny_hunt.git
cd easter_bunny_hunt
npm install -g terser
cp template.js teams/my_entry.js
(Write your team code)
script/run.sh my_entry to watch the game
script/run.sh to see all results (if you import more entries)

When you're happy with the result, copy it in to an answer like so:
# my_entry - 10 points

Any description you want to add goes here

    Teams.push(
      {
        name: 'template',
        shared_storage: {},
        functions: [
          function(api) {
            // NW kid
          },
          function(api) {
            // NE kid
          },
          function(api) {
            // SE kid
          },
          function(api) {
            // SW kid
          }
        ]
      }
    );

Competition rules
Official scoreboard will be updated roughly once a day.
This will run until the 19th of April, one week after Easter Sunday (in the traditions which celebrate Easter Sunday on the 12th of April this year).

Is this intended to be tagged [king-of-the-hill]?

@mypronounismonicareinstate I'd like to tag it king of the hill, but it will be removed if I do. A king of the Hill is only when entries interact with each other. The challenge here is to find a high-scoring path through a task.

If so, can this be tagged [ai-player]? update: it's not a winning criterion though, merely a tag; should also probably have [code-challenge]

@mypronounismonicareinstate Thanks, added

Am I correct that the bunny does not move if it sees one kid above and one kid below, for example?

@pppery That's correct, if it has balanced numbers, it will stay in place. I've added this to the quirks

@pppery The github URL was very wrong, thanks for letting me know. Corrected now. (It's also at the top if you want to dig in to the repo)

@pppery In fact I'd messed the instructions up entirely, could you let me know if you run into more problems?

Looking at the code, the limit on the bunny's sight appears to not be implemented, and it can see kids anywhere in the garden, even if they are more than 5 squares away.

@pppery sorry, missed a push, try git pull and try again

Keep on getting ReferenceError: Game is not defined when I try to run it as above.  What am I missing?

@noodle try ‘npm install -g terser’, sorry

@Noodle9 sorry, I think it’s terser I missed out.

Did npm install -g terser - no change after that.

@Noodle9 can we discuss this in the chat? https://chat.stackexchange.com/rooms/106513/easter-bunny-challenge

Also, what does "I'm using square distances for simplicity" mean? Does it mean the distance from (0 0) to (3, 4) is 7? (i.e. you used the Manhattan distance) Is it 5? (i.e. you used regular euclidean distances) Or is it 25? (i.e. you used the square of the regular euclidean distance)

@RGS it means it looks up to 5 squares away on both axes, describing a square which is visible to the bunny.

The Run of Doom, score 109
var kid_api = function (api) {
    var bunny = api.bunny();
    var kids = api.kids();
    for (var i = 0;i<kids.length;i++) {
        if(kids[i].me) {
            var me = kids[i];
            if (me.x < 24) {
                return api.east();
            } else if (me.x > 24) {
                return api.west();
            } else {
                var s = api.shared_storage();
                var my_data = s[i];
                if (!my_data) {
                    return;
                }else if (my_data.backaway == bunny.eggs_remaining) {
                    return;
                }else if(bunny.y == me.y + my_data.y && bunny.eggs_remaining != 1) {
                    s[2] = Object.assign({}, s.opposites[my_data.func])
                    s[0] = Object.assign({}, s.opposites[my_data.func])
                    s[2-i].backaway = bunny.eggs_remaining;
                    s[i].backaway = 1;
                    api[s[i].func]();
                } else if (me.y + my_data.y < 0 || me.y + my_data.y > 49) {
                    s[i] = null;
                } else {
                    api[my_data.func]();
                }
            }
        }
    }
}
Teams.push(
  {
    name: 'the_run_of_doom',
    shared_storage: {
        2: {"func": "north", "y": -1},
        0: null,
        "opposites": {
            "south":{"func": "north", "y":-1},
            "north":{"func":"south", "y":1}
        },
    },
    functions: [
      kid_api,
      function(api) {
        // NE kid
      },
      kid_api,
      function(api) {
        // SW kid
      }
    ]
  }
);

Uses only two kids: one that starts on the north side, and one that starts on the south side (this version uses NW and SE, but it could be rewritten to use NE and SW, or NE and SE, or NW and SW fairly easily). With a little more effort, one could do this with any combination of two kids.
A score of 110 isn't possible, since the game always ends immediately after the bunny drops the last egg, so I believe this answer is unbeatable.

Maybe you should rename it The Hog of Eggs! T_T

No, I think I like "The Run of Doom", given it describes the pattern of the easter bunny; repeatedly bolting from one edge of the garden to the other without actually ever getting away.

random - 0 to 33 points
Totally random kids!
Teams.push(
  {
    name: 'random',
    shared_storage: {
      sequence: 'abcd',
      take_step: function(api) {
        var char = api.shared_storage().sequence[Math.floor(Math.random() * 5)];
        if(char) {
          api[api.my_storage()['key'][char]]();
        }
      }
    },
    functions: [
      function(api) {
        // NW kid
        if(!api.my_storage()['key']) {
          api.my_storage()['key'] = {'a': 'east', 'b': 'south', 'c': 'west', 'd': 'north'}
        }
        api.shared_storage().take_step(api);
      },
      function(api) {
        // NE kid
        if(!api.my_storage()['key']) {
          api.my_storage()['key'] = {'a': 'east', 'b': 'south', 'c': 'west', 'd': 'north'}
        }
        api.shared_storage().take_step(api);
      },
      function(api) {
        // SE kid
        if(!api.my_storage()['key']) {
          api.my_storage()['key'] = {'a': 'east', 'b': 'south', 'c': 'west', 'd': 'north'}
        }
        api.shared_storage().take_step(api);
      },
      function(api) {
        // SW kid
        if(!api.my_storage()['key']) {
          api.my_storage()['key'] = {'a': 'east', 'b': 'south', 'c': 'west', 'd': 'north'}
        }
        api.shared_storage().take_step(api);
      }
    ]
  }
);

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


text:
Produce all even primes
A prime number is a positive integer that has exactly two divisors 1 and the number itself. For example number 7 is a prime since it is divisible by 1 and 7. Number 1 is not a prime since it has only one divisor. Write a program or function that produces all even prime numbers.
This is a code golf challenge, shortest answer per language wins.

Wonderful first challenge! However, I don't really think all that background info is related to the challenge, I'm removing it temprarily.

also I think the name might be a bit unrelated, maybe it should be named something like even primes?

@petStorm You significally changed the requirements of the challenge. From an output of [2], you changed it into 2. Given the challenge, that's a significant part. You should never do that.

Everything about this challenge feels like April Fools happened 9 days too late...

@OlivierGrégoire Producing all numbers would evidently require list-wrapping, no? (I was surprised that I haven't specified enough.)

However, now you can output a newline-separated list instead of a cumbersome JS-specific IO format! :(

@mypronounismonicareinstate You have a good point. The previous challenge employs a Cumbersome I/O format. It doesn't allow people to output a list joined with the newline, and it forces answerers to output in their raw form.

You seem to assume that there are only finitely many even prime numbers. Can you refer to a theorem that supports this assumption? (OTOH, do even prime numbers exist?)

@petStorm you haven't proved that all other even numbers have factors other than 2, therefore I claim there are infinitely many even primes.

@ChristianSievers According to the definition, all even numbers are divisible by 2, they can be represented as 2n. According to the definition of primes, since the only integral factors of 1x2 is 1 and 2 (there are no integers between them that can divide them), 1x2 fullfills the definition of primes. This proves that 2 is a prime. However, 2x2, 3x2, and so on don't fullfill the defintion, since given that they are divisible by the prime 2, in order to be a prime, their only other factor has to be 1. However, these numbers divided by 2 do not result in 1, which means that they are not prime.

Visual Basic .NET (VBC), 0 bytes
They added this neat function that an empty program outputs a list of the even primes via the exit code.

Try it online!

Noxan, 1 byte
2

Implicitly prints out 2.

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

-[>+<-----]> is a script to generate 50 (which is the ascii code of 2) from https://esolangs.org/wiki/Brainfuck_constants#50, and then . outputs it
Try it online!

Width, 3 bytes
Curious and hoping to try it. Not short at all, since it's designed for restricted-source.
Unfortunately in Width, numbers don't have the privilege of being implicitly printed. :(
Gfm

Try it online!
Explanation
G     Start a string
 fm   Codepoint 18 in the custom code page ('2')
      Implicit end quote
      Implicit print

Nandy, 12 bytes
－２　Ｔｈａｎｋｓ　to　Ｋｅｖｉｎ　Ｃｒｕｉｊｓｓｅｎ.
::#oo>oo>o>o

Try it online!
Explanation
::#          Generate a 1 bit
   oo        Output 1 twice
     >       Roll the stack
      oo     Output 0 twice
        >o>o Output 1 and 0

This makes the binary codepoint of ASCII 2. 110010

I don't know Nandy at all, but can't you drop the first two oo to make the binary 110010? Seem to work just fine on TIO.

+-=, 3 bytes
++=

Add the accumulator by 3, then output the number.

Lost, 11 bytes
v<<>>
>(%2@

Try it online or verify that it's deterministic.
Explanation:
Explanation of the language in general:
Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that both the start position AND starting direction it travels in is completely random. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.
A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up/north, down/south, left/west, or right/east.
In Lost you therefore want to lead everything to a starting position, so it'll follow the designed path you want it to. In addition, you'll usually have to clean the stack when it starts somewhere in the middle.
Explanation of the program:
All arrows will lead the path towards the > on the second line. From there, the program flow is as follows:

>: Travel in a east/right direction.
(: Pop the top of the stack (and push it to the scope). This is to clean a potential 2 that was already pushed.
%: Put the safety 'off'. In a Lost program, an @ will terminate the program, but only when the safety is 'off'. When the program starts, the safety is always 'on' by default, otherwise a program flow starting at the exit character @ would immediately terminate without doing anything. The % will turn this safety 'off', so when we now encounter an @ the program will terminate (if the safety is still 'on', the @ will be a no-op instead).
2: Push a 2
@: Terminate the program if the safety is 'off' (which it is at this point). After which all the values on the stack will be output implicitly with space separator, which in this case is just the 2.

Note that the top line could have been v<<<<, but that the reversed part >> will wrap-around to the other side, making the path shorter and therefore the performance slightly better. The byte-count remains the same anyway, so why not.

Malbolge, 8 bytes
D'<;:^"J

Try it online!

Java 8, 4 bytes
v->2

Try it online.
Explanation:
v->  // Method with empty unused parameter and integer return-type
  2  //  Return 2

Whitespace, 10 bytes
[S S S T    S N
_Push_2][T  N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer n = 2
Print n as integer to STDOUT

Python 3, 7 bytes
exit(2)

Try it online!

C (gcc), 15 14 12 bytes
Saved a byte thanks to petStorm!!!
Saved 2 bytes thanks to Arnauld!!!
a;f(){a|=2;}

Try it online!

a;f(){a|=2;} for 12 bytes

@Arnauld Very nice - thanks! :-)

@l4m2 It's a hack is to load register EAX with the function's return value.

Python 3 without literals, 15 bytes
exit(-~-~int())

Try it online!

int() produces 0? Cool.

I originally put "Python 3 without literals" but that was a bit specific. I put literals again.

What exactly does "without literals" mean? Do strings count too?

Yes, and booleans, and lists, and dictionaries, basically everything other than builtin functions, maybe modules, and variables.

TrumpScript, 3 bytes
a
b

Try it online!
The error message in the output contains all even prime numbers and no other numbers. Well no-one said the output couldn't include other non-numeric text.
The exception message is a bit special:
Exception: Trump will ensure that 'America is great'
As a (not very much) more serious effort (without errors):
TrumpScript, 36 bytes
say 1000002-1000000
America is great

Try it online!

Enlist, 1 byte
2

Try it online!
Just picked a random language on TIO and it worked. Oh well, it's another language to add to the list.

Gol><>, 2 bytes
2h

Try it online!

05AB1E, 1 byte
2

it pushes 2 into the stack and then implicitly outputs it, pretty boring
Try it online!

Ahh, a polyglot with almost every golfing language :)

not really, as ¸ encloses the number in an array and I think it's unique to 05AB1E, but can probably be converted to almost any other golfing language

oh the post have been edited so now I don't need to output JSON, so it's 1 byte

Y is an alternative 1-byte solution for 05AB1E ;)

Python 2, 7 bytes
print 2

Explaination
prints 2
Try it online!

Bash, 6 bytes
echo 2

Try it online!

JavaScript (Node.js), 4 bytes
v=>2

Try it online!

AWK, 12 bytes
END{print 2}

Try it online!

Lenguage, 979,674,373,772 bytes
Unary, 2,063,923,527,196 bytes
Programs consists of 2063923527196 and 979674373772 amount of characters of your own choosing.
Port of CommandMaster's brainfuck answer.
Try it online in brainfuck.
Byte-counts generated by this program I wrote in 05AB1E.

naz, 4 bytes
2a1o

Simply adds 2 to the register and outputs.

J, 1 byte
2

Explanation
2 NB. 2

Uselesslang, 4 bytes
>>.

(There is trailing space)

><>, 3 bytes
2n;

Try it online!

CellTail, 8 bytes
I=2;O=N;

Try it
Explanation:

I=2 sets the initial state to 2.
O=N sets the output format to numbers.

I should really get around to setting up these things as flags.


text:
Modify The Stack
Let's say you have a stack, which at the start contains a b c in this order (a is on the top). You are given the required output stack, in any reasonable format (a list, a string, etc.), e.g. [a, c, b] (here a is on the top, below it c and below it b). You can also take the input reversed if you want, e.g. [b, c, a] where a is in the top
Your task is to output the shortest sequence of operations to achieve that stack formation, and you may assume that there is such sequence, and it's shorter than 10 moves:

s - swap the top two elements of the stack, a b c -> b a c
d - duplicate the top element of the stack, a b c -> a a b c
t - swap (or rotate) the top three elements of the stack, a b c -> b c a

You may call the input/operations whatever you want, as long as it's consistent.
Examples
['a', 'c', 'b'] -> st
([a b c] [b a c] [a c b])
['a','a','b','c'] -> d
['a','b','a','b','c'] -> sdtsdt
([a b c] [b a c] [b b a c] [b a b c] [a b b c] [a a b b c] [a b a b c]) (sdttdt is also valid)
['c','b','a'] -> ts

This is an example ungolfed algorithm which solves it: https://pastebin.com/9UemcUwj
Score
This is a codegolf, so the shortest answer wins. good luck!

right, I've found it and forgot to update, sorry

@Noodle9 sorry, I've accidentally put there an impossible sequance

should be fixed now

Works fine now! :-)

It looks to be like the stacks that can be created are exactly those where the bottom element appears nowhere else, and all three symbols are present. Can anyone confirm or disconfirm this?

@xnor I think so too. Maybe one could solve this as (sequence to put the correct bottom item) + (sequence to generate the rest from two items).

@xnor You're indeed correct. When we don't use any duplicates, the swaps and triple-swaps could put the three values in any order. But as soon as a duplicate is used, the at that point bottom item on the stack will remain the bottom item, since the swap and triple-swap can no longer touch this fourth item on the stack.

@KevinCruijssen Thanks for the observation. I needed to also convince myself that we can always avoid making one of the two remaining elements "go extinct". For instance, if you try to create b a a a b c and do a b c ->  a a b c -> a a a b c, you get stuck. But, you can avoid this by doing a b c -> b a c -> b b a c -> a b b c -> a a b b c -> a b a b c -> a a b a b c -> b a a a b c. (I'm writing any permutation of the top 3 elements as a single step.) In particular, you should always keep two copies of the next element that you need to commit. I hope this allows a short direct solution.

@xnor: You can always do this using s and dt, but the result may not be optimal, for instance the naïve algorithm uses sdt instead of d for the second test case.

No, that's just a coding error - my test code can't handle a repetition.

Better still, you only mostly need d and t; you just need to be careful of the two test cases acb and cba.

@xnor: My first attempt at the direct approach was longer than my brute force solution, but I was eventually able to golf it down so it's now three bytes shorter!

Python 2, 117 bytes
Simple BFS brute-force algorithm, outputs to STDERR.
t=input()
l=[('abc','')]
for s,o in l:s==t>exit(o);l+=(s[1:3]+s[0]+s[3:],o+'t'),(s[0]+s,o+'d'),(s[1::-1]+s[2:],o+'s')

Try it online!
Combined with Surcoloses way of generating the new stacks, this gets to 97 bytes: Try it online!

Took me a while to understand s==t>exit(o). Simply awesome!

97 bytes by using 1,2,3 instead of d,s,t which allows shorter way to generate new stack.

@SurculoseSputum thanks for the suggestion. I have added this as a note, since I feel this more similar to your answer than to mine.

JavaScript (ES6), 79 bytes
Expects 460 instead of abc. Output format: \$1\$ = swap, \$2\$ = duplicate and \$3\$ = rotate.
Same logic as the main version, but with a less readable input format which was chosen to optimize the lookup table.
f=s=>([a,b,c]=s,d=s.slice(3))?a-b?f(c+a+b+d)+3:f(b+c+d)+2:[[13,31,3,1,33][s%7]]

Try it online!

JavaScript (ES6),  100 ... 84  81 bytes
Expects 012 instead of abc. Output format: \$1\$ = swap, \$2\$ = duplicate and \$3\$ = rotate.
f=s=>([a,b,c]=s,d=s.slice(3))?a-b?f(c+a+b+d)+3:f(b+c+d)+2:[[3,33,31,,,13,1][s&7]]

Try it online!
How?
This solves the problem by starting with the input string and transforming it back into "012".
Step 1
The first step of the algorithm is to reverse duplicate and rotate operations until the string is exactly 3-character long.
We can notice that given an input string of length \$n\$, there are necessarily \$n-3\$ duplicate.
We can reverse a duplicate operation whenever the first 2 characters of the string are equal.
If the first 2 characters are not equal and the string is still longer than 3 characters, it means that we have to reverse a rotate. (It can't be a swap because the first 2 characters would still be different.)
We need to reverse at most 2 consecutive rotate before we can reverse the next duplicate. (If it still doesn't work after 2 reversed rotate, it means that the input is invalid.)
Step 2
Once we have a string \$s\$ which is 3-character long, we use a lookup table to figure out how "012" can be turned into \$s\$ with as few operations as possible:
"012" : no operation
"021" : "st" because t(s("012")) = t("102") = "021"
"102" : "s"  because s("012") = "102"
"120" : "t"  because t("012") = "120"
"201" : "tt" because t(t("012")) = t("120") = "201"
"210" : "ts" because s(t("012")) = s("120") = "210"

The lookup table works by coercing the string to an integer an applying a modulo \$8\$.
 string | mod 8
--------+-------
  "012" |   4
  "021" |   5
  "102" |   6
  "120" |   0
  "201" |   1
  "210" |   2

Commented
f = s =>               // s = input string
  (                    //
    [a, b, c] = s,     // split the first 3 characters as a, b and c
    d = s.slice(3)     // d = all remaining characters after the 3 first ones
  ) ?                  // if d is not empty:
    a - b ?            //   if a is not equal to b:
      f(c + a + b + d) //     reverse a 'rotate' by re-ordering the first 3 characters
      + 3              //     append a "3"
    :                  //   else:
      f(b + c + d)     //     reverse a 'duplicate' by removing the leading character
      + 2              //     append a "2"
  :                    // else:
    [                  //   make sure the following result can be coerced to a string:
      [                //     lookup table:
        3              //       0: "120" -> "t" encoded as "3"
        33,            //       1: "201" -> "tt" encoded as "33"
        31,            //       2: "210" -> "ts" encoded as "31"
        ,              //       3: not used
        ,              //       4: "012" -> no operation
        13,            //       5: "021" -> "st" encoded as "13"
        1              //       6: "102" -> "s" encoded as "1"
      ]                //
      [s & 7]          //     compute s mod 8
    ]                  //

Haskell, 111 110 bytes
g s=[b|(a,b)<-zip f o,a==s]!!0
f="abc":(f>>=k)
k w@(a:b:c:s)=[b:c:a:s,a:w,b:a:c:s]
o="":[x++[w]|x<-o,w<-"tds"]

Try it online!
Finds the position of the target stack in an infinite list of possible stacks f, then uses the result to index into the infinite list of operations o.

Python 3.8, 105 bytes
f=lambda r,i=0,j=1,s="abc",*l:(t:=i%4)and f(r,i//4,j,s[t>1:t]+s[0]+s[t:],*l,t)or f(r,j,j+1)if s!=r else l

Try it online!
Input: A string representing the goal stack, where the first character of the string is the top of the stack.
Output: A tuple of 0,1,2 representing d,s,t respectively.
This is a brute-force recursive search that simply tries all possible operation sequences of increasing size.

102 bytes if the solution doesn't have to deal with the edge case "abc"
f=lambda r,i=0,j=1,s="abc",*l:(t:=i%4)and f(r,i//4,j,s[t>1:t]+s[0]+s[t:],*l,t)or(s==r)*l or f(r,j,j+1)

Try it online!

How:
Given the stack s as a string, and an operation t = 1, 2, or 3 reperesenting d, s, t respectively, the resulting stack is:
s[t>1:t]+s[0]+s[t:]

A sequence of operations can be encoded as a single integer j, and decoded using division and mod. The solution simply increment j, then test if j can produces the goal stack. This guarantees that the result sequence is the shortest.
The argument i keeps track of the remaining operations in the current sequence. l is the tuple of operations performed.

Retina 0.8.2, 88 82 79 bytes
^(.)(\1[a-c]+)
$2d
}`^(.)(.)(\1|\2)([a-c]+)
$3$1$2$4t
abc

ac|bac?
s
a

bc?|c
t

Try it online! Link includes test cases. Uses @xnor's direct approach. Explanation:
^(.)(\1[a-c]+)
$2d

If the first two characters are the same, then they must have just been duplicated, so output a d and remove the first character. (The [a-c] ensures that the outputs collect in reverse order.)
^(.)(.)(\1|\2)([a-c]+)
$3$1$2$4t

If the third character is one of the first two, then try rotating the stack.
}`

Repeat the above stages until the three characters are all different, in which case they should be the last three.
abc

If they are abc then there is nothing left to do.
ac|bac?
s

acb, bac, and cba all need a swap. For bac this completes the operations; acb needs a rotation after the swap, while cba needs a rotation before the swap. Leaving a b or c behind will achieve this later.
a

Remove any remaining as as they have nothing left to contribute.
bc?|c
t

Any remaining bs and cs indicate rotations, except that bc is just one rotation.
Previous brute-force 82-byte solution:
$
¶abc:
{`^(.+)¶(.+¶)*\1:(.*)(¶.+)*$
$3
(.)(.)(.)(.*:.*)
$2$1$3$4s¶$1$&d¶$2$3$1$4t

Try it online! Link includes test cases. Edit: Saved 6 bytes thanks to @someone. Explanation:
$
¶abc:

Append the initial position to the input.
{`

Repeat until a solution is found.
^(.+)¶(.+¶)*\1:(.*)(¶.+)*$
$3

If the input matches an output stack, delete everything except the output sequence.
(.)(.)(.)(.*:.*)
$2$1$3$4s¶$1$&d¶$2$3$1$4t

For each position, compute the three positions arising from applying each of the three operators.

I think $1$2$3$4 -> $0.

@someone Bah, I spent ages trying to think of ways to simplify all of those $s and yet overlooked the obvious one...

In fact, I thought about the ages I'd spend trying to simplify all of those $s and decided not to write a Retina answer :)

05AB1E, 21 18 17 bytes
g…sŠD×æé.Δ₁`r.V)Q

-1 byte by taking the input as 256 (₁) for abc respectively, instead of ABC (žR) I had prior.
Takes the input in reversed order using the characters 256 for abc respectively.
Outputs s for swap; D for duplicate; and Š for triple swap/rotate.
Try it online or verify all test cases.
Explanation:
g           # Get the length of the (implicit) input-list
 …sŠD       # Push the string "sŠD"
     ×      # Repeat it the length amount of times
      æ     # Take the powerset of this
       é    # Sort them by length
            #  i.e. input-length=3 → ["","s","Š","D","s","Š","D","s","Š","D","sŠ","sD","ŠD","ss","Šs","Ds","sŠ","ŠŠ","DŠ","sŠ","sD","ŠD","DD","sD","ŠD","ss","Šs","Ds","ss","Šs","Ds","sŠ","ŠŠ","DŠ","sŠ","ŠŠ","DŠ","sŠ","sD","ŠD","DD","sD","ŠD","DD","sD","ŠD","sŠD","sŠs","sDs","ŠDs","sŠŠ","sDŠ","ŠDŠ","ssŠ","ŠsŠ","DsŠ","sŠD","sDD","ŠDD","ssD","ŠsD","DsD","sŠD","ŠŠD","DŠD","sŠD","sŠs","sDs","ŠDs","sss","Šss","Dss","sŠs","ŠŠs","DŠs","sŠs","sDs","ŠDs","DDs","sDs","ŠDs","sŠŠ","sDŠ","ŠDŠ","ssŠ","ŠsŠ","DsŠ","sŠŠ","ŠŠŠ","DŠŠ","sŠŠ","sDŠ","ŠDŠ","DDŠ","sDŠ","ŠDŠ","ssŠ","ŠsŠ","DsŠ","ssŠ","ŠsŠ","DsŠ","sŠD","sDD","ŠDD","ssD","ŠsD","DsD","sŠD","ŠŠD","DŠD","sŠD","sDD","ŠDD","DDD","sDD","ŠDD","ssD","ŠsD","DsD","ssD","ŠsD","DsD","sŠD","ŠŠD","DŠD","sŠD","ŠŠD","DŠD","sŠD","sŠDs","sŠDŠ","sŠsŠ","sDsŠ","ŠDsŠ","sŠDD","sŠsD","sDsD","ŠDsD","sŠŠD","sDŠD","ŠDŠD","ssŠD","ŠsŠD","DsŠD","sŠDs","sŠss","sDss","ŠDss","sŠŠs","sDŠs","ŠDŠs","ssŠs","ŠsŠs","DsŠs","sŠDs","sDDs","ŠDDs","ssDs","ŠsDs","DsDs","sŠDs","ŠŠDs","DŠDs","sŠDs","sŠDŠ","sŠsŠ","sDsŠ","ŠDsŠ","sŠŠŠ","sDŠŠ","ŠDŠŠ","ssŠŠ","ŠsŠŠ","DsŠŠ","sŠDŠ","sDDŠ","ŠDDŠ","ssDŠ","ŠsDŠ","DsDŠ","sŠDŠ","ŠŠDŠ","DŠDŠ","sŠDŠ","sŠsŠ","sDsŠ","ŠDsŠ","sssŠ","ŠssŠ","DssŠ","sŠsŠ","ŠŠsŠ","DŠsŠ","sŠsŠ","sDsŠ","ŠDsŠ","DDsŠ","sDsŠ","ŠDsŠ","sŠDD","sŠsD","sDsD","ŠDsD","sŠŠD","sDŠD","ŠDŠD","ssŠD","ŠsŠD","DsŠD","sŠDD","sDDD","ŠDDD","ssDD","ŠsDD","DsDD","sŠDD","ŠŠDD","DŠDD","sŠDD","sŠsD","sDsD","ŠDsD","sssD","ŠssD","DssD","sŠsD","ŠŠsD","DŠsD","sŠsD","sDsD","ŠDsD","DDsD","sDsD","ŠDsD","sŠŠD","sDŠD","ŠDŠD","ssŠD","ŠsŠD","DsŠD","sŠŠD","ŠŠŠD","DŠŠD","sŠŠD","sDŠD","ŠDŠD","DDŠD","sDŠD","ŠDŠD","ssŠD","ŠsŠD","DsŠD","ssŠD","ŠsŠD","DsŠD","sŠDsŠ","sŠDsD","sŠDŠD","sŠsŠD","sDsŠD","ŠDsŠD","sŠDss","sŠDŠs","sŠsŠs","sDsŠs","ŠDsŠs","sŠDDs","sŠsDs","sDsDs","ŠDsDs","sŠŠDs","sDŠDs","ŠDŠDs","ssŠDs","ŠsŠDs","DsŠDs","sŠDsŠ","sŠDŠŠ","sŠsŠŠ","sDsŠŠ","ŠDsŠŠ","sŠDDŠ","sŠsDŠ","sDsDŠ","ŠDsDŠ","sŠŠDŠ","sDŠDŠ","ŠDŠDŠ","ssŠDŠ","ŠsŠDŠ","DsŠDŠ","sŠDsŠ","sŠssŠ","sDssŠ","ŠDssŠ","sŠŠsŠ","sDŠsŠ","ŠDŠsŠ","ssŠsŠ","ŠsŠsŠ","DsŠsŠ","sŠDsŠ","sDDsŠ","ŠDDsŠ","ssDsŠ","ŠsDsŠ","DsDsŠ","sŠDsŠ","ŠŠDsŠ","DŠDsŠ","sŠDsŠ","sŠDsD","sŠDŠD","sŠsŠD","sDsŠD","ŠDsŠD","sŠDDD","sŠsDD","sDsDD","ŠDsDD","sŠŠDD","sDŠDD","ŠDŠDD","ssŠDD","ŠsŠDD","DsŠDD","sŠDsD","sŠssD","sDssD","ŠDssD","sŠŠsD","sDŠsD","ŠDŠsD","ssŠsD","ŠsŠsD","DsŠsD","sŠDsD","sDDsD","ŠDDsD","ssDsD","ŠsDsD","DsDsD","sŠDsD","ŠŠDsD","DŠDsD","sŠDsD","sŠDŠD","sŠsŠD","sDsŠD","ŠDsŠD","sŠŠŠD","sDŠŠD","ŠDŠŠD","ssŠŠD","ŠsŠŠD","DsŠŠD","sŠDŠD","sDDŠD","ŠDDŠD","ssDŠD","ŠsDŠD","DsDŠD","sŠDŠD","ŠŠDŠD","DŠDŠD","sŠDŠD","sŠsŠD","sDsŠD","ŠDsŠD","sssŠD","ŠssŠD","DssŠD","sŠsŠD","ŠŠsŠD","DŠsŠD","sŠsŠD","sDsŠD","ŠDsŠD","DDsŠD","sDsŠD","ŠDsŠD","sŠDsŠD","sŠDsŠs","sŠDsDs","sŠDŠDs","sŠsŠDs","sDsŠDs","ŠDsŠDs","sŠDsŠŠ","sŠDsDŠ","sŠDŠDŠ","sŠsŠDŠ","sDsŠDŠ","ŠDsŠDŠ","sŠDssŠ","sŠDŠsŠ","sŠsŠsŠ","sDsŠsŠ","ŠDsŠsŠ","sŠDDsŠ","sŠsDsŠ","sDsDsŠ","ŠDsDsŠ","sŠŠDsŠ","sDŠDsŠ","ŠDŠDsŠ","ssŠDsŠ","ŠsŠDsŠ","DsŠDsŠ","sŠDsŠD","sŠDsDD","sŠDŠDD","sŠsŠDD","sDsŠDD","ŠDsŠDD","sŠDssD","sŠDŠsD","sŠsŠsD","sDsŠsD","ŠDsŠsD","sŠDDsD","sŠsDsD","sDsDsD","ŠDsDsD","sŠŠDsD","sDŠDsD","ŠDŠDsD","ssŠDsD","ŠsŠDsD","DsŠDsD","sŠDsŠD","sŠDŠŠD","sŠsŠŠD","sDsŠŠD","ŠDsŠŠD","sŠDDŠD","sŠsDŠD","sDsDŠD","ŠDsDŠD","sŠŠDŠD","sDŠDŠD","ŠDŠDŠD","ssŠDŠD","ŠsŠDŠD","DsŠDŠD","sŠDsŠD","sŠssŠD","sDssŠD","ŠDssŠD","sŠŠsŠD","sDŠsŠD","ŠDŠsŠD","ssŠsŠD","ŠsŠsŠD","DsŠsŠD","sŠDsŠD","sDDsŠD","ŠDDsŠD","ssDsŠD","ŠsDsŠD","DsDsŠD","sŠDsŠD","ŠŠDsŠD","DŠDsŠD","sŠDsŠD","sŠDsŠDs","sŠDsŠDŠ","sŠDsŠsŠ","sŠDsDsŠ","sŠDŠDsŠ","sŠsŠDsŠ","sDsŠDsŠ","ŠDsŠDsŠ","sŠDsŠDD","sŠDsŠsD","sŠDsDsD","sŠDŠDsD","sŠsŠDsD","sDsŠDsD","ŠDsŠDsD","sŠDsŠŠD","sŠDsDŠD","sŠDŠDŠD","sŠsŠDŠD","sDsŠDŠD","ŠDsŠDŠD","sŠDssŠD","sŠDŠsŠD","sŠsŠsŠD","sDsŠsŠD","ŠDsŠsŠD","sŠDDsŠD","sŠsDsŠD","sDsDsŠD","ŠDsDsŠD","sŠŠDsŠD","sDŠDsŠD","ŠDŠDsŠD","ssŠDsŠD","ŠsŠDsŠD","DsŠDsŠD","sŠDsŠDsŠ","sŠDsŠDsD","sŠDsŠDŠD","sŠDsŠsŠD","sŠDsDsŠD","sŠDŠDsŠD","sŠsŠDsŠD","sDsŠDsŠD","ŠDsŠDsŠD","sŠDsŠDsŠD"]
.Δ          # Then find the first string which is truthy for:
  ₁         #  Push the builtin 256
   `        #  Pop and push them separated to the stack
    r       #  Reverse the stack, so the order is [6,5,2,string]
     .V     #  Execute the string as 05AB1E code
       )    #  Wrap all values on the stack into a list
        Q   #  And check that it's equal to the (implicit) input-list

Ruby, 126 bytes
->s{*w='',321;(a,b,*w=w;w<<a+?d<<b*10+(k=b%10)<<a+?s<<b+k*10-(z=b%100)+z/10<<a+?t<<b+k*100-(x=b%1000)+x/10)until w[1]==s;w[0]}

Try it online!