text:
Determine the area enclosed by slashes
For example, let's look at the following ASCII art:
/\    - encloses a total of 2 cells - half a cell per slash
\/
 /\   - encloses 4 cells fully and half of 8 cells, for a total of 8
/  \
\  /
 \/

Your challenge is to write a program that determines (and outputs) the total area enclosed by ASCII art composed only of spaces, slashes and newlines. Slashes won't necessarily be a part of a shape with non-zero area. A point is defined as enclosed iff it is unreachable from any point outside the art's bounding box, if slashes are impassable.
Slashes have zero area and cells are assumed to be \$1\times1\$ squares. /s represent lines that connect the lower left corner with the upper right corner, and \s represent lines the connect the upper left corner with the lower right corner of the corresponding cells. Spaces represent empty space.
Test cases
/\/\
\   \
 \/\/

Encloses 3 cells fully and 10 partially, for a total of 8.
///\\\
//  \\
/ /\ \
\ \/ /
\\  //
\\\///

Encloses 12 cells fully (the four innermost slashes have both corresponding half-cells enclosed) and half of 12 cells, for a total of 18.
/\/\
/\/\
/\/\

Encloses 0 cells.
 /\
/  \
\/\/
/\/\
\  /
 \/

Encloses 8 cells fully and 12 cells partially, for a total of 14.
   /\
  /  \
 /  \ \
/   /  \
\ \/  \/
 \ \  /
  \   \
   \/\/

Encloses 25 cells fully and half of 18 cells, for an area of 34.
This is tagged code-golf, so the shortest answer wins.

Deleted sandbox post

@KrzysztofSzewczyk A possible solution is a graph search, where all cells are split into four quarters (and connections are removed depending on the placement of slashes). The number of quarter-cells not reached is four times the area asked for.

I'd like to hear the reasons for the downvote.

It's the point that is to the upper left of the upper left corner, although that doesn't matter: any point that is outside the art's bounding box works. I guess I'll change it to that.

May we assume rectangular input?

Do you mean that the input will never be square, or that it will be padded with spaces to an equal length? The latter is okay.

It saves me a few bytes if the first line is the (equal) longest, which is trivially satisfied for rectangular input.

Closely related

JavaScript (ES6),  228 195 192  185 bytes
Expects a matrix of characters as input.
This can be quite slow on some inputs, such as the last test case.
m=>m.map((r,Y)=>r.map((_,X)=>n+=(g=(x,y,z,q=z&2,r=m[y],v=r&&r[x])=>v?(v|=64+(v>{})+!++v)^(r[x]|=v|4<<z)?g(x+--q*~z%2,y-q*z%2,z^2)&g(x,y,v&3?z^=v&2|1:z+1&3)|!(r[x]=v):1:0)(X,Y,0)),n=0)|n

Try it online!
How?
Grid encoding
We divide each cell into 4 areas as follows:

The current position is encoded as \$(x,y,z)\$, where \$(x,y)\$ is the position in the matrix and \$z\$ is the ID of the area.
The characters in the original matrix are converted on the fly to 7-bit integers as they are visited:
+---------> a marker to tell that this tile has been converted (always 1)
|      +--> 4 bits to tell whether a given area has been visited
|      |
|      |      +-----> set to 1 if the cell contains an anti-slash
|  ____|____  |  +--> set to 1 of the cell contains a slash
| /         \ |  |
1 z3 z2 z1 z0 AS S

The conversion is done with:
v |= 64 + (v > {}) + !++v

The expression (v > {}) is only true for '\' and !++v is true for either '/' or '\'. If v is already an integer, it is left unchanged.
Algorithm
Evaluating the area enclosed by slashes is equivalent to counting the number of cells from which we can't escape from the grid, starting from a given area ID. We arbitrary start from area #0, but that would work with any of them as long as it is consistent.
We iterate on all possible starting points and process some kind of flood-filling that takes the area IDs into account.
For each visited cell, we try to move to an adjacent cell (left figure) and  to another area within the same cell (right figure).

The recursion stops either when we escape the grid or when we get trapped.

J, 108 95 93 91 83 80 77 bytes
-13 due using 4x4 instead of 3x3 masks
-7 thanks to Jonah
-2 5 thanks to Bubbler
This expands the ASCII to a 4 times as big bit map that gets searched in for enclosed spaces. Maybe you can do the calculations on the original map, but at least this approach works for now. :-)
[:+/@,12%~1=2|.@|:@(2(>.*])/\,)^:4^:_[:,"_1/^:2((+./~#:9),-.(,:|.)=i.4){~' \'i.]

Try it online!
How it works
Ungolfed:
12 +/@,@:%~
1=
((,-)=i.2) (] * >./@:(|.!.2))^:_
((+./~#:9) , -. (,:|.)=i.4) ,"_1/^:2@:{~ ' \/'i. ]

Build up 3x4x4 masks, where 0 is a wall:
((+./~#:9) , -. (,:|.)=i.4)

1 1 1 1
1 0 0 1
1 0 0 1
1 1 1 1

0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0

1 1 1 0
1 1 0 1
1 0 1 1
0 1 1 1

That expands each character ' \/'. So from a 3x4 drawing we get a 12x16 bit mask. The empty space has 12 1's (while still allowing traversal) and each side of a slash has 6.
,"_1/^:2@:{~' \/'i.]

Then shift the matrix in the four directions by rotating the matrix. At the borders 2 gets shifted in. The resulting matrices are added up together by taking the highest value (so 2 expands), while 0 in the matrix deletes (so borders blocks expansions). We do this until the result does not change (…)^:_.
2|.@|:@(2(>.*])/\,)^:4^:_

We are interested in the 1's that still stand. And because of our bit masks, we can simply divide by 12 of the total sum of all 1's to get the result.
12 +/@,@:%~

I do not know J at all, so the only characters I understand here are digits, but is the first mask supposed to be all walls?

I mixed up 0's and 1's there. :-)

And that just gave me an idea to golf this further; the empty tile has now walls in the center!

Really like this approach, nice work.  Small improvements: 86 bytes

84 bytes

81 bytes by porting my APL answer at some parts.

77 bytes.

Charcoal, 114 100 96 91 bytes
ＷＳ⊞υιＦυ«Ｊ⁰⁺³ⅉＦι«Ｍ³→≡κ/Ｐ/²\Ｐ\²»»≔⁺²Ｌθθ≔⁺²ＬυυＪ±¹±¹Ｂ×³θ×³υψ¤#ＦυＦθ«Ｊ×³κ×³ιＰX²»≔Ｉ÷⁻×⊗υ⊗θ№ＫＡ#⁴θ⎚θ

Try it online! Link is to verbose version of code. Assumes rectangular input. Explanation:
ＷＳ⊞υι

Input the art.
Ｆυ«Ｊ⁰⁺³ⅉ

Loop over each row of the art.
Ｆι«Ｍ³→

Loop over each cell of the art.
≡κ/Ｐ/²\Ｐ\²»»

Output it at three times its original size.
≔⁺²Ｌθθ≔⁺²Ｌυυ

Adjust the size of the art for a notional 1-square border on each side.
Ｊ±¹±¹Ｂ×³θ×³υψ

Draw a notional box around the notional border. This allows the border to be filled without actually having drawn anything.
¤#

Fill the exterior of the art with #. Sadly Charcoal doesn't support multiline fill patterns. (Its fill was designed for the challenge, Bake a slice of Pi.)
ＦυＦθ«Ｊ×³κ×³ιＰX²»

Draw Xs at every position (including the notional border), overwriting all the existing spaces and slashes. This means that each square now has only four #s (or fewer if it didn't get completely filled in).
≔Ｉ÷⁻×⊗υ⊗θ№ＫＡ#⁴θ

Calculate the number of #s that there would have been had the art originally been empty (including the border), subtract the number of #s actually filled, then divide by 4.
⎚θ

Clear the canvas and output the result.
Alternative solution, based on @xash's idea of 4×4 masks, also 91 bytes:
≔⪫  ⭆θ θ⊞υθＷＳ⊞υ⪫  ι⊞υθＢ×⁴Ｌθ×⁴ＬυψＦＬυＦＬθ«Ｊ×⁴κ×⁴ι≡§§υικ «↘ＵＲ²»/«↓↓↓↗⁴»↘⁴»↖¤#≔Ｉ⁻×ＬυＬθ÷№ＫＡ#¹²θ⎚θ

Try it online! Link is to verbose version of code. Assumes rectangular input. Explanation:
≔⪫  ⭆θ θ⊞υθ

Generate a padding row.
ＷＳ⊞υ⪫  ι

Input the art padded on both sides.
⊞υθ

Add padding to the bottom of the art.
Ｂ×⁴Ｌθ×⁴Ｌυψ

Draw a notional box around the padded art. This allows the padding to be filled without actually having drawn anything.
ＦＬυＦＬθ«

Loop over each cell of the art.
Ｊ×⁴κ×⁴ι

Jump to the cell.
≡§§υικ «↘ＵＲ²»/«↓↓↓↗⁴»↘⁴

Draw the cell at four times size, except that space becomes a dot. This means that it takes up the same amount of space as a / or \ but without impeding the flood fill.
»↖¤#

Move the cursor off the last dot so that the exterior of the art can be flood filled with #.
≔Ｉ⁻×ＬυＬθ÷№ＫＡ#¹²θ

Divide the number of #s by 12, and subtract that from the padded size of the art.
⎚θ

Clear the canvas and output the result.

APL (Dyalog Unicode), 67 bytes
12÷⍨≢⍸1=(⍉∘⌽2(⌈∧⊢)/2,⊢)⍣4⍣≡⊃⍪/,/({(∘.∨⍨1=3|⍳4)(⌽⍵)⍵}∘.≠⍨⍳4)[' /'⍳⎕]

Try it online!
A port of xash's excellent J answer.
How it works
12÷⍨≢⍸1=(⍉∘⌽2(⌈∧⊢)/2,⊢)⍣4⍣≡⊃⍪/,/({(∘.∨⍨1=3|⍳4)(⌽⍵)⍵}∘.≠⍨⍳4)[' /'⍳⎕]

⊃⍪/,/({(∘.∨⍨1=3|⍳4)(⌽⍵)⍵}∘.≠⍨⍳4)[' /'⍳⎕]  ⍝ Preprocessing
     (                         )          ⍝ Create 3 bitmasks
                         ∘.≠⍨⍳4           ⍝ Negated identity matrix of size 4
      {            (⌽⍵)⍵}                 ⍝ Strand with its reflection, and
       (∘.∨⍨1=3|⍳4)                       ⍝ Self OR outer product of 1 0 0 1
                                [' /'⍳⎕]  ⍝ Convert three chars ' /\' to respective bitmasks
   ,/  ⍝ Join horizontally adjacent arrays horizontally
 ⍪/    ⍝ and vertically adjacent ones vertically
⊃      ⍝ Remove nesting

12÷⍨≢⍸1=(⍉∘⌽2(⌈∧⊢)/2,⊢)⍣4⍣≡  ⍝ Flood fill from the outside, and find the answer
        (          2,⊢)      ⍝ Prepend 2 on each row
            2(⌈∧⊢)/          ⍝ Pairwise reduce: (x,y)→lcm(max(x,y),y)
                             ⍝ Effectively, if left is 2 and right is nonzero, make it 2;
                             ⍝ keep the right one otherwise
         ⍉∘⌽                 ⍝ Rotate the matrix 90 degrees
                       ⍣4⍣≡  ⍝ Repeat on the four sides, until the flood fill is complete
12÷⍨≢⍸1=  ⍝  Count ones, and divide by 12

MATL, 51 50 49 bytes
Ji^G8\*TTYa3XytPJ*-X*Xj~4&1ZIt1)0hm3thZCS6:Y)~Yms

Input is a char matrix, with ; as row separator.
Try it online! Or verify all test cases
Explanation
The approach is similar to that used in my answer to this other challenge.
J        % Push imaginary unit, j
i        % Take input: char matrix
^        % Element-wise power of j raised to the code points of the input.
         % This gives -j, 1, 1 for '/', '\' and ' ' respectively
G        % Push input again
8\       % Modulo 8, element-wise. This gives 7, 4 0 for '/', '\' and ' '
         % respectively. The specific values do not matter; it only matters
         % that ' ' gives 0 and the other chars give nonzero
*        % Multiply. Now we have a matrix that contains -7, 4 and 0 for
         % '/', '\' and ' ' (*)
TTYa     % Pad array with a 2D frame of zeros of length 1
3Xy      % Push 3×3 identity matrix
tP       % Duplicate, flip vertically
J*-      % Multiply by imaginary unit and subtract. This gives the matrix
         % [1 0 -j; 0 1-j 0; -j 0 1] (**)
X*       % Kronecker product. This replaces each entry of (*) by its
         % product with (**)
Xj       % Real part. We now have a matrix where '/', '\' and ' ' have been
         % transformed into [0 0 -7; 0 -7 0; -7 0 0], [4 0 0; 0 4 0; 0 0 4]
         % and [0 0 0; 0 0 0; 0 0 0] respectively
~        % Negate. We now have a matrix with "pixelated" versions of the
         % input chars at 3 times greater resolution, with an empty frame.
         % Pixels equal to 1 are empty space, and pixels equal to 0 are
         % borders corresponding to the original slash chars
4&1ZI    % Label connected components based on 4-neighbourhood. This
         % transformes the pixels which contained 1 into different numbers
         % We are interested in the area not occupied by the outer
         % connected component and the borders
t1)      % Duplicate. Value of the upper-left corner. This gives the label
         % of the outer component
0h       % Append 0. This is the value of the borders
m        % Ismember: this gives true for pixels that are outer component
         % or border. Each original cell corresponds to a 3×3 block of
         % pixels. Each of those blocks will contain 9 zeros for cells
         % that were fully enclosed; 6 zeros for cells with its two halves
         % enclodes but with a border in between; 3 zeros for cells with
         % one of its halves enclosed, and 0 zeros for cells not enclosed
3thZC    % Matrix where each distinct 3×3 block has been arranged into
         % a column of length 9
S        % Sort. This sends 1 to the bottom and 0 to the top
6:Y)     % Keep the first 6 rows. This effectively transforms columns with
         % 9 zeros into columns of 6 zeros. So now we have 0, 3 or 6 zeros
         % for not covered, partically covered or fully covered cells
~        % Logical negation
Ym       % Mean of each column. This transforms the 0, 3, and 6 numbers
         % referred to above into 0, 0.5 or 1
s        % Sum. Implicit display

Thanks for linking to that other challenge; comparing my answers, I found that I'd already used at least one of my golfs from the other answer, but there was another golf that I hadn't thought of.


text:
Write a crochet pattern generator
Introduction
I crochet a lot, and lately I've started writing crochet patterns. However, while I work very well from notes such as rnds 2-6 (round number = x, original number of stitches = y): *dc x-2 stitches, 2 dc in next stitch* around (xy stitches), most published patterns spell out each row in more detail. I don't like writing out each individual row/round myself though, so I want to have a program do it for me.
Challenge
The challenge is to write a program or function that takes three mandatory inputs (r, s, and y) and returns a string of the pattern.
Inputs
The inputs can go in any appropriate order or format, just please point that out so others can run your code.
R is an integer corresponding to the number of rounds/rows (use whichever designation you want) to generate. S is a string corresponding to the type of stitch. This can be guaranteed to be one of the following strings: "tc", "dc", "hdc", "sc", or "ch". Y is the number of stitches in row/round 1, and the number of increases in each following row (for instance, if y=6, row 1 has 6 stitches, row 2 has 12 stitches, row 3 has 18 stitches, etc). In the general case: row x has xy stitches.
Outputs
The output is a list of strings with length r, in the following pattern.
O N: \*s in next N-2 stitches, 2 s in next stitch\* y times (NY stitches).
To clarify: it should return r strings, in order from least row/rnd number to greatest row/rnd number. The first row/rnd should be row 1, and the last row should be row r. In the template, replace s and y with the matching inputs, and N is the row number of the current row (N isn’t an input, just an integer that represents the current row). O is used to denote one of the following strings, your choice: “Row”, “Round”, or “Rnd”.
Each line of output should be separated by a newline. The period is necessary and should follow the parentheses.
Edge Cases
You can assume s is one of the listed strings. R will always be a positive integer, as will y.
You don’t have to do anything fancy for row 1, it can be Row 1: \*s in next -1 stitches, 2 s in next stitch\* y times (y stitches). Row 2 can also be outputted in the default format, as Row 2: \*s in next 0 stitches, 2 s in next stitch\* y times (2y stitches). Thusly, it can be outputted with a for loop. But, if you output rows 1 and 2 as Row 1: s in next y stitches (y stitches).\nRow 2: 2 s in next y stitches (2y stitches)., you can have -10% or -10 bytes, whichever is smaller, removed from your score.
Scoring
This is code golf, so fewest bytes wins. If you output rows 1 and 2 as shown in the Output section above, your score is lowered by -10% or -10 bytes, whichever is smaller.
Example Input and Output
Input [the format doesn’t matter so much as the answer, so it could be any format the language supports]: (r,s,y)

(5, “dc”, 6)
(3, “sc”, 1)
(6, “hdc”, 100)
(0, “ch”, 1)
(5, “tc”, 0)

Output [this format must be fairly exact, hyphens are used to show negative numbers]:

Row 1: \*dc in next -1 stitches, 2 dc in next stitch\* 6 times (6 stitches).\nRow 2: \*dc in next 0 stitches, 2 dc in next stitch\* 6 times (12 stitches).\nRow 3: \*dc in next 1 stitches, 2 dc in next stitch\* 6 times (18 stitches).\nRow 4: \*dc in next 2 stitches, 2 dc in next stitch\* 6 times (24 stitches).\nRow 5: \*dc in next 3 stitches, 2 dc in next stitch\* 6 times (30 stitches).
Rnd 1: \*sc in next -1 stitches, 2 sc in next stitch\* 1 times (1 stitches).\nRnd 2: \*sc in next 0 stitches, 2 sc in next stitch\* 1 times (2 stitches).\nRnd 3: \*sc in next 1 stitches, 2 sc in next stitch\* 1 times (3 stitches).\n
Rnd 1: \*hdc in next -1 stitches, 2 hdc in next stitch\* 100 times (100 stitches).\nRnd 2: \*hdc in next 0 stitches, 2 hdc in next stitch\* 100 times (200 stitches).\nRnd 3: \*hdc in next 1 stitches, 2 hdc in next stitch\* 100 times (300 stitches).\nRnd 4: \*hdc in next 2 stitches, 2 hdc in next stitch\* 100 times (400 stitches).\nRnd 5: \*hdc in next 3 stitches, 2 hdc in next stitch\* 100 times (500 stitches).\nRnd 6: \*hdc in next 4 stitches, 2 hdc in next stitch\* 100 times (600 stitches).\n
This can error, or not produce any output, or anything. R will always be positive and nonzero.
This can either error OR produce Rnd 1: \*tc in next -1 stitches, 2 tc in next stitch\* 0 times (0 stitches).\nRnd 2: \*tc in next 0 stitches, 2 tc in next stitch\* 0 times (0 stitches).\nRnd 3: \*tc in next 1 stitches, 2 tc in next stitch\* 0 times (0 stitches).\nRnd 4: \*tc in next 2 stitches, 2 tc in next stitch\* 0 times (0 stitches).\nRnd 5: \*tc in next 3 stitches, 2 tc in next stitch\* 0 times (0 stitches).

Suggestions for more test cases welcomed! Please let me know how to improve it. If you have an input/output that produces a pattern you like, add it to your answer and maybe I’ll crochet it when I have time.
Ungolfed solution in Python 2: Try it online

Perhaps you should be more lenient than this format must be exact. Would lists of the given strings be ok? Also there's a lot of *, -, and () dispersed through-out the output - can this be optional or removed?

A list of the strings is an acceptable output. The * ( ) characters I don’t think should be optional, they are part of the format of crochet patterns and show repeats and stitch count.

Great! I was more concerned about the commas, the periods, the colons and the dashes - can they be optional?

This was initially posted in the sandbox but I don’t know if I can post a link to a comment on a deleted post: reference implementation in Python 2 for an older version (should still work for the current specs). Try It Online

I think the periods and commas are probably optional, as long as the spacing is ok. I don’t see any dashes — only the hyphens showing subtraction, which are part of computing the output. What dashes do you see, @Noodle9?

Ah, didn't realise they where negative numbers. Maybe you should have a more formal description of the output format.

Can you use preformatted text (using 4 spaced indent) to show output in the examples? The use of a proportional font in combination with \n doesn't make it very readable.

@Abigail: 4 space indent didn’t seem to work, so I used backticks, but fixed that.

Why does the first example start each line with 'Row', but the others start with 'Rnd'?

The first two tests were generated from the original specs allowing an input for rows/rounds, so I flipped a coin to say what it would input. The other 3 were from edge cases that popped up with my code that I wanted to clarify, plus a bigger test case, so it was using a default value.

perl -M5.010 -a, 124 bytes
say"Row $_: \\*$F[1] in next ${\($_-2)} stitches, 2 $F[1] in next stitch\\* $F[2] times (${\($_*$F[2])} stitches)."for 1..$_

Try it online!
Pretty trivial. The bulk of the program consists of the line which needs to be printed, with some variable interpolation.

05AB1E, 62 bytes
EN³*³²NÍ²N“ ÿ: \*ÿ€†‚š ÿÀŠ, 2 ÿ€†‚šïŠ\* ÿ„Æ (ÿÀŠ).“'w't:'¢ã™ì,

Input in the same order as the challenge description, as three loose inputs \$r,s,y\$.
I've used Row for the optional first word, although Round and Rnd could both also be used for the same byte-count, by replacing '¢ã™ with 'í‰™ or …Rnd respectively.
Try it online or verify all test cases.
Explanation:
E        # Loop `N` in the range [1, (implicit) first input `r`]:
 N³*     #  Push `N` multiplied by the third input `y`
 ³       #  Push the third input `y`
 ²       #  Push the second input `s`
 NÍ      #  Push `N-2`
 ²       #  Push the second input `s` again
 N       #  Push `N`
 “ ÿ: \*ÿ€†‚š ÿÀŠ, 2 ÿ€†‚šïŠ\* ÿÀŠ (ÿ„Æ).“
         #  Push dictionary string " ÿ: \*ÿ in next ÿ switches, 2 ÿ in next switch\* ÿ times (ÿ switches).",
         #  where the `ÿ` are automatically replaced with the values on the stack
  'w't:  #  Replace all "w" with "t" ("switch" to "stitch")
  '¢ã   '#  Push dictionary string "row"
     ™   #  Titlecase it to "Row"
      ì  #  Prepend it in front of the string
       , #  And output it with trailing newline

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why “ ÿ: \*ÿ€†‚š ÿÀŠ, 2 ÿ€†‚šïŠ\* ÿ„Æ (ÿÀŠ).“ is " ÿ: \*ÿ in next ÿ switches, 2 ÿ in next switch\* ÿ times (ÿ switches)." and '¢ã is "row".

I'm not sure that your output is correct - it says (Ny times) instead of y times (Ny stitches).

And there should be \s before the *s... (fortunately I spotted that error in my code before the grace period expired!)

... except I forgot to update my byte count, oops...

@Neil Thanks for noticing. Should be fixed now. EDIT: After I've fixed the slashes. EDIT2: Done

Retina, 132 bytes
^\d+
*
Lv^$`(_+) (.+) (.+)
Row $.1: \$*$2 in next $1 stitches, 2 $2 in next stitch\$* $3 times ($.($3*$1) stitches).
__(_*)
$.1
_
-1

Try it online! Takes input in the order r, s, y. Explanation:
^\d+
*

Convert r to unary.
Lv^$`(_+) (.+) (.+)

Count down from r to 1, then reverse the results, and substitute in the output pattern:
Row $.1: \$*$2 in next $1 stitches, 2 $2 in next stitch\$* $3 times ($.($3*$1) stitches).

$.1 is the row, $* is a literal *, $2 is s, $1 is the row in unary, $3 is y, and $.($3*$1) is the product of the row with y (in decimal).
__(_*)
$.1

Subtract 2 from the row for the final substitution.
_
-1

Fix up the first row.

source: Stack Exchange

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

sort: votes


text:
Shortlex predecessor
Please note the special scoring for this challenge.
Given a non-empty string made of a-z, output the string immediately before it in the shortlex order.
Shortlex order
We enumerate strings in shortlex order by first listing the strings of length 0, then those of length 1, then length 2, and so on, putting them in alphabetical order for each length. This gives an infinite list of all strings. Said a bit differently, this sorts strings by length, tiebroken alphabetically.
For strings a-z as used in the challenge, this list goes (abridged):
(empty string)
a
b
c
...
z
aa
ab
...
az
ba
bb
...
zy
zz
aaa
aab
...

Scoring
Answers will be compared in shortlex order, with earlier being better.
Like in code golf, fewest bytes wins, but there's a tiebreak for same-length answers in favor of coming first alphabetically. This means that you'll want to further "golf" your answer to use characters with lower code points where this doesn't hurt its length. Characters nearer to the start are more important.
For non-ASCII languages, answers are treated as a sequence of bytes. Use the byte order of the code page to compare characters, not their UTF encoding.
For your answer's header, you can just put the code's length and say when you've outgolfed a same-length answer in the same language. You could also put the code's position in shortlex order if that number is not too long.
Input and output
The input string will be between 1 and 10 characters long, and consist only of letters a-z. As per site defaults, you may do I/O with strings as lists of characters or code points. The letters should be lowercase (code points 97-122).
Test cases
The first output is the empty string.
a ->
c -> b
z -> y
aa -> z
az -> ay
ba -> az
aaa -> zz
zaa -> yzz
golf -> gole
bzaaaaaaaa -> byzzzzzzzz
zzzzzzzzzz -> zzzzzzzzzy

Related: Smaller Strings in Printable ASCII base, Counting in bijective base 62

A real life example of this in use is the names of the columns in a spreadsheet. LibreOffice/OpenOffice Calc have a limit of AMJ columns. I think that Microsoft Excel 2019 has a limit of ZZZ columns...

Haskell, 64, 63, 56, 55 bytes

c is an infinite list of all strings composed of 97..122 in shortlex order.
\x y -> last$fst$span(/=x)y gives the predecessor of x in y

a b=last$fst$span(/=b)c
c=[]:[d++[e]|d<-c,e<-[97..122]]

Try it online!

1 byte saved by using code points: [97..122] vs. ['a'..'z']
9 bytes saved by ovs
1 bytes saved by Laikoni

Shortlex optimality
To get the lowest-ordered version of this code:

Each variable is chosen to be the smallest, front-to-back
The two lines are sorted (' ' < '=')

You need to put brackets around &s to make it a valid function. But you can write the predecessor function shorter as f x=last$takeWhile(/=x)s: Try it online!.

Note the scoring of the challenge. You can use smaller letters for instance.

f x=last$fst$span(/=x)s saves another byte.

Python 3.8, 67 65 bytes
Thanks @xnor for helping me get my shortlex score down!
A=lambda	B:(C:=B.pop())>97and	B+[C-1]or	A(B)+[122]if	B>[97]else[]

Try it online!
A recursive function that takes in a list of code points, and returns a list of code points.
Note that all spaces are replaced with tabs for smaller shortlex score.
Let C be the last character of the string, and B be the prefix. If C == "a", then the result is A(B) + "z". If C != "a", then the result is B + "{C-1}".
The base case is when the string is "" or `"a", in which case the function returns the empty string.

Same idea, but this function takes in and returns proper strings.
Python 3.8, 73 72 bytes
A=lambda	B:B>"a"and[B[:-1]+chr(C:=ord(B[-1])-1),A(B[:-1])+"z"][97>C]or""

Try it online!

Note the scoring of the challenge, which favors smaller variable names for instance.

Looks like underscore is actually bigger than capital letters.

@xnor You're right! I might have confused it with hyphen.

Turns out, tabs are smaller than spaces

Pyth, 8 bytes
ef!-TGrN

Try it online!
Throws an error for input a, but outputs nothing to STDOUT, which is technically the correct output.
Explanation
ef!-TGrN
      rN   Build a string range from the string '"' to the implicit input
 f         Filter for strings of this range satisfying:
  !         - the string becomes empty...
   -TG      - ...when all lowercase letters are removed
e          Take the last element

Note: N was used to start the range rather than d or k since it has a lower codepoint.

Ruby -pl, 29 13 bytes
*,$_=*?a...$_

Try it online!
Ironically, this task is essentially the opposite of Ruby's next (or alternatively succ) method on strings, however this potential previous method is not available out of the box. Therefore, to take advantage of existing functionality we have to loop through the range of strings (which is constructed using succ) from "a" all the way to the input (non-inclusive), and take the last position. Obviously, this will be too slow for the longer test cases.

I'm curious, how does this know to use only letters up to z?

@xnor It's implemented in such way that letters and digits cycle separately, you can see some examples in the docs

Retina 0.8.2, 22 bytes
(?=a+$)^a

T`l`zl`.a*$

Try it online! Link includes test cases. Explanation:
(?=a+$)^a

Remove one of the as if all of the letters are as. The lookahead is naturally placed before the anchor as it has a lower ASCII code.
T`l`zl`.a*$

Cyclically decrement any the trailing as and the previous letter.

JavaScript (ES6),  65 64  62 bytes
I/O: array of code points
$=>$.reduceRight((A,B,C)=>!C&($=$&&--B<97)?A:[$*26+B,...A],[])

Try it online!
Commented
$ =>                  // $[] = input array, reused for the carry
  $.reduceRight(      // for each
    (A, B, C) =>      // code point B at position C, using A[] as the accumulator:
    !C &              //   is it the leading 'digit'?
    ( $ = $ && --B    //   if the carry is set, decrement B
               < 97 ) //   and set it again if the result is 96 (just below 'a')
    ?                 //   if this is the leading 'digit' and the carry is set:
      A               //     leave A[] unchanged
    :                 //   else:
      [ $ * 26 + B,   //     prepend B if there's no carry or B + 26 otherwise
        ...A ],       //     (which gives 122, or 'z')
    []                //   initialize the accumulator to an empty array
  )                   // end of reduceRight()

Jelly, 14 13 bytes
LØaṗṪṖṭƊði’ị⁸

Try it online!
-1 byte thanks to Jonathan Allan reminding me of the Cartesian power builtin.
A new different approach using raw enumeration instead of math. LØaṗṖL¦ði’ị⁸ is a byte shorter, but doesn't correctly produce the empty string for some reason. It's not quite so efficient as the first solution, so I've abridged the longer test cases...
 Øaṗ             Take the Cartesian product of the lowercase alphabet with itself
L                a number of times equal to the length of the input.
    Ṫ            Take the last element of the product (e.g. "zzzz"),
     Ṗ           remove its last element ("zzzz" -> "zzz"),
      ṭƊ         and re-append it to the product.
        ð        Given that product and the original input,
         i       find the input's index in the product,
          ’      subtract 1,
           ị⁸    and index back into the product.
                 Since Jelly uses modular 1-indexing, if the input is the least
                 string of its length, its index of 1 will decrement to 0, which
                 then maps it back to the end of the enumeration, which has been
                 truncated appropriately.

Jelly, 21 bytes
O_96µJṚ’26*×µS’ḃ26ịØa

Try it online!
There's probably a shorter conversion from bijective base 26 out there, but I figured I may as well write my own before taking someone else's.

Product using the length saves one byte: TIO

Factor, 115 bytes
: а ( s -- s ) >array [ 96 - ] map reverse
dup length [0,b] [ 26 swap ^ ] map [ * ] 2map
sum 1 - bijective-base26 ;

A naive implementation using bijective-base26 which does half the work. This solution doesn't work in TIO, because it apparently doesn't include the html-help dictionary.
Here's a screenshot from my desktop Factor Listener:

@xnor Thank you! I have totally forgotten about the scoring - of course the function can be renamed to a.,

Python 2, 81 bytes
A="";B=1
for C in input()[::-1]:A=chr((ord(C)-97-B)%26+97)+A;B*=C<"b"
print A[B:]

Try it online!
72 bytes with lists of code points as input and output:
A=[];B=1
for C in input()[::-1]:A=[(C-97-B)%26+97]+A;B*=C<98
print A[B:]

Try it online!

Note the scoring of the challenge, which favors smaller variable names for instance.

@xnor thanks for reminding me. Although this probably won't affect any ranking, my score is now only half as high. ;)

J, 39 36 35 31 26 bytes
-5 when using codepoints
*/@:=&97}.<:&.(26#.2,-&97)

Try it online!
How it works
*/@:=&97}.<:&.(26#.2,-&97)
                     -&97  a->0,b->1,..
               26#.2,      append 2 and convert from base 26
          <:&.(          ) execute right side, then decrement,
                           then inverse of right side
               26#.2,      convert to base 26 and drop the 2
                     -&97  convert back to string
*/@:=&97                   does input string only contain a's?
        }.                 drop 0 or 1 letters

Very nice use of &.!

Sadly the version with only one &. is shorter. :-)

Haskell, 56 bytes
a.b.a
a=reverse
b"a"=""
b('a':a)='z':b a
b(a:b)=pred a:b

Try it online! The identifier names are a bit confusing (i.e. a appears as the current character, the rest of the string, and as shorthand for reverse) in order to use low code points.
Currently beats the other Haskell answer, though I already submitted an one byte improvement there which will put it into the lead again.

K (ngn/k), 35 bytes
{`c$97+1_26\-1+26/2,{(~+/x)_x}x-97}

Try it online!
Strongly inspired by @xash's J solution - don't forget to upvote it!

PHP, 35 bytes
for($a=a;$a!=$argn;$b=$a++);echo$b;

Try it online!
who knew strings incrementing would serve one day? Too bad decrementing doesn't work..

I was surprised when I found out it doesn't work too, I've had to implement it manually a long time ago. But the naive approach of incrementing until the desired result is a good idea. Also, you probably could do $a<$argn instead of $a!=$argn. PHP will check if the character value is lower. For example, a < b is true in PHP. This saves you 1 byte.

@IsmaelMiguel nice suggestion, I tried but unfortunately it stops prematurely, as for the example of "golf" it displays "g" because "h">"golf" is true

... That's pretty dumb ... I know what PHP is doing ... It's checking if the substring $a is lower than $argn. It's kinda like assuming that 2 is higher than 1234 because it starts with 2... I'm out of ideas to improve your code. I guess this is the optimal solution in PHP? Not even range() works here!

@IsmaelMiguel I would have liked to avoid being obliged to use a second var $b value save but I couldn't find any shorter than this so far..

I can't find any shorter either... I'm pretty sure this is optimal.

05AB1E, 10 bytes
āAδã˜s¡нθJ

Try it online or verify all (short) test cases. (Times out for any test cases with a length above 5 due to the ã builtin.)
Explanation:
ā           # Push a list in the range [1, (implicit) input-length] (without popping)
 A          # Push the lowercase alphabet
  δ         # Apply double-vectorized:
   ã        #  Take the cartesian product
    ˜       # Flatten this list of lists
     s      # Swap so the input is at the top of the stack
      ¡     # Split this list of strings on the input
       н    # Only leave the first list
        θ   # And leave the last string of that first list
         J  # Join (for the edge case 'a', which will result in an empty list [])
            # (after which it is output implicitly as result)

NOTE: In this solution I'm alternatively able to change the н to ć/¬; θ to ¤; and/or J to » without changing the functionality. However, all of those would only negatively effect the score, since нθJ are earlier in the 05AB1E encoding.

SimpleTemplate, 25 bytes
I loved PHP's feature where incrementing 'a' woud give 'b', and incrementing 'z' would give 'aa'.
So, since very early in the creating, I've decided to emulate that functionality, but PHP doesn't support decrementing.
That had to be implemented manually, a long time ago...

Anyway, this is the code for the task:
{@incby-1argv}{@echoargv}

The code is incredibly simple: Increment all values in argv by -1 (decrement) and output it (without a separator).
An ungolfed version of the code isn't much different:
{@inc by -1 argv}{@echo argv}

(Note: argv is the default variable that contains all arguments passed, both to the script as well as to a function. Converting to a function is trivial.)

You can try it on: http://sandbox.onlinephpfunctions.com/code/05d4f13a1d27480d119e516c446b9d001d1111d8

perl -M5.010 -nl, 46 bytes
$"=a;say/^$"$/?"":do{{$,=$"++;/^$"$/||redo}$,}

Try it online!
Very slow. Starting with a, it iterates over all the strings consisting of lower case letters, in shortlex order. If it matches the input, it prints the previous string. Some bytes are wasted to deal with the input of a, which should return the empty string.

Brachylog, 19 bytes
{{∧Ẓ∋}ᵐ|b↰}ᶠs[?,.]∧

Try it online!
I expect to be able to outgolf this.

Perl 5 -pl, 42 bytes
-1 byte, thanks to @Abigail!
s/(.)(a*)$/$1=~y!b-za!a-y!dr.$2=~y!a!z!r/e

Try it online!
Explanation
Mostly just using Regex here. First, match any character followed by a (greedy match of 0 or more) as. In the replacement, return $1, tr///anslating (y///) chars to those directly preceding them (/deleting any as), followed by $2, translating as to zs.
This should work for any length input.

Replace z x length$ with $2=~y!a!z!r to save a byte. Try it online

@Abigail Ah, nice! I tested s/./z/gr thinking I needed to catch all chars, but of course, it's only as! Thank you!

C (gcc), 85 bytes
Works backwards from the end, overwriting the string as it goes along. If the previous digit borrowed (which the first character processed always does), then decrement the current digit, wrapping if required. If the final digit processed wrapped, then return the next character in the string.
A,B,C;D(char*E){for(A=1,B=strlen(E);B--;E[B]=(A=C<97)?B?122:0:C)C=E[B]-A;return E+A;}

Try it online!

Husk, 14 bytes
→←xṁOmπ…'a'zΘN

Try it online! Uses a strategy similar to the one in Kevin Cruijssen's answer.

Charcoal, 33 bytes
≔⪪Ｓ¹θＷ›θ⟦a⟧«≔⊟θι←§β⊖⌕βι¿›ιa«↑θ≔υθ

Try it online! Link is to verbose version of code. Vaguely based on @SurculoseSputum's answer. Explanation:
≔⪪Ｓ¹θ

Split the input into characters.
Ｗ›θ⟦a⟧«

Repeat until we only have a or nothing left.
≔⊟θι

Get the last remaining letter.
←§β⊖⌕βι

Print its cyclic decrement leftwards.
¿›ιa«

If there is no borrow, ...
↑θ

... print the remaining list in reverse, ...
≔υθ

... and clear the list to exit the loop.

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


text:
Print the Black Mirror episode title
Given two integers, s and e, print the title of Black Mirror series #s episode #e.
Expected output is as below, case sensitive. Output for blank cells and invalid inputs is unspecified.
e↓s→                          1                  2                     3               4                              5                6
 1 | The National Anthem       | Be Right Back    | Nosedive            | USS Callister | Striking Vipers              | Joan Is Awful  |
 2 | Fifteen Million Merits    | White Bear       | Playtest            | Arkangel      | Smithereens                  | Loch Henry     |
 3 | The Entire History of You | The Waldo Moment | Shut Up and Dance   | Crocodile     | Rachel, Jack, and Ashley Too | Beyond the Sea |
 4 |                           |                  | San Junipero        | Hang the DJ   |                              | Mazey Day      |
 5 |                           |                  | Men Against Fire    | Metalhead     |                              | Demon 79       |
 6 |                           |                  | Hated in the Nation | Black Museum  |                              |                |

(The episode "White Christmas" is grouped with series 2 on Netflix, but originally aired as a standalone special, so it is not part of the challenge. The film Bandersnatch is likewise standalone and exempt.)
This question was posted before the release of series 6, at a time when it appeared the future of Black Mirror was in jeopardy. I have added series 6 to the challenge; answers posted before this edit are still considered valid.

Can we make a function that returns the title instead of printing it?

@Dion As far as I know, returning rather than printing is always allowable.

@Dion Returning is just printing to the function output.

Husk, 162 bytes
!x'x!¶¨Σṅ←ÿ‼⌋xżFE«Ȯ⌊Żψ'xΣẏ>ï?₀fẏu₈eṙ‼ḂkxẇïBȦrxΣ«QẆḟṁŸ)⁶ıex₉?²tx«‼UÜUÄd□Δ'xS▲⌋ȷ9oxṀËäαγFxHȦ∂↕εṄ|≠USSχ⁷ıżxŻKȦ£Ġx£%Øx□´'ËDJxẎȦlḊh₈Ċż_ṀÿKi▼V₉→xSmi►&η$x£ƒ´,⌋ȷ@,Ädÿ¿◄θ⁰

Try it online!
A perfect task for Husk's string compression. Seasons are separated with newlines and episodes are separated with 'x'.
Then:
!x'x!¶¨...
      ¨...     Big compressed string
     ¶         Split on newlines
    !          Take the line corresponding to given season
 x'x           Split on 'x'
!              Take the title of the given episode

05AB1E, 213 bytes
.•Ω?"Λ1äγÍθ}Æuмï∍βb6G¨—Wc“jép¡úórÑ9ǝ‘øδs@!иésb•#`”0á½Ú©ÿ0ŽÚÿ0Çˆ,—É, ÿÍ±…«00
0€€ƒ³à¬ÿ0ßà‡ÈÝìs0€€îÆ„ª of€î00
0€ïƒ©‚ƒ0„¸Ÿâ0€€Ò´doœÂ00
«¢d in ÿï¹0ÄÃÿ0†•ÿ0À…€¾ ÿ–›0†ŽŠ€ÿ0…±†¤ŠÄ
ƒÏ—´0USS„Òÿ0Aÿ0Cÿ0ÂŒ ÿ DJ0îÊÿ”¶¡0δ¡IèIèðÚ

Try it online or verify all test cases.
Explanation:
.•Ω?"Λ1äγÍθ}Æuмï∍βb6G¨—Wc“jép¡úórÑ9ǝ‘øδs@!иésb•
            "# Push compressed string "head the rocodile rkangel ister ipero and test dive the hem and ereens ers"
 #           # Split it on spaces
  `          # Pop and push each string separated to the stack
”0á½Ú©ÿ0ŽÚÿ0Çˆ,—É, ÿÍ±…«00
0€€ƒ³à¬ÿ0ßà‡ÈÝìs0€€îÆ„ª of€î00
0€ïƒ©‚ƒ0„¸Ÿâ0€€Ò´doœÂ00
«¢d in ÿï¹0ÄÃÿ0†•ÿ0À…€¾ ÿ–›0†ŽŠ€ÿ0…±†¤ŠÄ
ƒÏ—´0USS„Òÿ0Aÿ0Cÿ0ÂŒ ÿ DJ0îÊÿ”
             # Push dictionary string "0 Striking Vipÿ0 Smithÿ0 Rachel, Jack, ÿ Ashley Too00\n
             # 0 The National Antÿ0 Fifteen Million Merits0 The Entire History of You00\n
             # 0 Be Right Back0 White Bear0 The Waldo Moment00\n
             #  Hated in ÿ Nation0 Noseÿ0 Playÿ0 Shut Up ÿ Dance0 San Junÿ0 Men Against Fire\n
             #  Black Museum0USS Callÿ0Aÿ0Cÿ0 Hang ÿ DJ0 Metalÿ",
             # with all `ÿ` automatically filled with the strings on the stack
 ¶¡          # Split it on newlines
   0δ¡       # Split each line on 0s
             #  [[""," Striking Vipers"," Smithereens"," Rachel, Jack, and Ashley Too","",""],
             #   [""," The National Anthem"," Fifteen Million Merits"," The Entire History of You","",""],
             #   [""," Be Right Back"," White Bear"," The Waldo Moment","",""],
             #   [" Hated in the Nation"," Nosedive"," Playtest"," Shut Up and Dance"," San Junipero"," Men Against Fire"],
             #   [" Black Museum","USS Callister","Arkangel","Crocodile"," Hang the DJ"," Metalhead"]]
      Iè     # Index the first input-integer into it (0-based and with wraparound)
        Iè   # Index the second input-integer into that list (0-based and with wraparound)
          ðÛ # Remove any leading spaces
             # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to use the dictionary? and How to compress strings not part of the dictionary?) to understand how the used compressed and dictionary strings work.

Stax, 202 bytes
ü○b(╠◘qÅñÿ[%Uδö╬ε#êc∙╪≈ü╒┘ú┴tÆ↔nU¥┴♣ßª•┼<\╣`vΘ╒°²~♦∙'E♂○N½←àp▄û'XpéIê┼z♂Qìa~Æq7-T⌐ ○¡B▬#√╤cçµM╖Æ♦N╜Ü◄4òτ`≈úG{╧►)┴╬║º,Φ┤╫ÿα►]Q╬≈♠ [εjy0z▲dΘÜ╚é6♥#ö»ë'KC▬.W◙)lH↓√↓ö¿▐▌φ┬;┼ΣuΓuΣiè‼x╘ö╝▐┴ßIG•∙¿╦↓AQt}yd◘$éⁿ≤←

Run and debug it
This program takes episode and season as input, separated by a space.

Vyxal, 192 bytes
`λƛ ¬ε Ṫṅ¥ṗXṠ↳ ÷⁋ Ṗ≈sXλƛ ∆ɾ ∧Ġ of λß
Be ¬ẏ λǑX∧… ∞↑Xλƛ W…±o ɽ⁋
₁ḣ¦ḭX∨±∨ḊXż≬ Up λ¬ ↔÷X⟑ɖ ∨Ǐ °↔X←Ġd in λλ ⌐±
USS ⟑«iḊꜝrXArk›ǎXC≥ẋo∩ȧeX⟩ẇ λλ DJX∆↑÷≠X¬⁼ ¢⁋
Ẇ± Ŀʀ□ẊX€∧□Ṅ↳¾X₄ð, ¢…, λ¬ §⋏ ⟑⋏`↵\X/?i?i

Try it Online!
`...`         # Dictionary-compressed string
     ↵        # Split on newlines
      \X/     # Split on Xs (vectorised)
         ?i?i # Index input twice

Charcoal, 224 bytes
§⪪§⪪”}∨⊙α⁷ξ{⪪\`Ｇ↔Iλ?Ｉ⟧∧≕EαγＲ≔³E↙\`UκêΣJ4⧴Ｕ↙�～Ｂ⁺^dF]η8A⊖ξ≡Ｗ¦¶⧴hNνＸ^#Ol▶⊙｜Ｑ|,/(:ZＮQξζG↥≧⟲ψ∨]⮌⊖≦#Rς+vQlＫ≧⦄⁴φＣ7“L¡⊘[⁸⮌!⌕↗Ｏp;⧴‹Hr,◧⁹‖·›↨χ➙⌕↙bＭ″G@ⅉ<↔ＧnQＳ§‖⎚Þ⟧⊗¤E*ⅈ⁶℅Orν%Ｆ¤×Xbη＆◨χＪＷCＸz�Π8D>νＢ⁶≔Ｘ″~↖≡@/ÀＹ#¦▷Ｉ¿↷Φ№!｜↔δＭKＵλÀE§χＵo:γ@▷”¶Ｎ⸿Ｎ

Try it online! Link is to verbose version of code. Explanation:
    ”...”       Compressed table of episode titles
   ⪪     ¶      Split on `\n`s
  §       Ｎ     Cyclically index by series
 ⪪         ⸿    Split on `\r`s
§           Ｎ   Cyclically index by episode
                Implicitly print

Because Charcoal uses cyclic 0-indexing the last series and last episode of each series will wrap around to 0 so they actually appear first in the table.

JavaScript, 353 bytes
s=>e=>`The National Anthem|Fifteen Million Merits|The Entire History of You||||Be Right Back|White Bear|The Waldo Moment||||Nosedive|Playtest|Shut Up and Dance|San Junipero|Men Against Fire|Hated in the Nation|USS Callister|Arkangel|Crocodile|Hang the DJ|Metalhead|Black Museum|Striking Vipers|Smithereens|Rachel, Jack, and Ashley Too`.split`|`[s*6+e-7]

Try it online!

Python 3, 360 bytes
lambda s,e:"The National Anthem|Fifteen Million Merits|The Entire History of You||||Be Right Back|White Bear|The Waldo Moment||||Nosedive|Playtest|Shut Up and Dance|San Junipero|Men Against Fire|Hated in the Nation|USS Callister|Arkangel|Crocodile|Hang the DJ|Metalhead|Black Museum|Striking Vipers|Smithereens|Rachel, Jack, and Ashley Too".split("|")[s*6+e-7]

Try it online!

Bash, 291 + 45 bytes
up to series 6
base64 -w0|cut -d2 -f$2|cut -d3 -f$1|tr 45 \ ,

Attempt This Online!
The input is generated with
cat table | tail -n 6 | sed "s/ *| */|/g" | cut -d "|" -f 2-7 | tr "\n| ," "2345" | sed "s/332$//" | base64 -d.


text:
Remove each integer from a string and multiply them all!
Goal:

Get every integer from the string (not a number, but integer)
Multiply them
Output the result

Input:
5 kilograms of food eaten, 10 liters of water drank, 20 plates dirty, 40 mugs dirty, and only 3 people acted!
Output:
120000
How:
Result was 5 * 10 * 20 * 40 * 3
What do we count as an integer:
General:

If integer has a symbol BEFORE of AFTER the int, only take the number without symbols. -335 or 335+ are 335 anyways.
If integer has a symbol like this: 35:3, don't take it. 35 : 3 is available though, and considered as 2 integers.

Detailed:
35/3 aren't two integers, skip this
35.3 is not an integer, skip this
35:3, 35*3, 3e3, etc. aren't ints, skip them as well
353 is an integer
35 3 are two integers

is an integer

353?, 353!, etc. are integers
-353 is an integer, but you only claim 353 and skip "-".
+353 is the same case as upper

Requirements:
Select any language you want
The program should contain as little bytes as possible
You should tell us the language (if it's, like, exotic, link it like this)
Please, upload the code to Try It Online services like this
Count the bytes using special services like this
It would be fine if you'd explain your code!

Scoring:
Less bytes program wins! The end is 20th of June, you guys have a week

Can there be negative or zero integers? Can they have scientific notation?

Can there be numbers like 3.45 (which we should then discard)?

Can the string contain things like 13/06/2020? In general, you should specify exactly what counts as an integer to be extracted and what doesn't

Let us continue this discussion in chat.

They multiply ints by another int. Me - ints by unknown yet ints. Example: They got a sentence 3g 43 and number 2. Their output was 6g 86 as soon as 3*2 and 43*2. For me it would be 129 because of 3*43 @manatwork

I'm still not clear exactly what's an integer. You have lots of examples which is good, but need a rule.

General: If integer has a symbol BEFORE of AFTER the int, only take the number without symbols. If integer has a symbol like this: 35:3, don't take it. 35 : 3 is available though, and considered as 2 integers.

I think this is an 1-character-change (in the submissions, + -> *) away from https://codegolf.stackexchange.com/questions/181060/sum-integers-in-a-string.

Possible duplicate of Sum integers in a string

It's definitely a near-dupe (of both that and this), but even ignoring the strange and ambiguous rules about which integers to discard, the possible presence of 0 in a product could disrupt some answers. It's not a huge difference, though...

perl -pl, 64 bytes
s!\D+|\d+(?:[.:^e/]\d+)+|(\d+)!$1?"*".(0+$1):""!aeg;$_=eval"1$_"

Try it online!
Ignores anything which isn't a digit, or multiple sequences of digits separated by /, ., e, :, or ^. Sequences of digits are replaced by themselves, prepended with *. The result, we eval, after predending 1. There's a tiny bit of hackery going to deal with numbers starting with 0s -- we don't want them be interpreted as octal numbers.
Reads lines from STDIN, writes the result to STDOUT.

The shortest won

Red, 109 bytes
func[s][p: 1 d: charset"0123456789"parse s[any[to d copy t[any d ahead[" "|"!"|"?"]](p: p * to p t)| skip]]p]

Try it online!

The challenge says that 353?, 353!, and 353. are integers.

@Abigail Thank you, I've missed that part. I'll fix it

Don't answer duplicate/unclear questions.


text:
Does this month start on a Monday?
June 2020 is a month in which June 1st corresponds to Monday, June 2nd corresponds to Tuesday, ... June 7th corresponds to Sunday. For reference, here's the cal of June 2020.
      June 2020
Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30

Given a year and a month in the format [year, month], output two distinct values that tell whether this month starts on a Monday.
Test cases
[2020,6] -> True
[2021,2] -> True
[1929,4] -> True

[1969,1] -> False
[1997,5] -> False
[2060,1] -> False

Specification

The input can be in any format you prefer for your answer, e.g. numeric list, numeric tuple, etc. It doesn't have to be taken in this rigid format (it's JSON by the way).
However, making the input a Date object is a loophole here. You shouldn't make the input a Date object.
The month in the input doesn't have to be 1-indexed - it can also be 0-indexed.
You need to support all years after 1582 (the start of the Proleptic Gregorian calendar), up to the year 9999.

Is this asking, in less jargony terms, "does the given month start on a Monday"? The question is kind of hard to parse

@pppery that's what I based my answer upon.

I suggest scrapping the entire challenge text and replacing it with: Given a year and a month, answer whether the given month begins with a Monday in the given year.

Do you really mean that the input has to be in the format [year, month], with square brackets, a comma, and a space character as indicated?  The posted answers seem to assume that it's OK just to input the year and the month in some reasonable format.

@MitchellSpector Unless anything specific is stated, you can assume that default I/O rules apply. (And the format used happens to be JSON, a very well-supported standard.)

I asked because the challenge specifically says "in the format [year, month]".  That implies to me a rigid input format (how else would a rigid input format be expressed?).  I agree with what I think is your implication that the challenge would be better with the usual default I/O rules. I think OP should clarify this. @Adám

@MitchellSpector I just took that to mean any numeric list/tuple, and by any means.

@Adám I've posted an answer assuming that too.  If OP says otherwise, I'll adjust the answer accordingly.

May we use 0-based indexing for the month, with 0 being Jan.?

How large a year range do we have to support? For instance, certain hundred years skip the leap day, and year -1 coming directly before year 1 doesn't work well with some number types.

"The input can be in any format you prefer" - does that include as our chosen language's date object? I suspect that's not your intention and, if not, you should update the spec to close that loophole.

for added complexity you might wish to specify a different calendar, such as Julian evilgrin

It's Gregorian calendar, not Gregory calendar. And when it started is location dependent; many countries switched in the 18th century, with some holding out until the 20th. (If you ever wonder why in the Soviet Union the October revolution was celebrated in November, that's why). Wikipedia says Saudi Arabia adopted the Gregorian calendar as recent as 2016. But we can assume the proleptic Gregorian calendar instead.

Japt -!, 6 5 bytes
ÓÐN e

Try it
ÓÐN e     :Implicit input of integers U=y and V=m
 Ð        :Create date object from
  N       :  The array of inputs [U,V] with the date defaulting to the 1st
    e     :0-indexed day of the week
Ó         :Decrement
          :Implicit output of Boolean negation

Looks like our "Try it" link shows that your solution does not produce the correct results.

Depends on your locale, @Thomas.

Excel,  44  34 23 19 18 bytes
=2=MOD(A3&"-"&A2,7

-11 thanks to Adam and -4 thanks to Shazback
-1 thanks to this
Original Answer
=(TEXT(DATE(A2,A3,1),"ddd")="Mon")

Ensure that the year is placed in cell A2 and the month in A3.
:( Crossed out 44 is still 44.

=2=MOD(DATE(A2,A3,1),7)

You removed the final closing parenthesis. While I'm not to comment on the validity of that, what you have now is only 22 bytes.

@Adám that was a copy paste error

Doesn't Google Sheets auto-close parentheses?

1 byte can be saved by abusing the Date function's default value: =1=mod(date(A2,A3,),7)

24 bytes - but quite readable for a golf: =WEEKDAY(DATE(A2,A3,))=1

19 is possible by relying on excel to convert strings to dates: =2=MOD(A3&"-"&A2,7)

Ruby, 26 24 bytes
->d{Time.gm(*d).monday?}

Try it online!
You'll never guess what this does.
Edit: -2 bytes from Dingus.

Bash + GNU utilities, 25 22 19 bytes
date -d$1-1|grep ^M

Try it online!
Or verify the test cases online.
The input is passed as an argument in the format year-month, and the output is the exit code (0 for truthy, 1 for falsey, as usual).

It assumes being run on an english locale.

@Amessihel That's true. Of course, the question was in English, and TIO doesn't even seem to have any non-English locales available.

date -d$1-1 +%u would be more universal and has 15 bytes, but will print numbers 1-7, which is not what OP requested.

@pLumo Yes -- in fact, if you check the edit history, my first version worked that way: date +%u -d$1-$2-1|grep 1 was the code. But that's 25 bytes, including the grep at the end to check for the numerical code for Monday, so that it meets OP's specs. https://codegolf.stackexchange.com/revisions/206071/1  (I could take off 3 bytes with the more liberal input criteria OP provided in response to a question, using $1 instead of $1-$2, but that would still only get down to 22 bytes.)

JavaScript (ES61),  33 26  25 bytes
1: This works in Chrome, Node and Edge Chromium
Saved 7 bytes thanks to @Shaggy
Saved 1 byte thanks to @l4m2
Using a built-in. Takes input as ([year, month]).
a=>/^M/.test(new Date(a))

Try it online!
How?
Converting the input to a Date object
The Date() constructor expects either:
Date(year, month [ , date [ , hours [ , minutes [ , seconds [ , ms ] ] ] ] ])

or:
Date(value)

In the first syntax, month must be 0-indexed.
In the second syntax, value is coerced to a string (unless it's undefined or it's an object) and parsed as such. Therefore, a 1-indexed month is expected in that case.
According to the ECMAScript specification:

The function first attempts to parse the format of the String
  according to the rules (including extended years) called out in Date
  Time String Format (20.3.1.15). If the String does not conform to
  that format the function may fall back to any implementation-specific
  heuristics or implementation-specific date formats.

So [2020,6] is turned into "2020,6" and parsed using implementation-specific heuristics which happen to work in V8-based engines when a comma is used as a separator. This also works with several other symbols.
Regular expression
When passed as the argument of /^M/.test(), the Date object is implicitly converted into a string in the following format:
"DDD MMM 01 YYYY 00:00:00 GMT[...]"

where:

DDD is the 3-letter abbreviation of the day of the week
MMM is the 3-letter abbreviation of the month
YYYY is the year in numerical format

Therefore, the string begins with a "M" iff the day of the week is Monday.

JavaScript (ES6),  62 61  60 bytes
Using a formula. Takes input as (year)(month), where month is 0-indexed.
y=>m=>(y-=m<2,y+=(y&~3)-3*~~(y/100)>>2)%7=='045204263153'[m]

Try it online!

26 bytes

@Shaggy Nice. I don't think I've ever seen this trick before. I guess the Date constructor basically accepts any separator between the numbers.

The strangest part of it to me is that the month is now 1-indexed.

@Shaggy I've added an explanation. Please let me know if you think something is inaccurate.

25

A different 25 byte solution based on the 26 byte solution

@JoostK Fail on Sunday

It doesn't seem locale-independent.

@Amessihel, it doesn't have to be. A locale is just a form of implementation.

APL (Dyalog Unicode) 18.0, 9 bytes (SBCS)
Anonymous tacit prefix function.
1=7|1⎕DT⊂

Try it online! (uses a model, ∆DT, instead of ⎕DT so it can run using TIO's current version)
⊂ enclose the argument (because we need the date to be a scalar)
1⎕DT convert Date-Time to days since 1899-12-31 (this will "pad" the date to the first of the month)
7| division remainder when divided by 7
1= does one equal that?

Wolfram Language 36 bytes
DayName@DateObject@{#,#2,1}==Monday&

examples
Naming the function f, to save space and increase clarity.
f = DayName@DateObject@{#, #2, 1} == Monday &
f[2020, 6]
f[2021, 2]
f[1929, 4]
f[1969, 1]
f[1997, 5]
f[2060, 1]

(*True*)
(*True*)
(*True*)
(*False*)
(*False*)
(*False*)

Red, 33 bytes
func[b][1 = pick(to now b)+ 1 10]

Try it online!
The argument bis a block containing the year and the month. now is function returning the current date and time; to now b converts the input to a date! datatype. The odd thing is that currently Red assigns the missing data (the day of month) 0 by default, but Red being 1-indexed, thus calculates the last day of the previos month instead of the first day of the given month:
to now [2020 6] gives 31-May-2020
That's why I add 1 to the resulting date. date! has among its path accessors /weekday, wich can be queried using indexing instead - 10 (tenth item). Too bad I can't use direct indexing using paths /10, because it only works on words (variables) and not on literal / unnamed data. That's why I use pickdate 10.
Finally I check if the weekday is 1 (for Monday).

T-SQL, 47 bytes
SELECT 1/datepart(w,datefromparts(y,m,7))FROM i

(10 bytes saved thanks to @t-clausen.dk)
Assumes the input is in a table i with two columns, y and m. It assumes Sunday is set as the first day of week, which is the default setting. Outputs 1 if the month starts on a Monday, 0 otherwise.
datepart(w,datefromparts(y,m,7)), the day of week of the seventh day of the month returns 1 (=Sunday) if the month starts on a Monday, and a higher number otherwise. Since it's an integer, the division is rounded down to zero in the latter case.
Demo

nice first answer. I hope to see more SQL answers. This will not work on all servers. It depends on the datefirst setting. SET datefirst 7 would ensure it works

you can save a few bytes: 1/datepart(w,datefromparts(y,m,7))

Thanks, that's a nice trick.

Sunday is the default setting for some languages. I know Germany, Denmark, Norway. Sweden and alot of other countries uses different defaults. So you can't release this code for production - but this doesn't matter for Codegolf, as  long as your Demo works

05AB1E, 36 bytes
Ð3‹12*+>₂*T÷s3‹Xα©т%D4÷®т÷©4÷®·(O7%Θ

Here we go again. 05AB1E has no date builtins, so everything is done manually. This solution is a derivative of my answer here.
Takes both inputs separated, the \$month\$ as first input and \$year\$ as second.
Try it online or verify all test cases.
Explanation:
The general formula to calculate the Day of the Week manually is:
$${\displaystyle h=\left(q+\left\lfloor{\frac{13(m+1)}{5}}\right\rfloor+K+\left\lfloor{\frac{K}{4}}\right\rfloor+\left\lfloor{\frac{J}{4}}\right\rfloor-2J\right){\bmod{7}}}$$
Where for the months March through December:

\$q\$ is the \$day\$ of the month ([1, 31])
\$m\$ is the 1-indexed \$month\$ ([3, 12])
\$K\$ is the year of the century (\$year \bmod 100\$)
\$J\$ is the 0-indexed century (\$\left\lfloor {\frac {year}{100}}\right\rfloor\$)

And for the months January and February:

\$q\$ is the \$day\$ of the month ([1, 31])
\$m\$ is the 1-indexed \$month + 12\$ ([13, 14])
\$K\$ is the year of the century for the previous year (\$(year - 1) \bmod 100\$)
\$J\$ is the 0-indexed century for the previous year (\$\left\lfloor {\frac {year-1}{100}}\right\rfloor\$)

Resulting in in the day of the week \$h\$, where 0 = Saturday, 1 = Sunday, ..., 6 = Friday.
Source: Zeller's congruence
Since we only care about \$q=1\$, we can use that to golf 2 bytes. With the formula above, the result would be \$2\$ for Mondays (and thus requiring a leading $ to push both 1 AND the input-month; as well as a trailing 2Q to check if the result equal 2). But if we remove the \$q+\$ part, the result would be \$1\$ for Mondays (in which case we can use the implicit input-month, removing the $; and also use the ==1 builtin Θ instead of 2Q).
Ð             # Triplicate the (implicit) input-month
 3‹           # Check if the month is below 3 (Jan. / Feb.),
              # resulting in 1 or 0 for truthy/falsey respectively
   12*        # Multiply this by 12 (either 0 or 12)
      +       # And add it to the month
              # This first part was to make Jan. / Feb. 13 and 14

>             # Month + 1
 ₂*           # Multiplied by 26
   T÷         # Integer-divided by 10
s3‹           # Check if the month is below 3 again (resulting in 1 / 0)
   Iα         # Take the absolute difference with the second input-year
     ©        # Store this potentially modified year in the register
      т%      # mYear modulo-100
D4÷           # mYear modulo-100, integer-divided by 4
®т÷©4÷        # mYear integer-divided by 100, and then integer-divided by 4
®·(           # mYear integer-divided by 100, doubled, and then made negative
O             # Take the sum of all values on the stack
 7%           # And then take modulo-7 to complete the formula,
              # resulting in 0 for Sunday, and [1, 6] for [Monday, Saturday]

Θ             # Check if this is equal to 1 (thus a Monday)
              # (after which the result is output implicitly)

Note that I've also used \$\left\lfloor{\frac{26(m+1)}{10}}\right\rfloor\$ instead of \$\left\lfloor{\frac{13(m+1)}{5}}\right\rfloor\$, since 05AB1E has a 1-byte builtin for both 26 and 10 (₂ and T respectively), saving a byte on the 13.

Python 2, 56 bytes
lambda y,m:date(y,m,1).weekday()<1
from datetime import*

Try it online!

Python 3.8 (pre-release), 53 bytes
lambda x:date(*x,1).weekday()<1
from datetime import*

Try it online!

Bash + Standard Unix Tools, 17 bytes
cal $1|grep ' 6$'

Input like "06 2020".
Exit Code is 0 if first day of month is Monday and 1 if not.

Try it online!
In some implementations, additional two bytes are necessary:
 cal $1|grep ' 6 *$'

Julia 1.0, 39 bytes
using Dates
x*y=dayofweek(Date(x,y))==1

Try it online!
I am posting this seperate from my other answer, since it doesn't use the  point-free style, and thus doesn't have the cool side-benifits of also working for year only etc.
But it is shorter

save one byte by replacing ==1 with <2

C (gcc), 61 60 59 bytes
Saved a byte thanks to ceilingcat!!!
Saved a byte thanks to nununoisy!!!
f(y,m){y-=m<2;m=(y+y/4-y/100+y/400+"bed=pen+fad."[m])%7<1;}

Try it online!
Straight-up calculation that uses 0-based months.

59 bytes if you use 0-indexed months: Try it online!

@nununoisy Yes of course, was using a byte up in that string just to make it 1-based.  Nice one = thank! :D

PowerShell, 28 21 bytes
(d $i -U %A)-like'M*'

Try it online!

Java (JDK), 35 bytes
m->{m.set(5,1);return m.get(7)==2;}

Try it online!
Explanation
The input is taken as a java.util.Calendar. First we modify the calendar to force the first of the month, then we check if that day of week is a Monday.
m -> {
  m.set(Calendar.DAY_OF_MONTH, 1);    // DAY_OF_MONTH is the constant 5
  return m.get(Calendar.DAY_OF_WEEK)  // DAY_OF_WEEK is the constant 7
    == Calendar.MONDAY                // MONDAY is the constant 2. Don't ask why, no one knows.
}

Perl 5 -MTime::Local -pa, 38 33 bytes
Shaved 5 bytes with help from @DomHastings
$_=(gmtime timegm 0,0,0,1,@F)=~Mo

Try it online!
Input is space separated: 0-indexed month followed by year.

Nice, I wasn't getting anything competitive with core functions... You can save a few bytes dropping the / around the regex and using @F instead of <>,$_ too: Try it online!

q, 33 32 bytes
accepting the inputs as strings:
{2=mod["d"$"M"$x,".",-2#"0",y]7}

explanation
                     -2#"0",y    /append "0" to 2nd input and take last 2 chars from result
               x,".",            /join by "."
           "M"$                  /tok, convert string to month type
       "d"$                      /cast to date type - returns 1st of month
   mod[                      ]7  /date mod 7, 0->sat,1->sun,2->mon,etc
 2=                              /check if equal 2

run like:
q){2=mod["d"$"M"$x,".",-2#"0",y]7}["1929";"4"]
1b

Befunge-93, 81 78 bytes
&&:2`!#v_2->267+**2-55+/\:"d"/02-*\:"d"%\:"d"%4/\"d"/4/++++7%!.@
-1\++55<   ^\

Try it online!
How does it work?
This is based on a formula which gives the day of the
week given a date:
W = (k + floor(2.6m - 0.2) - 2C + Y + floor(Y/4) + floor(C/4)) mod 7

where

k is the day of month,
m is the month of the year, if years start with March (so
  Mar = 1, Apr = 2, ..., Dec = 10, Jan = 11, Feb = 12).
C is the century of the March adjusted year (so year = year - 1
  in January and February).
Y is the year in the century (March adjusted).
W is the weekday, (Sun = 0, ..., Sat = 6).

We will be calculating
W' = floor((26m - 2)/10) - 2C + Y + floor(Y/4) + floor(C/4)) mod 7

the month will start with a Monday, iff W' == 0.
Breaking down the program gives us:
&&              Reads year and month

  :2`!#v_2->    If the month is January or February, subtract 1 from
-1\++55<   ^\   the year, and add 10 to the month; else, subtract
                2 from the month. (Years start in March).

267+**2-55+/    Calculate (2.6 * month - 0.2).

\:"d"/02-*      -2 * Century (= int (year / 100))

\:"d"%          Year in century (year % 100)

\:"d"%4/        4 year leap year cycle adjustment (int ((year % 100) / 4))

\"d"/4/         400 year leap year cycle adjustment
                (int (int (year / 100) / 4))

++++            Sum them all

7%              Mod 7.

!.@             Negate the result and print it -- if 0 (hence, first
                day of the month is a Monday), then 1, else (not a
                Monday) 0.

Edit: Saved three bytes.

Julia 41 bytes
(37 characters)
using Dates
isequal(1)∘dayofweek∘Date

It's fairly rare to find a code-golf that can be answered in point-free style in Julia.
An interesting side effect of this, is that if you give this just 1 input it will tell you if the year starts with a Monday.
And if you give it 3 inputs it will tell you if a given day is a Monday.

save 5 bytes by replacing isequal(1) with ==(1), and an additional byte with <(2) (requires Julia 1.2)

Retina 0.8.2, 108 bytes
\d+
$*
^(11? )1
12$*1$1
\G1
13$*
(1+)\1{4}1{27,} (?=(1*)\2{399})(?=(1*)\3{3})(1*)(?=\4{99})
$1$2$3
^(1{7})*$

Try it online! Link includes speedup ^ so that the included test cases complete within TIO's time limit. Takes 1-indexed month first, then the year. Explanation:
\d+
$*

Convert to unary.
^(11? )1
12$*1$1

If the month is January or February, then add 12 and subtract 1 from the year.
\G1
13$*

Multiply the month by 13, which begins a form of Zeller's congruence.
(1+)\1{4}1{27,} (?=(1*)\2{399})(?=(1*)\3{3})(1*)(?=\4{99})
$1$2$3

The month is integer divided by 5, but with 27 subtracted, which allows the calculation to result in Monday = 0. The year is separately divided by both 400 and 4, after which 1% of the year is skipped thus effectively subtracting it. The month calculation, y/400 and y/4 are then added to the remaining (y-y/100). Note that Retina will attempt to match this expression more than once but will always fail because there is only one space in the input. However, these attempts make it very slow, so to optimise this the TIO link includes a leading ^. The code will work without it eventually though.
^(1{7})*$

Test whether the result is a multiple of 7.

R, 39 bytes
strftime(paste0(scan(,''),'-1'),'%u')<2

Try it online!

PHP 7.4, 43 bytes
This code creates an anonymous function where you pass the month and year, returning true for monday, and false if the 1st day it isn't on a monday.
fn($Y,$M)=>!~-date(N,strtotime("$Y-$M-1"));

You can try this on: http://sandbox.onlinephpfunctions.com/code/5bf01ff098ef40b4b45bbc82e3b13a5e1b83f8d1

An alternative solution could be just this (40 bytes):
fn($Y,$M)=>date(N,strtotime("$Y-$M-1"));

Which returns the week day, where 1 is monday, 2 is tuesday ....
I don't think this is in the spirit of the question.

Python 3.8, 80 bytes
from calendar import Calendar as C
f=lambda x:C().monthdayscalendar(*x)[0][0]==1

Try it online!

This can be shorter with from calendar import*.

T-SQL, 43 bytes
PRINT datediff(d,0,concat(@+@y*100,14))%7/6

the expression
datediff(d,0,concat(@+@y*100,14))%7

will return 0-6. 6 represent Monday - this is divided by 6(rounding off)
Mondays returns 1, other weekdays returns 0
Try it online

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

Try it online!
Definitely not the shortest program here, this was more to see if it was possible to do. Expects input in the form of YYYYMM - the month needs to be 1-indexed and 2 characters wide. Outputs 1 if the month starts on Monday, 0 otherwise. This could be shortened by 21 bytes if the output was not ASCII.
Ungolfed:
-> reference

+++[                     input 3 sets of 2 numbers
 [>]                     find next zero
 >,>++++++[<-------->-]< input number and sub 48 ascii
 [<++++++++++>-]         mul by 10
 ,>++++++[<-------->-]   input next number and sub 48
 <[<+>-]                 copy to previous cell
 +[-<+]-                 move back to reference
 >-                      dec counter
]                        end input

>>>
[->>>>+>+<<<<<]       copy the month variable for comparison
>>>>[<<<<+>>>>-]<+>>>+++<+>+<[->-[>]<<]
<[-]<[-<              if month is less than 3
 <<<->>>              decrement the year
]>[-]>[-]>[-]>[-]>[-] clear out comparison cells to store lookup table

0 3   2  5    0 3   5     1 4    6      2  4
  +++>++>+++++>>+++>+++++>+>++++>++++++>++>++++ lookup table
+[-<+]- move back to reference
>>>>    move to month

[>>+>+<<<-]
>>[>>>[-<<<<+>>>>]<<[->+<]<[->+<]>-] access lookup table for month
>>>[-<+<<+>>>]<<<[->>>+<<<]>
[[-<+>]>[-<+>]<<<<[->>>>+<<<<]>>-]   copy table value to result
>>++++++++++[<+++++++>-]<<<<<<<      add 70 to result to prevent wrap

[>>+>>>>--<<<<<<-]
>>[-[->>+<]>[<]<]
>>[-[->>+<]>[<]<] add century div by 4

<<<[->+>>>>+<<<<<]> add year
[-[->>+<]>[<]<]
>>[-[->>+<]>[<]<]>> add year div by 4

[-<<<<<<<+>>>>>>>]                           set up modulo
<<<<<<+++++++<<+>[>->+<[>]>[<+>-]<<[<]>-]    all modulo 7
>[-]+>[[-]<->]<[->+<]>>++++++++[<++++++>-]<. display result

TI-Basic, 15 bytes
2=dayOfWk(Ans(1),Ans(2),1

Input is taken from Ans as a list. Output is stored in Ans and is displayed. Assumes that the time and date are set correctly before the program is run. Outputs 1 if the month starts on a Monday and 0 if it does not. Only works on TI-84+/SE.

jq, 50 bytes
.+[1]+(now|gmtime[3:8])|mktime|strftime("%w")=="1"

Try it online!
Not that short, but it's different enough that I thought it might be interesting enough to post...
It expects a year and a 0-indexed month as a list, meaning [2021,3] for April, 2021.
.+[1]+(               )                            - append "day 1" to input
       now|gmtime[3:8]                             - curr time breakout, drop Y/m/d fields
                       |mktime                     - convert to epoch time
                              |strftime("%w")=="1" - compare "day of week" to Monday

Factor, 20 bytes
[ 1 <date> monday? ]

Try it online!

1 <date> Create a timestamp object from the given year, month, and using 1 as the day.
monday? Is it Monday? A builtin from the calendar vocabulary.

Perl 5, 44 bytes
say 1==(gmtime timegm 0,0,0,1,-1+pop,pop)[6]

Try it online!

Charcoal, 43 bytes
ＮθＮη≧⁻‹η³θ¬﹪Σ⟦θ÷θ⁴±÷θ¹⁰⁰÷θ⁴⁰⁰Ｉ§”)➙⊟-�=.”η⟧⁷

Try it online! Link is to verbose version of code. Takes 1-indexed month and outputs a Charcoal boolean, i.e. - for Monday, no output otherwise. Explanation:
ＮθＮη

Input the year and the month.
≧⁻‹η³θ

Decrement the year if the month is January or February.
¬﹪Σ⟦θ÷θ⁴±÷θ¹⁰⁰÷θ⁴⁰⁰Ｉ§”)➙⊟-�=.”η⟧⁷

Calculate the number of leap years and adjust for the month using a cyclic lookup table 403250351462, then output whether the result is zero (mod 7).

JavaScript, 45 bytes
n=>(''+new Date(n[0]+'-'+n[1]+'-01'))[0]=='M'

Takes input as an array like [2020, 6].
How it works
Converts the date object to a string then checks if the first character is an M.

Python 3, 76 68 bytes
Creates a new datetime object with given year and month (as a list) and the first day of the month and then checks if the day name starts with a M for Monday.
lambda l:date(*l,1).strftime("%A")[0]=="M"
from datetime import date

Try it online!

Python 3, 57 56 bytes
lambda y,m:date(y,m,1).weekday()<1
from datetime import*

Try it online!

You can save a byte by testing for weekday()<1. Also, the order of lines needs to be swapped or else there's no way to call the (anonymous) lambda: Try it online!

Ok. One of the reasons I avoided changing the ==0 to <1 is because it is then identical to this answer. I'll swap the line order though.

Posting identical answers is totally fine on our site, so you don't need to feel bad when your golf becomes identical to someone else's.

Thank you, I wasn't aware of that! I should probably fully read the rules.


text:
Insert parens into a free-form SKI calculus expression
Imagine a simple SKI calculus expression - for example, (((S α) β) γ). As you can see, each node of the rooted tree has exactly two children. Sometimes though, the parentheses are omitted and the tree is unrooted (just to make the notation clear, I believe). The challenge is to put the parentheses back, so that the tree is binary and rooted again.
The preferable way of I/O is mostly up to you; although the input and output has to at least look like the SKI calculus, and it obviously has to represent a tree.
The rule on adding parentheses is simple: α β γ becomes ((α β) γ) (bind to the left), α β γ δ becomes (((α β) γ) δ), and so on.
You may assume that the input is a correct SKI-calculus expression.
If it wasn't clear enough, you may NOT add more braces than necessary. And if it helps you in any way, you can assume that the input contains no redundant parens (like, for example, (((SK)))).
Examples
S(KS)K => ((S(KS))K)
SS(SK) => ((SS)(SK))

I'm not sure I understand the challenge completely: does using specifically SKI calculus rather than random letters affect things?

Well - no, not really, but I'd like to ask specifically about SKI calculus. It doesn't change anything, though

Does the program have to remove extra, unneeded parentheses?  For example, what if the input is (S) or ((S))KK?

In the second example, would answer of ((SS)((SK))) be wrong? If so, why?

@MitchellSpector it doesn't have to remove currently existing brakcets; it can't add useless ones (like (((SK))))

What are the nesting rules? Does A(BCDE)F become ((A(((BC)D)E))F)?

@JonathanAllan yes, exactly, that's described in the challenge. What's the problem? The paren problem is described in examples, and I even gave the example on the exact problem you mention: α β γ δ becomes (((α β) γ) δ)

The challenge gives unnested inputs in the rules section, so does not tell me the nesting rules

Perl 5 -p, 37 bytes
s/(\w|\((?1)*\)){2}(?!\))/($&)/&&redo

Try it online!

very nice, "regular" expressions parsing a proper context-free language :)

Charcoal, 52 bytes
≔⟦⟧ηＦθ¿⁼)ι≔⊟υη«Ｆ⁼Ｌη²⊞η⮌Ｅ²⊟η¿⁼(ι«⊞υη⊞η⟦⟧≔§η¹η»⊞ηι»⭆¹η

Try it online! Link is to verbose version of code. Outputs a stringified tree-like nest of lists. Explanation:
≔⟦⟧η

Start with an empty tree.
Ｆθ

Loop over the input characters.
¿⁼)ι

If this is a ), then...
≔⊟υη

... restore the parent node saved below, otherwise:
«Ｆ⁼Ｌη²

If the current node already has two children, then...
⊞η⮌Ｅ²⊟η

... remove them and put them in a first child node. (I can't wrap them in a node, since its parent is still pointing to it.)
¿⁼(ι«

If this is a (, then...
⊞υη

... save the current node, ...
⊞η⟦⟧

... push an empty node, ...
≔§η¹η»

... and set that as the current node.
⊞ηι»

Otherwise push the letter to the current node.
⭆¹η

Stringify and output the tree.
56 bytes for pretty output:
≔⟦⟧ηＦ⁺θI«≔⪫()⪫ηωζＦ⁼Ｌη²≔⟦ζ⟧η≡ι(«⊞υη≔⟦⟧η»)«≔⊟υη⊞ηζ»⊞ηι»§η⁰

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

Start with an empty tree.
Ｆ⁺θI«

Loop over the input characters, but add an extra I to ensure that the final result is wrapped in () if necessary. (If the result can always be wrapped in (), then this can be Ｆ⪫()θ« and the last part can be »ζ for an overall saving of 1 byte.)
≔⪫()⪫ηωζ

Get what the bracketed expression would be.
Ｆ⁼Ｌη²≔⟦ζ⟧η

If the current node already has two children then replace it with a node with the bracketed expression.
≡ι

Switch on the current character.
(«⊞υη≔⟦⟧η»

If it's a ( then save the current node and start a new node.
)«≔⊟υη⊞ηζ»

If it's a ) then retrieve the saved node and push the bracketed expression to it.
⊞ηι

Otherwise push the letter to the current node.
»§η⁰

Output the desired expression.

the output is correct; well done.


text:
Toroidally magnify-blur a matrix
Task
Given a matrix of numbers \$M\$ with \$r\$ rows and \$c\$ columns, and the magnification factor \$n\$, build the matrix with \$rn\$ rows and \$cn\$ columns where the original elements are spaced \$n\$ units apart and the gaps are filled by piecewise linear interpolation:
$$
    \begin{bmatrix}
    a_{11} & a_{12} & \cdots \\
    a_{21} & a_{22} & \cdots \\
    \vdots & \vdots & \ddots \\
    \end{bmatrix} \Rightarrow
    \begin{bmatrix}
    a_{11} & \frac{(n-1)a_{11} + a_{12}}{n} & \cdots & a_{12} & \cdots \\
    \frac{(n-1)a_{11} + a_{21}}{n} & \frac{(n-1) \frac{(n-1)a_{11} + a_{21}}{n} + \frac{(n-1)a_{12} + a_{22}}{n}}{n} & \cdots & \frac{(n-1)a_{12} + a_{22}}{n} & \cdots \\
    \vdots & \vdots & \ddots & \vdots \\
    a_{21} & \frac{(n-1)a_{21} + a_{22}}{n} & \cdots & a_{22} & \cdots \\
    \vdots & \vdots & & \vdots & \ddots \\
    \end{bmatrix}
$$
Because the operation is toroidal, the "gaps" between the \$r\$-th row and the 1st row (resp. the \$c\$-th column and the 1st column) must also be filled, which is placed below the original elements of the \$r\$-th row (resp. on the right side of the \$c\$-th column).
You can take \$M\$ and \$n\$ (and optionally \$r\$ and \$c\$) as input and output the resulting matrix in any suitable format. \$n\$ is guaranteed to be a positive integer. The input matrix and the result may have non-integers.
Standard code-golf rules apply. The shortest code in bytes wins.
Test cases
# one-element matrix
M = [[1]], n = 3
[[1, 1, 1],
 [1, 1, 1],
 [1, 1, 1]]

# one-element matrix, large n
M = [[1]], n = 100
(100-by-100 matrix of ones)

# one-row matrix
M = [[0, 6, 3, 6]], n = 3
[[0, 2, 4, 6, 5, 4, 3, 4, 5, 6, 4, 2],
 [0, 2, 4, 6, 5, 4, 3, 4, 5, 6, 4, 2],
 [0, 2, 4, 6, 5, 4, 3, 4, 5, 6, 4, 2]]

# one-column matrix
M = [[0], [6], [3], [6]], n = 3
(transpose of the above)

# n = 1
M = [[1, 9, 8, 3],
     [5, 4, 2, 7],
     [3, 8, 5, 1]], n = 1
(same as M)

# 2-by-2 matrix; here the result is rounded to 2 decimal places for convenience.
# An answer doesn't need to round them, though one may choose to do so.
M = [[0, 9],
     [3, 6]], n = 3
[[0, 3,    6,    9, 6,    3],
 [1, 3.33, 5.67, 8, 5.67, 3.33],
 [2, 3.67, 5.33, 7, 5.33, 3.67],
 [3, 4,    5,    6, 5,    4],
 [2, 3.67, 5.33, 7, 5.33, 3.67],
 [1, 3.33, 5.67, 8, 5.67, 3.33]]

# a larger test case
M = [[0, 25, 0],
     [25, 0, 0],
     [0, 0, 25]], n = 5
[[0, 5, 10, 15, 20, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0],
 [5, 8, 11, 14, 17, 20, 16, 12, 8, 4, 0, 1, 2, 3, 4],
 [10, 11, 12, 13, 14, 15, 12, 9, 6, 3, 0, 2, 4, 6, 8],
 [15, 14, 13, 12, 11, 10, 8, 6, 4, 2, 0, 3, 6, 9, 12],
 [20, 17, 14, 11, 8, 5, 4, 3, 2, 1, 0, 4, 8, 12, 16],
 [25, 20, 15, 10, 5, 0, 0, 0, 0, 0, 0, 5, 10, 15, 20],
 [20, 16, 12, 8, 4, 0, 1, 2, 3, 4, 5, 8, 11, 14, 17],
 [15, 12, 9, 6, 3, 0, 2, 4, 6, 8, 10, 11, 12, 13, 14],
 [10, 8, 6, 4, 2, 0, 3, 6, 9, 12, 15, 14, 13, 12, 11],
 [5, 4, 3, 2, 1, 0, 4, 8, 12, 16, 20, 17, 14, 11, 8],
 [0, 0, 0, 0, 0, 0, 5, 10, 15, 20, 25, 20, 15, 10, 5],
 [0, 1, 2, 3, 4, 5, 8, 11, 14, 17, 20, 16, 12, 8, 4],
 [0, 2, 4, 6, 8, 10, 11, 12, 13, 14, 15, 12, 9, 6, 3],
 [0, 3, 6, 9, 12, 15, 14, 13, 12, 11, 10, 8, 6, 4, 2],
 [0, 4, 8, 12, 16, 20, 17, 14, 11, 8, 5, 4, 3, 2, 1]]

"an answer shouldn't round the values" - shouldn't or doesn't need to? Perhaps specify a minimum acceptable decimal precision?

@Shaggy Doesn't need to, my mistake. Of course any programming language will try to round to some places before printing it.

APL (Dyalog Extended), 27 26 bytes
-1 thanks to Bubbler.
Anonymous infix lambda. Takes \$n\$ as left argument and \$M\$ as right argument.
{⊃+⌿,(⍳⍺)⍉⍤⌽\⍣2⊂⍺/⍺⌿⍵÷⍺*2}

Try it online! (the \$n=100\$ case run out of memory on TIO gives by default, but works offline)
{…} "dfn"; ⍺ is \$n\$ and ⍵ is \$M\$
 ⍺*2 \$n^2\$
 ⍵÷ \$M\over n^2\$
 ⍺⌿ replicate vertically so each row becomes \$n\$ copies
 ⍺/ replicate horizontally so each column becomes \$n\$ copies
 ⊂ enclose to work on entire matrix
 (⍳⍺)…⍣2 do the following twice, each time with the \$0,1…n-1\$ as left argument:
  \ outer "product" using the following tacit function instead of multiplication:
   ⌽ cyclically rotate the rows by the indices
   ⍤ then:
    ⍉ transpose
 , flatten
 +⌿ sum
 ⊃ disclose (since the summation reduced rank from 1 to 0 by enclosing)

I guess ⍉⍤⌽ should save a byte?

"with the 0, 2, ..., n-1 as left argument:" has a typo

J, 22 bytes
(1#.&|:<@[1&|.[#%~)^:2

Try it online!
The "blur" is separable so operate in two passes where each pass operates on the rows and transposes its results.

Mathematica, 63?
I can't remember the rules regarding non-ASCII characters but it looks like they are in play.
ListCorrelate[##/n^2&[n-Abs[n-Range[2n-1]]],Upsample[m,n,n],1]

 is short notation for TensorProduct.

R, 97 92 91 86 bytes
function(m,n,`[`=apply)m[1,h][1,h<-function(i)approxfun(c(i,i))(0:(n*sum(1|i)-1)/n+1)]

Try it online!
Thanks to Giuseppe for -5 bytes.

I've never seen approx before. Right tool for the job. You can get down to 92 bytes.

Thanks, I was pretty sure there must be something for this in base R, but I actually hoped it would support 2D interpolation at once :)

Charcoal, 36 bytes
ＩＥ×ηＬθＥ×ηＬ§θ⁰∕ΣＥη∕ΣＥη§§θ÷⁺ινη÷⁺λπηηη

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

Cast the final array to string for implicit print (each row's cells print vertically and rows are double-spaced).
Ｅ×ηＬθ

Loop over each row of the final array.
Ｅ×ηＬ§θ⁰

Loop over each column of the final array.
∕ΣＥη∕ΣＥη§§θ÷⁺ινη÷⁺λπηηη

Extract an n-by-n square from a virtual array created by a simple inflation of the original array, where the top left of the square is at the final row and column. Cyclic indexing ensures that the square wraps around toroidally. The average of the elements is then taken.

Python 2, 109 bytes
M,n=input()
exec"M=[[i%n*((r*2)[i/n+1]-r[i/n])/n+r[i/n]for i in range(len(r)*n)]for r in zip(*M)];"*2
print M

Try it online!

JavaScript (ES10), 170 bytes
Takes input as (m)(n).
m=>n=>(T=m=>m.map((r,y)=>r.map((v,x)=>(M[x]=M[x]||[])[y]=v),M=[])&&M)((g=m=>m.map((r,y)=>r.flatMap((v,x)=>[...Array(n)].map((_,i)=>v+(r[-~x%r.length]-v)*i/n))))(T(g(m))))

Try it online! (with formatted outputs for readability)


text:
Lucky dice rolls
Lucky dice rolls
In pen and paper roleplaying games dice are used for various chance calculations. The usual way to describe a roll is \$n\textbf{d}k\$ where \$n\$ is the number of dice and \$k\$ is the number of faces on a die. For example \$3d6\$ means that you need to roll the classical 6-sided die 3 times (or roll 3 dice at the same time). Both \$n\$ and \$k\$ are positive integers. Each die's output value ranges from 1 to \$k\$.
Usually the values are then summed and they are used for various game mechanics like chance to hit something or damage calculations.
A lucky roll will mean that you have Fortuna's favor on your side (or against you). Luckiness is an integer number that increases (or decreases) the sum in the following way. The roll is modified to \${(n+|luck|)}\textbf{d}{k}\$ and the sum will be the \$n\$ best (or worst) values. Each die is fair, so they will have the same probability for the outcome of the possible values per die.
The \$luck\$ can be a negative number, in this case you need to get the \$n\$ worst values for the sum.
Input
The integer values for \$n,k,luck\$ in any way.
Output
The expected value for the sum of the (un)lucky roll. The expected value is \$\sum{x_{i} p_{i}}\$ where \$x_{i}\$ is the possible outcome of the sum and \$p_{i}\$ is the probability for \$x_{i}\$ occuring, and \$i\$ indexes all possible outcomes. The output value can be float or rational number, at least 3 decimal places of accuracy or a fraction of two integer numbers, whichever suits your program better.
Examples
n,k,luck    expected value
1,6,0       3.5
2,6,0       7
2,6,-1      5.54166
2,6,1       8.45833
2,6,-5      3.34854
2,10,-1     8.525
2,10,1      13.475
6,2,15      11.98223
6,2,-15     6.01776

Scoring
Shortest code in bytes wins.
Other
With this mechanic you essentially create fake dice using only fair dice. I wonder if there is a nice formula to calculate this mathematically.
Good luck! ;)

Shouldn't the fourth example have 8.458333333333 as expected answer? Rounding should not result in a trailing 4.

@Abigail Time for you to read What every computer scientist should know about floating-point arithmetic.

You may want to add a test case with $|luck|>1$. (Unless we always have $|luck|\le1$, in which case it should be specified.)

@Noodle9 I expect the examples to be exact (up to rounding), and not to show some  artifact from floating point arithmetic.

@Abigail Why do you expect base-10 precision from a binary device?

@Noodle9 I presume the OP is a human, not a binary device. No human should round the exact value of 1827 / 216 to 8.458333333333334.

@Abigail So you want the computer output edited by a human so it doesn't look like it came from a computer?

@Arnauld right, I just realized that, will add some more test cases, it should of course work for any integer.

@Abigail Yes, I'm a [human] beep, boop. Both of you are right but as I specified that at least 3 decimal places are enough I didn't think this would raise any concerns.

If I understand correctly: For a k faces dice, values on each faces would be 1 ~ k. Maybe this could be add to question specification.

@tsh right, it's a 1-indexed range, I added it to make it clear.

AnyDice, 82 bytes
function:l N K L{ifL<0{result:[lowestNof(N-L)dK]}else{result:[highestNof(N+L)dK]}}

Try it online!
For the output, check the "export" view and "summary" data and take the first value next to the output name (normally the link brings you there, but if you encounter issues, you know).
Ungolfed for readability
function: l N K L {                  \ function with 3 parameters                                     \
  if L<0 {                           \  if L is negative                                              \
    result: [lowest N of (N-L)dK]    \   return the lowest N dice among (N-L) rolls of a K-sided die  \
  } else {                           \  else                                                          \
    result: [highest N of (N+L)dK]   \   return the highest N dice among (N-L) rolls of a K-sided die \
  }                                  \  end if                                                        \
}                                    \ end function                                                   \

@Memberfor3months The value is incorrect for several test cases: 2, 6, 1, 2, 10, 1 and 6, 2, 15, basically all cases where L is strictly positive.

MATL, 24 bytes
|+i:Z^!S1G0>?P]2G:Y)XsYm

Inputs are: luck, n, k.
How it works
|      % Implicit input: luck. Absolute value
+      % Implicit input: n. Add. Gives n+|luck|
i:     % Input: k. Range [1 2 ... k]
Z^     % Cartesian power. Gives a matrix with n+|luck| columns, where each
       % row is a Cartesian tuple
!      % Transpose
S      % Sort each column in ascending order
1G     % Push first input (luck) again
0>     % Is it positive?
?      % If so
  P    %   Flip vertically: the order within each column becomes descending
]      % End
2G:    % Push second input (n) again. Range [1 2 ... n]
Y)     % Row-index. This keeps the first n rows
Xs     % Sum of each row
Ym     % Mean. Implicit display

Try it online! Or verify all test cases.

R, 106 96 88 bytes
function(n,k,l)n*mean(apply(expand.grid(rep(list(NA,1:k),n+abs(l))),1,sort,l>0,T)[1:n,])

Try it online!
Credit to Dominic van Essen for the l>0 for the descending argument to sort, and for golfing down a lot of other bytes!

Nice.  Another example where I accidentally learn something useful (expand.grid) while trying to waste time...

99 bytes if you simply take the mean of the (selected) dice rolls.

97 bytes with [] instead of head (assuming there aren't any annoying edge cases that get broken by this).

@DominicvanEssen neat! I saw you used that method of extracting the first n rows and the n*mean() in your code but I think I flubbed it by putting the [1:n,] after the apply() instead of after the matrix().

91 bytes by deliberately poisoning the matrix with some NAs, just to stop it collapsing to a vector in the 1-roll case.

Nice! You can just put the NA inside the list() to save some more bytes. It makes the array bigger, but who cares!

05AB1E, 15 bytes
L²³Ä+ãε{³.$O}ÅA

Inputs in the order \$k,n,luck\$.
Try it online or verify all test cases.
Explanation:
L             # Push a list in the range [1, (implicit) input `k`]
 ²            # Push the second input `n`
  ³Ä+         # Add the absolute value of the third input `luck`
     ã        # Take the cartesian product of the list and this value
      ε       # Map each inner list to:
       {      #  Sort the list
        ³.$   #  Drop the third input amount of leading items,
              #   `luck` = 0: no items are removed
              #   `luck` = 1: the first item is removed
              #   `luck` = -1: the last item is removed
           O  #  Sum the remaining list of values
      }ÅA     # After the map: calculate the average of this list of sums
              # (after which it is output implicitly as result)

Nice approach :-D

@LuisMendo Thanks. I see it's pretty similar as your answer and the Python answer in terms of the cartesian product and average (now that you've added an explanation, since I can't read MATL). :)

Yes, I guess that enumerating the possibilities and averaging is the golfiest approach in most languages...

[ I was by no means suggesting you took it from my answer. I just found the coincidence funny :-) On second thought, may be not so much a coincidence, just the straightforward approach ]

@LuisMendo I know. :) I also only noticed it was similar after you added an explanation. As you said, generating all sums and taking the average is probably the best approach for most languages.

Perl 5 -MList::Util=sum -ap, 116 bytes
@r=1..$F[1];$_=(sum map{(sort{$F[2]<0?$a-$b:$b-$a}/\d+/g)[0.."@F"-1]}@g=glob join$"=',',("{@r}")x("@F"+abs$F[2]))/@g

Try it online!
Enumerates all possible rolls, selects the top (bottom) entries from each list, adds all of those up, and divides by the number of combinations.

Nice as ever! Can't think of a different approach right now, but you can save a few bytes with a little re-organisation: Try it online!

R, 152 127 109 bytes
function(n,k,l,w=n+abs(l))n*mean(apply(cbind(NA,mapply(rep,list(1:k),e=k^(w:1-1),l=k^w)),1,sort,l>0,T)[1:n,])

Try it online!
Edit: -18 bytes thanks to Giuseppe for a really nice bit of programming!  Note that this solution avoids a key R built-in function expand.grid, but Giuseppe's improvement manages to close-the-gap on his own solution (that uses the function) quite a lot.
Commented:
lucky_total=function(n,k,l){
    m=n+abs(l)          # number of rolls including lucky rolls
    a=matrix(NA))       # initial (empty) matrix of roll results
    for(r in 1:m){      # do all the rolls & combine results in matrix
        a=cbind(a[rep(seq(d<-k^(r-1)),k),],rep(1:k,e=d))
    }
    mean(               # get the mean result of...
        apply(a,1,function(b)
                        # all the rolls, but only keeping
                        # the highest/lowest 'lucky' dice
                        # (using luck>0 to decide whether to sort
                        # increasing or decreasing)
            sum(sort(b,l>0)[1:n])
        )
    )
}

struggled mightily to get apply to do what I wanted for n=1; I see you went with na.last to get around that, but I ended up just reshaping the output as a matrix again, which seems to have worked, and I did steal your decreasing argument to sort in the apply :-)

109 bytes -- wanted to see if you could do it without expand.grid and ended up golfing it out more than I thought I could...

Incredible!  I'd given-up trying to improve this after realising I'd never beat your version with expand.grid!  The argument-recycling trick using mapply is brilliant: I had to run it several times to understand what's going on!

J, 45 bytes
Takes input as k on the left side and n, luck on the right side.
[:(+/%#){:@]+/@}.&|:1+[:/:~"1[#.inv(i.@^+&|/)

Try it online!
How it works
[:(+/%#){:@]+/@}.&|:1+[:/:~"1[#.inv(i.@^+&|/)
                                    i.@^+&|/ 0..k^(|n| + |luck|)
                             [#.inv          to base k 0 0 0..5 5 5
                        /:~"1                sort each roll
                    1+                       0 0 0 -> 1 1 1
        {:@]   }.&|:                         transpose and drop luck rows
                                             negative values drop from end
            +/                               sum each roll
  (+/%#)                                     average of all rolls

R, 131 119 bytes
function(Z,Y,l,E=Z*(1+Y)/2,`[`=pbinom)(sum(1:Y*((K=rep(1:Z-1,e=Y))[X<-abs(l)+Z,J<-1-1:Y/Y]-K[X,J+1/Y]))-E)*(-1)^(l<0)+E

Try it online!
Quite a fast implementation; calculates the value directly. It's binomials all the way down.
The key is the identity found here, for the expected value of a rolling \$X\$ d\$Y\$ and keeping the highest \$Z\$ of them. I rearranged it slightly to
$$\sum_{j=1}^{Y}j \sum_{k=0}^{Z-1} \sum_{l=0}^k \binom{X}{l}\left(\left(\frac{Y-j}{Y}\right)^l\left(\frac{j}{Y}\right)^{X-l} - \left(\frac{Y-j+1}{Y}\right)^l\left(\frac{j-1}{Y}\right)^{X-l}\right). $$
Recognizing the innermost sum as the difference of two binomial CDFs, it's implemented as
sum(1:Y*(p(K<-rep(1:Z-1,e=Y),X,J)-p(K,X,J+1/Y)))

for maximum (ab)use of R's recycling rules. There is then an adjustment for the fact that we may wish to keep the lowest n dice, but that's easy due to the symmetry of the binomial distribution.

nice find! I searched everywhere for a formula but this seems to be the one I was looking for :)

Python 2, 131 bytes
from itertools import*
n,k,l=input()
w=n+abs(l)
print sum(sum(sorted(x)[l>0and-n:][:n])for x in product(*[range(1,k+1)]*w))*1./k**w

Try it online!

range(1,k+1) -> range(k) and +n at the end: sum(sum(sorted(x)[l>0and-n:][:n])for x in product(*[range(k)]*w))*1./k**w+n

APL (Dyalog Unicode), 61 58 57 64 61 bytesSBCS
Full program, input order is k, luck and n.
(⊢⌹=⍨){w←1∘/⍵⋄1⊥w[⍒w]↑⍨n×(¯1*<∘0)l}¨(,∘.,)⍣(¯1+(n←⎕)+|l←⎕)⍨⍳⎕

Try it online! (with two extra bytes to print in TIO) or check all test cases!

JavaScript (ES10), 143 bytes
A naive, straightforward approach.
(n,k,l)=>eval([...Array(N=k**(t=l<0?n-l:n+l))].flatMap((_,v)=>[...Array(t)].map((_,i)=>-~(v/k**i%k)).sort((a,b)=>(a-b)*l).slice(-n)).join`+`)/N

Try it online!
How?
We generate \$N=k^{n+|l|}\$ arrays of length \$n+|l|\$ corresponding to all possible rolls, keeping only the \$n\$ best or \$n\$ worst die in each array.
We turn that into a single flat list of values, compute its sum and divide it by \$N\$.

perl -alp -MList::Util=sum, 144 bytes
@,=map{@;=sort{$a<=>$b}/\d+/g;pop@;for$F[2]..-1;shift@;for 1..$F[2];sum @;}glob join",",("{".join(",",1..$F[1])."}")x($_+abs$F[2]);$_=sum(@,)/@,

Try it online!
More readable written:
use 5.026;

use strict;
use warnings;
no  warnings 'syntax';

my ($n, $k, $luck) = @F;

my @a = map {         # Iterate over all possible rolls
    my @b = sort {$a <=> $b} /\d+/g;  # Grab the digits, sort them.
    pop @b for $luck .. -1;           # Remove the -luck best rolls.
    shift @b for 1 .. $luck;          # Remove the  luck worst rolls.
    sum @b;                           # Sum the remaining pips.
}
glob       #  Glob expansion (as the shell would do)
join ",",  #  Separate the results of each die in a roll.
           #  Almost any character will do, as long as it's
           #  not special for glob expansion, and not a digit
     (
        "{" .      # "{" introduces a set of things glob can choose from
            join (",", 1 .. $k) .   # 1 to number of faces
         "}"       # matching "}"
     ) x ($n + abs $luck);  # Number of dice in a roll

$_ = sum (@a) / @a;  # Sum the results of each different roll,
                     # and divide by the number of rolls; $_ is
                     # printed at the end of the program.

__END__

Reads space separated numbers from STDIN. Writes results to STDOUT.

JavaScript (Node.js), 116 bytes
k=>l=>g=(n,w=[],h=i=>i&&g(n-1,[...w,i])+h(i-1),L=l<0?-l:l)=>n+L?h(k)/k:eval(w.sort((a,b)=>(a-b)*l).slice(L).join`+`)

Try it online!

Charcoal, 57 bytes
ＮθＮηＮζ≧⁺↔ζθ≔ＸηθεＦε«≔⊕…⮌↨⁺ιεηθδＦ↔ζ≔Φδ⁻μ⌕δ÷⌊×δζζδ⊞υΣδ»Ｉ∕Συε

Try it online! Link is to verbose version of code. Explanation:
ＮθＮηＮζ

Input n, k and l.
≧⁺↔ζθ

Add |l| to n.
≔Ｘηθε

Calculate the number of possible outcomes of rolling n+|l| k-sided dice.
Ｆε«

Loop over each outcome index.
≔⊕…⮌↨⁺ιεηθδ

Generate the next outcome by converting to base k padded to length n+|l|.
Ｆ↔ζ

For each element of luck, ...
≔Φδ⁻μ⌕δ÷⌊×δζζδ

... remove the lowest or highest value from the outcome.
⊞υΣδ

Save the sum of the remaining dice.
»Ｉ∕Συε

Output the average sum.
41 bytes if l is limited to -1, 0 or 1:
ＮθＮηＮζ≧⁺↔ζθ≔ＸηθεＩ∕ΣＥＥε⊕…⮌↨⁺ιεηθ⁻Σι×⌊×ιζζε

Try it online! Link is to verbose version of code. Explanation:
ＮθＮηＮ

Input n, k and l.
≧⁺↔ζθ

Add |l| to n.
≔Ｘηθε

Calculate the number of possible outcomes of rolling n+|l| k-sided dice.
Ｉ∕ΣＥＥε⊕…⮌↨⁺ιεηθ⁻Σι×⌊×ιζζε

Generate all the possible outcomes, but if the luck is -1 or 1 then subtract the largest or smallest entry from the sum, finally calculating the average sum.