text:
Fivenum and a little bit
(a paradox, a paradox, a most ingenious paradox)
This is the first part of a multipart series inspired by different R functions.
The Task
Given a dataset \$D\$ of positive integers, I need you to compute the 5 number summary of \$D\$. However, I'm working on large datasets, so I need your code to be as small as possible, allowing me to store it on my computer.
The five number summary consists of:

Minimum value
First quartile (Q1)
Median / Second quartile (Q2)
Third quartile (Q3)
Maximum value

There are several different ways of defining the quartiles, but we will use the one implemented by R:
Definitions:

Minimum and maximum: the smallest and largest values, respectively.
Median: the middle value if \$D\$ has an odd number of entries, and the arithmetic mean of the two middle-most values if \$D\$ has an even number of entries. Note that this means the median may be a non-integer value. We have had to Compute the Median before.
First and Third Quartiles: Divide the data into two halves, including the central element in each half if \$D\$ has an odd number of entries, and find the median value of each half. The median of the lower half is the First Quartile, and the median of the upper half is the Third Quartile.

Examples:
\$D=[1,2,3,4,5]\$. The median is then \$3\$, and the lower half is \$[1,2,3]\$, yielding a first quartile of \$2\$, and the upper half is \$[3,4,5]\$, yielding a third quartile of \$4\$.
\$D=[1,3,3,4,5,6,7,10]\$. The median is \$4.5\$, and the lower half is \$[1,3,3,4]\$, yielding a first quartile of \$3\$, and the upper half is \$[5,6,7,10]\$, yielding a third quartile of \$6.5\$.
Additional rules:

Input is as an array or your language's nearest equivalent.
You may assume the array is sorted in either ascending or descending order (but please specify which).
You may return/print the results in any consistent order, and in whichever flexible format you like, but please denote the order and format in your answer.
Built-in functions equivalent to fivenum are allowed, but please also implement your own solution.
You may not assume each of the five numbers will be an integer.
Explanations are encouraged.
This is code-golf, so shortest answer in each language wins!

Randomly generated test cases
1 1 1 1 1 2 2 2 2 2 3 3 4 4 4 4 4 5 5 5 -> 1 1.5 2.5 4 5
1 2 2 2 4 4 5 5 6 7 7 8 9 9 9 9 9 10 10 10 -> 1 4 7 9 10
2 2 2 6 8 10 15 16 21 22 23 24 26 33 35 38 38 45 46 47 48 -> 2 10 23 38 48
1 2 9 -> 1 1.5 2 5.5 9
1 2 3 3 3 4 9 -> 1 2.5 3 3.5 9
1 1 2 5 7 7 8 8 15 16 18 24 24 26 26 27 27 28 28 28 29 29 39 39 40 45 46 48 48 48 48 49 50 52 60 63 72 73 79 85 86 87 88 90 91 93 94 95 95 97 100 -> 1 25 45 76 100
2 2 4 4 6 8 10 11 13 14 14 15 17 21 23 24 26 27 27 28 28 30 31 33 33 34 36 36 38 38 39 40 41 42 42 43 45 45 47 47 47 47 47 48 48 48 50 51 53 53 55 56 56 56 57 57 58 62 62 63 64 64 65 65 66 67 67 67 68 69 69 71 71 71 74 79 80 81 81 81 82 82 83 83 86 86 86 87 89 94 94 94 95 95 97 98 99 100 100 100 -> 2 33.5 54 76.5 100
1 3 3 4 -> 1 2 3 3.5 4
1 3 3 3 4 -> 1 3 3 3 4

R, 7 bytes
fivenum

Try it online!
Obvious cheeky answer. ;-)
Interestingly, fivenum(x) is not equivalent to summary(x) even when x is numeric, as the quantiles are computed differently: fivenum averages at discontinuities, whereas summary interpolates. You can force summary to behave like fivenum with the option quantile.type, but this is still longer than
R, 51 bytes
function(x)quantile(x,(0:4)/4,t=2+5*!sum(!!x)%%4-3)

Try it online!
which computes the quantiles of order 0 (min), 0.25 (Q1), 0.5 (median), 0.75 (Q3) and 1 (max). The t=2 specifies how quantiles are defined: there are 9 possible types, and the challenge definition corresponds to type 2 in most cases, and to type 7 when \$n\equiv 3\pmod 4\$. Honestly, this choice of a definition of quantiles is a bit weird.
Note that the source code of the fivenum built-in is very different (and much longer).

The only thing I can find is that quantile returns a named vector, while fivenum is unnamed. Maybe that's a problem downstream of where fivenum is used?

@JAD Enclosing the code in unname() would solve that. Maybe there are historical reasons?

Your function differs from fivenum for inputs of length 3 mod 4, including two of the test cases.

@Nitrodon Argh! Thanks for noticing! It should be OK now.

MATL, 18 bytes
tno?t.5Xqh]5:q4/Xq

Output order is increasing, as in the test cases.
Try it online! Or verify all test cases.
Explanation
MATL, like MATLAB, computes quantiles using linear interpolation if needed (just as specified in the challenge for the median). To achieve the required behaviour for the first and third quartiles, it suffices to repeat the median if the length of the input is odd. Then the results are just the 0, .25, .5, .75 and 1 quantiles.
t       % Implicit input: numeric row array. Duplicate
no      % Length, parity
?       % If not zero (that is, if input length is odd)
  .5    %   Push .5
  Xq    %   .5-quantile: median. For even length it behaves as required
  h     %   Concatenate horizontally
]       % End
5:q     % Push [0 1 2 3 4]
4/      % Divide by 4, element-wise: gives [0 .25 .5 .75 1]
Xq      % [0 .25 .5 .75 1]-quantiles. Implicit display

Jelly, 13 bytes
œs2a\;WÆṁ;Ḣ;Ṫ

Try it online!
Order: [Q1, Q3, Q2/med, min, max].

Python 3.8 (pre-release), 66 bytes
lambda l:[(l[~-i//4]+l[-~i//4])/2for i in[1,n:=len(l),~n-n,~n,-3]]

Try it online!
Input and output are in ascending order.

Python 3.8, 97 bytes
lambda l:[l[0],l[-1]]+[(i[x(i)//2]+i[~x(i)//2])/2for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])]

This assumes that the input list is sorted in ascending order. f is the function to return the 5-number summary.
The 5-number summary is in the order: \$\{min, max, Q1, Q2,Q3\}\$
I took off a few bytes by taking some hints from FlipTack's answer to Compute the Median.
Try it online!
How does it work?
lambda l:
    [l[0],l[-1]] # The minimum and maximum, because l is assumed to be sorted in ascending order
    +[(i[x(i)//2]+i[~x(i)//2])/2 # This line computes the median...
    for i in(l[:~((x:=len)(l)//2-1)],l,l[x(l)//2:])] # ...for each of these lists (the first half, the overall list, and the second half)
    # The (x:=len) is an assignment expression from Python 3.8.
    # It assigns the len function to the variable x but also returns len.
    # Therefore, x can be used as len to save a byte (yes, just one byte)

it's fine to use a function that computes the median; that submission would no longer by Python (3?), but "Python + statistics package" or similar.

C (gcc), 123 121 119 bytes
-2 thanks to ceilingcat.
Assumes a list sorted in ascending order.
Outputs in order: min, Q1, Q2, Q3, max.
#define M(K,x)(K[~-x/2]+K[x/2])/2.,
f(L,n,m)int*L;{m=n-n/2;printf("%d %f %f %f %d",*L,M(L,m)M(L,n)M((L+n/2),m)L[n-1]);}

Try it online!

Charcoal, 33 bytes
≔⊖ＬθηＩＥ⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧⊘⁺§θ⌊ι§θ⌈ι

Try it online! Link is to verbose version of code. Outputs in ascending or descending order depending on whether the input is in ascending or descending order. Explanation:
≔⊖Ｌθη

Get the index of the last element.
ＩＥ

Map over the elements of the following array and cast the result to string for implicit print on separate lines.
⟦⁰⊘÷η²⊘η⁻η⊘÷η²η⟧

Calculate the positions of the quartile elements, where an extra 0.5 denotes that the value is the average of two adjacent elements.
⊘⁺§θ⌊ι§θ⌈ι

Calculate the quartile at each position by taking the average of the values at the floor and ceiling of the position.

Ruby 2.7-preview1, 59 bytes
A direct ripoff port of xnor's Python answer.
->a{[1,n=a.size,~n-n,~n,-3].map{(a[~-@1/4]+a[-~@1/4])/2.0}}

Try it online! (one byte longer since TiO is using Ruby 2.5 and doesn't have numbered block parameters e.g. @1).

05AB1E, 18 bytes
2F2äнIR})€ÅmIWsà‚«

Output-order is: [Q1, Q3, Q2, min, max].
Try it online or verify all test cases. (I've added a sort { for the test suite, so the test cases are easier to verify in the order [min, Q1, Q2, Q3, max].)
Explanation:
2F                 # Loop 2 times:
  2ä               #  Split the list at the top of the stack into two halves
                   #  (which is the (implicit) input-list in the first iteration)
    н              #  Only leave the first halve
     IR            #  Push the input in reverse
       })          # After the loop: wrap all three lists into a list
         €         # For each of the lists:
          Åm       #  Get the middle/median depending on the parity of the size of the list
            I      # Then push the input-list again
             W     # Get the minimum (without popping)
              s    # Swap to get the input-list again
               à   # Get the maximum (by popping the list)
                ‚  # Pair the min-max together to a pair
                 « # And merge both lists together
                   # (after which the result is output implicitly)


text:
String to Bit Transition
Task
Given an input string of one or more ASCII characters which codepoints are between 0 and 128 (exclusive), do the following:

Convert each character into its 7-bit ASCII code (if the ASCII code is less than 7 bits, put leading zero bits)
Concatenate all bits (this results in 7*n bits where n is the number of characters)
For each bit in this bitstream, print 1 if it is different from the previous bit, and print 0 otherwise. The first output bit is always 1.

Example
Input:
Hi

Output:
11011001011101

Explanation:

The string "Hi" has the ASCII codes
72 105
which in bits are:
1001000 1101001
And the transition bits indicators:
11011001011101

This is code golf. Lowest byte count wins.
Test Cases
Test case 1:
Hello World!
110110010101110011010101101010110001110000111110000110000001011101101010101100110001

Test case 2:
%% COMMENT %%
1110111111011111100001100010010100001010110101011010011101010011111110011000001101111110111

Test case 3 (credit to Luis Mendo):
##
11100101110010

Congrats to Luis Mendo for the shortest solution with 9 bytes in MATL!

I'm confused - don't you mean 1 if the bit is different than the previous one?

Oops, yeah, sorry, fixed that. Error after editing. Thanks @ChasBrown

There are 7! Way at last concatenate 2 7 bits string, and you not show either in example which one

Suggested test case ## (leading 0 bit; some answers currently fail because of that)

How is this a duplicate of the Manchester encoding challenge? Am I missing something?

The other challenge says converting an input stream of bits into a double-rate output stream, with each input '1' translated to a '01' and each input '0' translated to a '10'. So not dupe in my opinion. If a large number of people upvote @gastropner's comment above I can un-dupe (or any other user with that ability)

@Shaggy: Both test cases include a space, which has only a single bit set, and not the 7th.  So I don't think the problem statement is guaranteeing that each ascii code will be exactly 7 bits in length.

@Shaggy, yes, I perhaps should clarify that if the ascii code is less than 7-bit it should be prepended with leading zeros. And, like recursive said, the space character already has less than 7 bits.

@LuisMendo, the % character (second test case) also starts with 0.

@justhalf In some languages, if at least on character has all 7 bits (i.e. starts with 1) then all characters in the string are converted to 7 bits, even if fewer bytes would suffice for some characters. Consider this example in Octave, and compare with this, which only produces 6 bits. My test case was aimed to catch that sort of mistake

Ah, ok. I am not familiar with that. Thanks for catching that! I'll add the third test case.

Do I need to support a string of length 0?  Also, I can save a few bytes if it is guaranteed that for characters wider than 7-bits, all bits above the 7th are 0 - I'll assume that's the case unless you say otherwise

Bits above the 7th are all 0 -> yes, since the maximum code point that I would like to test is 127 (less than 128), as given in the description. String of length 0 I haven't really considered, but I guess it should be supported.

Does the code have to support embedded zero bytes? (for example, C uses zero bytes as string terminator).

It's ok to not handle null bytes.

@SmileAndNod On second thought, I think you don't need to handle empty string.

MATL, 9 bytes
Hj7&B!hdg

Try it online!
Explanation
H     % Push 2
j     % Read line of input, unevaluated
7&B   % Convert to binary with 7 bits. Gives a 7-column matrix
!     % Transpose
h     % Concatenate horiontally. The matrix is read in column-major order
d     % Consecutive differences
g     % Convert to logical. Implicitly display

This is the shortest so far. +1. It's fun to have a built-in for consecutive differences.

Python 2, 58 bytes
n=1
for c in input():n=n<<7|ord(c)
print'1'+bin(n^n/2)[4:]

Try it online!

How big can n be that Python supports for this operation?

@justhalf I don't think there's any limit other than your computer's memory. Python supports whole numbers of arbitrary size, and bit operations don't assume any fixed size.

Japt -P, 11 bytes
Takes advantage of the fact that spaces can be coerced to 0 in JavaScript when trying to perform a mathematical or, in this case, bitwise operation on it.
c_¤ù7Ãä^ i1

Try it or run all test cases
c_¤ù7Ãä^ i1     :Implicit input of string
c_              :Map codepoints
  ¤             :  Convert to binary string
   ù7           :  Left pad with spaces to length 7
     Ã          :End map
      ä^        :XOR consecutive pairs
         i1     :Prepend 1
                :Implicitly join and output

The 7-bit means that if it is 32 (for space character), it would be 0100000.
Also the % character (37) would be 0100101

It's working now. +1

Jelly, 12 bytes
O+Ø⁷BḊ€FIA1;

Try it online!

Octave, 36 30 bytes
Fix thanks to Luis Mendo
-2 bytes thanks to Sanchises

@(a)[1;~~diff(de2bi(a,7)'(:))]

Try it online!

You can probably shave off quite a few bytes with de2bi.

Wasn't working for me before @sanchises but I'll take another look when I can

Try it online!

CJam, 21 bytes
1q{i2b7Te[}%e__(;.^);

Try it online!
Explanation
Showing the stack with a sample input of 5:
1 q      e# Push 1 and then the whole input: 1 "5"
{
  i      e# Convert to its char code: 1 [53]
  2 b    e# Convert to binary: 1 [[1 1 0 1 0 1]]
  7 T e[ e# Left-pad with 0 to length 7: 1 [[0 1 1 0 1 0 1]]
} %      e# Map this block over every character in the string
e_       e# Flatten array: 1 [0 1 1 0 1 0 1]
_ ( ;    e# Duplicate array and remove its first element: 1 [0 1 1 0 1 0 1] [1 1 0 1 0 1]
. ^      e# Element-wise xor: 1 [1 0 1 1 1 1 1]
) ;      e# Remove and pop the last element of the array: 1 [1 0 1 1 1 1]
         e# Stack implicitly printed: 1101111

To see if a bit is different from the previous bit, we do a vector (element-wise) xor between the bit array and the bit array without the first element. We also remove the last bit of the result, because it is always the last bit of the longer array unchanged.

Ruby -p, 68 57 bytes
-11 bytes by shamelessly stealing the method used by xnor's Python solution.
l=1
gsub(/./){l=l<<7|$&.ord}
$_=?1+(l^l/2).to_s(2)[2..-1]

Try it online!
Original solution:
gsub(/./){'%07b'%$&.ord}
l=p
gsub(/./){b=$&.ord-48;r=l ?l^b:1;l=b;r}

Try it online!

APL (Dyalog Unicode), 16 bytesSBCS
Full program. Prompts for string from stdin.
1,2≠/∊1↓¨11⎕DR¨⍞

Try it online!
⍞ prompt for input ("a quote in a console")
11⎕DR¨ change each character to bit-Boolean Data Representation
1↓¨ drop the first bit from each
∊ ϵnlist (flatten)
2≠/ pairwise difference
1, prepend a one

Dart, 213 168 bytes
f(s,{t,i}){t=s.runes.map((r)=>r.toRadixString(2).padLeft(7,'0')).join().split('').toList();for(i=t.length-1;i>0;i--)t[i]=t[i]==t[i-1]?'0':'1';t[0]='1';return t.join();}

Previous one-liner
f(String s)=>'1'+s.runes.map((r)=>r.toRadixString(2).padLeft(7,'0')).join().split('').toList().reversed.reduce((p,e)=>p.substring(0,p.length-1)+(p[p.length-1]==e?'0':'1')+e).split('').reversed.join().substring(1);

Try it online!
This verbosity and lack of easy built ins is really killing this one. Still managed to pull a one liner though.

-45 bytes by not using a one liner and using a for loop

Charcoal, 25 bytes
⭆θ◧⍘℅ι²¦⁷←Ｗⅈ←Ｉ﹪⍘ＫＤ²←01 ²1

Try it online! Link is to verbose version of code. Explanation:
⭆θ◧⍘℅ι²¦⁷←

Convert all the characters to binary and pad them to a length of 7 and then print them, but leave the cursor over the last digit.
Ｗⅈ

Repeat until the cursor is over the first digit.
←Ｉ﹪⍘ＫＤ²←01 ²

Calculate whether the digits are different and overwrite each digit with the difference.
1

Overwrite the first digit with a 1.

PowerShell, 73 56 49 bytes
$args|%{$b=+$_
6..0}|%{+($c-ne($c=($b-shr$_)%2))}

Try it online!
-17 bytes thanks to mazzy :)

-17 bytes :D

Awesome, you have to post it yourself.

this answer for you. my princess is in another castle :))))

@mazzy, some more -7 bytes :)

awesome and brilliant! 【ツ】

05AB1E (legacy), 12 bytes
Çb7jð0:¥ÄJ1ì

Uses the legacy version of 05AB1E, since j implicitly joins the strings together, which requires an explicit J after the j in the new version of 05AB1E.
Try it online or verify all test cases.
Explanation:
Ç             # Convert the (implicit) input-string to a list of ASCII code-points
              #  i.e. "Hi#" → [72,105,35]
 b            # Convert each integer to a binary string
              #  → ["1001000","1101001","100011"]
  7j          # Prepend each with spaces to make them length 7,
              # and join everything together to a single string implicitly
              #  → "10010001101001 100011"
    ð0:       # Replace all those spaces with 0s
              #  → "100100011010010100011"
       ¥      # Get the deltas of each pair of 1s/0s
              #  → [-1,0,1,-1,0,0,1,0,-1,1,-1,0,1,-1,1,-1,0,0,1,0]
        Ä     # Get the absolute value of this
              #  → [1,0,1,1,0,0,1,0,1,1,1,0,1,1,1,1,0,0,1,0]
         J    # Join them all together
              #  → "10110010111011110010"
          1ì  # And prepend a 1
              #  → "110110010111011110010"
              # (after which the result is output implicitly)

Husk, 16 15 14 bytes
:1Ẋ≠ṁȯΩo=7LΘḋc

Try it online!

It is really ridiculous how many bytes one seems to need to waste to pad with zeros to the left!  I came up with this :1Ẋ≠ṁö↑_7+ḋ64ḋc as an alternative 15-byte solution...  surely there's a slicker way...?

Vyxal, 20 16 15 bytes
bƛṅS7↳vċ†;f¯ȧ1p

Try it Online!
A mess. -4 thanks to Aaron Miller. -1 thanks to lyxal.

16 bytes

15 bytes

Stax, 13 12 bytes
ìEÖâU₧(~¬8IE

Run and debug it
If it's guaranteed that all input characters have the 7th bit set, as some answers assume, it can be done in 10 bytes

Python 2, 104 bytes
lambda w:reduce(lambda(A,P),C:(A+'10'[P==C],C),bin(reduce(lambda a,c:a*128+ord(c),w,1))[3:],('','x'))[0]

Try it online!
A quick stab at it.

Clever trick with a*128+ord(c)! But isn't the reduce and lambda kind of costly?

K (ngn/k), 9 13 bytes
Solution:
~=':,/(7#2)\'

Try it online!
Explanation:
~=':,/(7#2)\' / the solution
           \' / convert each
      (   )   / do this together
       7#2    / 2 2 2 2 2 2 2
    ,/        / flatten
 =':          / equal to each-previous?
~             / not

Notes:

+4 bytes to support strings consisting only of 6-bit chars

This seems to fail for input # for example (output only has 6 bits)

@streetster, do you want to post the fixed version?

Python 3, 88 84 bytes
l=2;s=''
for c in''.join(f'{ord(c):07b}'for c in input()):s+='01'[l!=c];l=c
print(s)

Try it online!
I feel that the assignments should be avoidable, but couldn't think of any way to do that.
Update:

-4 bytes thanks to movatica

84 bytes

Kotlin, 182 bytes
var l='6'
fun f(b:String)=b.fold(""){t,i->t+"".a(i.toInt())}.map{if(l==it){l=it;0} else {l=it;1}}
fun String.a(v:Int):String=if(v<=0)"${this}0".reversed() else "${this}${v%2}".a(v/2)

Try it online!
Hopefully I can improve this soon, I feel like there must be some spots for improvement but I can't think right now

JavaScript (V8), 150 95 bytes
-55 thanks to @dana
x=>[...[...x].reduce((a,c)=>a+c.charCodeAt(0).toString(2).padStart(7,0),"")].map(c=>x!=(x=c)|0)

Try it online!

Ruby -p, 50 bytes
gsub(/./){"%07b"%$&.ord}
gsub(/./){$`=~/#$&$/?0:1}

Try it online!
Explanation
First line, same as Value Ink's answer:
gsub(/./){       $&    }   # Replace each character $&…
                   .ord    # …with its ASCII code…
                %          # …formatted as…
          "%07b"           # …binary digits padded to 7 places.

Second line:
gsub(/./){      $&      }  # Replace each character $&…
          $`               # …if the text to its left…
            =~             # …matches…
              /#  $/       # …the Regexp /c$/ where "c" is the character…
                    ?0:1   # …with 0, or 1 otherwise.

In Ruby you can use interpolation in Regexp literals, e.g. /Hello #{name}/, and for variables that start with $ or @ you can omit the curly braces, so if e.g. $& is "0" then the grawlixy /#$&$/ becomes /0$/.

Perl 5 -p, 60 bytes
s/./sprintf'%07b',ord$&/ge;s/.(?=(.))/0|$&^$1/ge;s/^/1/;chop

Try it online!

C (gcc (MinGW)), 90 bytes
Requires a compiler providing itoa().
n[9],b,c;f(char*s){for(b=*s<64;c=*s++;printf("%07s",itoa((c^c/2)&127,n,2)))c|=b<<7,b=c&1;}

88 bytes

Python3.8, 72 bytes
Solution:
lambda a:["10"[a==(a:=x)]for x in"".join(bin(ord(i)+128)[3:]for i in a)]

Explanation:
Ever since Python 3.8 introduced assignment expressions (rather than the standard assignment statements), I have wanted to use them in a list comprehension that needs to remember the last item.
This is not the best way to do this but demonstrates an interesting method of using the assignment expression.
The code creates a lambda function which takes the required argument which is the string to convert. When called, the function proceeds as follows. Every character in a is converted to its character code which 128 is added to for dealing with 6-bit characters (the binary representation will always be 8 bits and we can chop off the first bit). This number is converted to binary and the header (0x) and the initial 1 from adding 128 is chopped off. These new strings are then joined into one larger string.
For each character in this new string (which contains the concatenated 7-bit representation of the text), it is checked if the character is the same as the previous character. What happens with the first character? The first result character should always be "1" so we just have to make sure that whatever is in the last character variable is neither "1" nor "0". We do this by reusing the original parameter now that we are not using it anymore. This may be a problem if the original string was a single "0" (a single "1" just happens to work) but we will ignore that.
During the comparison, the previous character was evaluated first so when we use the assignment expression to set the previous character variable to the current character, it does not affect the comparison expressions' evaluation.
The comparison either produces True or False which can also be used as 1 or 0 respectively in Python, so they are used to look up either a "1" or "0" in a string

You can save some bytes by using string format literals: bin(ord(i)+128)[3:] -> f"{ord(i):07b}"

Emojicode, 263 bytes
➡sb❗❗sb❗➕128 2❗1 7❗➡s?➡pb s↪bp0❗1❗b➡p

Try it online here.
Ungolfed:
    Main code block
     ➡   s   Start with s as the empty string
     b       For each byte b in the input ...
    ❗ ❗
         s   ... append ...
              b ❗ ➕ 128   ... b + 128 (this gives the leading zero(s) in case the binary representation of b is shorter than 7 digits) ...

                 2   ... in binary ...
              ❗
              1 7   ... without the leading one ...
           ❗

        ➡  s   ... to s

    ? ➡   p   This will be used as the previous character, by assigning it neither 0 nor 1 we assure the first bit output is always a one
     b s    For each character in s:
        ↪ b  p    If it is the same as the previous character ...
             0 ❗   ... output a zero ...
              ... else ...
             1 ❗  ... output a one

        b ➡  p   And the current character becomes the new previous character.

Tcl, 215 167 140 bytes
{{s {B binary} {X ~$w/64}} {join [lmap c [split $s {}] {$B scan $c c w;$B scan [$B format i [expr 2*$w^$w^$X<<7]] B7 r;set X $w;set r}] ""}}

Try it online!
Uses shift-by-one and exclusive-or to detect transitions. Carries lsb of current character to msb of next character. Combines output for each character by joining list returned by lmap.
Uses lambdas with default arguments to save bytes on initialization and repeated commands.
Relies heavily on order of operation.  Works for empty string.

Haskell, 137 bytes
import Data.Char
b 0=[]
b n=odd n:b(n`div`2)
d x|x='1'|1<2='0'
c=('1':).map d.(zipWith(/=)<*>tail).concatMap(reverse.take 7.b.(+128).ord)

Try it online!
The biggest problem here is converting booleans (result of the XOR) to '0'/'1'.

PHP, 90 bytes
for(;$c=ord($argn[$j++]);$o.=sprintf('%07b',$c));for(;($q=$o[$i++])>'';$p=$q)echo$p!=$q|0;

Try it online!

C# (Visual C# Interactive Compiler), 80 bytes
s=>{for(int p,c=2,i=0;i<7*s.Length;Write(p==c?0:1))(p,c)=(c,1&s[i/7]>>6-i++%7);}

Try it online!

JavaScript (V8), 73 bytes
s=>[...c=s.repeat(7)].map((_,i)=>(c=1&s.charCodeAt(i/7,p=c)>>6-i%7)!=p|0)

Try it online!

source: Stack Exchange

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

sort: votes


text:
Mutation chain generator
Given a start word and a target word, print the "mutation chain" that starts at the start word and ends at the target word.
You may assume both words are lowercase and only have alphabetic characters.
Define a "mutation" as the removal of an character, the insertion of a character, or the altering of a character.
For example, "hi" can be mutated into:
ahi
ai
bhi
bi
chi
ci
dhi
di
ehi
ei
fhi
fi
ghi
gi
h
ha
hai
hb
hbi
hc
hci
hd
hdi
he
hei
hf
hfi
hg
hgi
hh
hhi
hhi
hi
hi
hia
hib
hic
hid
hie
hif
hig
hih
hii
hii
hij
hik
hil
him
hin
hio
hip
hiq
hir
his
hit
hiu
hiv
hiw
hix
hiy
hiz
hj
hji
hk
hki
hl
hli
hm
hmi
hn
hni
ho
hoi
hp
hpi
hq
hqi
hr
hri
hs
hsi
ht
hti
hu
hui
hv
hvi
hw
hwi
hx
hxi
hy
hyi
hz
hzi
i
ihi
ii
jhi
ji
khi
ki
lhi
li
mhi
mi
nhi
ni
ohi
oi
phi
pi
qhi
qi
rhi
ri
shi
si
thi
ti
uhi
ui
vhi
vi
whi
wi
xhi
xi
yhi
yi
zhi
zi
A mutation chain is a chain of these mutations, such as:
hi -> hei -> heio -> helo -> hello
Your task is to calculate the shortest possible mutation chain that starts from one word and ends in the other. Since there may be multiple such chains, you may print any.
For example, when
hi
hello

is input, the output may be
hi
hei
heio
helo
hello

or any valid chain of length 5.
Standard loopholes apply; shortest code wins.
For an arbitrary start word and end word of length less than 30, your program should terminate in less than a minute when run on a standard PC (i.e. Core 2 Duo) and use less than 128 MB of memory.

Is this sequence also okay? hi->he->hel->hell->hello

Suggested test case tt -> test for programs that might replace the second t rather than insert between them.

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


text:
Print the previous answer in reverse - with a catch
Your challenge is very simple: output the previous answer, in reverse.
However, as with this similarly-titled question, there's a catch: in this case, you can only use characters from the answer before the last. For example:
Let's say the first answer looks like this:

1 - Python
print('hi!')

And the second answer looks like this: (see 'Chaining' section for more info)

2 - Javascript
console.log(")'!ih'(tnirp")

Now, it would be my job to write the third answer: a program to output the text )"print('hi!')"(gol.elosnoc, while only using the characters p, r, i, n, t, (, ', h, i, ! and ). I can choose whatever language I like to complete this task.
Chaining
The first answer can output any text: but it must output something. The second answer should simply output the first answer in reverse, using any characters you like. The further rules about restricted characters, as described above, come into play from the third answer onwards.
Scoring
Your score is \$\frac{l_{n}}{l_{n-1}} + l_{n-2}\$, where \$l_x\$ represents the length of the \$x\$th answer, and \$n\$ is the position your answer is at in the chain. (all lengths are in bytes; if your answer is no. 1 or no. 2 then miss out \$l_{n-1}\$ and/or \$l_{n-2}\$ where necessary.
Best (lowest) score by August 1st wins.
Formatting
Please format your post like this:
[Answer Number] - [language]

    [code]
    (preferably a TIO link)

SCORE: [Submission Score]

(notes, explanations, whatever you want)

Everything in square brackets is a required argument to fill in; everything in normal brackets is an optional argument; everything not in brackets is there to make the snippet work.
Rules

All characters, etc. are case sensitive.
Preceeding/trailing whitespace is allowed, within reason (I'm looking at you, Whitespace).
Every submission must be a unique language.
You must wait at least 1 hour before submitting a new answer if you have just posted.
You may NOT submit two answers in a row, you must wait for TWO more submissions before posting a new answer.
Of course, standard loopholes are disallowed.
Please make sure to triple check that your answer is valid. ~This is especially important, because someone may start writing their answer based on yours, so if it's wrong you can't really edit it any more... and the whole chain breaks down.~ Also, you can't edit answers for continuity purposes.
Standard I/O methods are allowed.

Answer list/used languages

$.ajax({
  type: "GET",
  url: "https://api.stackexchange.com/2.2/questions/187667/answers?site=codegolf&filter=withbody&sort=creation&order=asc",
  success: function(data) {
    for (var i = 0; i < data.items.length; i++) {
      var temp = document.createElement('p');

      temp.innerHTML = data.items[i].body.split("\n")[0];

      try {
        temp.innerHTML += " - Score: " +
          data.items[i].body
          .split("SCORE")[1]
          .split("\n")[0]
          .split(":")[1]
          .trim() +
          "";
      } catch (TypeError) {
        temp.innerHTML += " (no score)";
      } finally {
        $('#list').append('
' + temp.innerText || temp.textContent + '');
      }
    }
  }
})

<base href="https://codegolf.stackexchange.com">

What's the winning criterion?

Do different versions of a language count as unique (is every version a unique language)?

@GezaKerecsenyi Pretty sure you should + the score of the previous answer to mine, or nobody will ever beat 1.64

I like the challenge, but don't understand the scoring rule. As is, the score of answer $n$ will almost always be higher (hence worse) than the score of answer $n-2$. It is almost certain that answer 2 will be the winner.

While the character limitation seems interesting, It looks like it's quickly going to devolve into extremely esoteric languages.

@RobinRyder That's the point of the challenge... sort of Kolmogorov-complexity-y.

What @RobinRyder is trying to point out is not the nature of the challenge, but how it is scored. Right now, if I were post an answer to this challenge, it would  have a score of at least 57 (the score of the first answer), even if it were (somehow) a zero-byte program. The fourth answer would have a score of at least 1.12 (the score of the second answer), even if it were (somehow) a zero-byte program. The fifth answer would have a score of at least the score of the third answer, and so on, meaning that no answer with a lower score than the second answer is possible.

This was the point I was trying to make earlier too. Mine should at least have the previous answer added too (and the first answer should be non-competing/infinite score)

I think this needs more work before continuing: both the character limitations and the scoring. With regards to the former, if someone uses an esolang that only needs 2 characters, that effectively will restrict all future alternate answers to that language.

@NickKennedy "Every submission must be a unique language.", that wouldn't restrict all answers to that language, it would make the challenge nearly impossible (one could write an answer in Lenguage at any point, which would make the challenge even harder to answer)

@pppery yes sorry, missed that. I saw the ‘I can use whatever language I like’ and took that literally.

I suggest copying this to the Sandbox, and reposting it once you have had enough feedback there to fine-tune this challenge, which should be fun once properly set up!

Everyone here: see https://codegolf.stackexchange.com/questions/187674/print-the-previous-answer-in-reverse-with-a-catch-pt-2

2. 05AB1E
“a = "Hello"““b = "World"“I“c = a + ", " + b + "!"“I“…¢““(c)“«»R

Try it online!

64/57 + 0 = 1.12

SCORE: 1.12

@Downvoter why?

I know this is improper, but would you mind deleting this answer? I want to update my first answer to make it a bit more complex (to avoid answers getting too short too quickly). Sorry about this, let me know if you don't want to.

or maybe edit your answer to print my edited version? Apologies about this.

@GezaKerecsenyi There you go, I still think it will be very hard. Probably a better challenge would be to NOT be able to use the characters from 2 languages ago. But that's a different challenge altogether

I agree with @ExpiredData. That option seems much more reasonable.

Using only the language set from 2 answers ago makes this an almost impossible challenge: How is the 3rd answer supposed to output «,“,…, and ¢ using only abcHelo, Wrd!+"=pint? There's only one mathematical operation available (addition). (I.e. I also agree with Expired Data)

@Draco18s I totally agree, but that's not really my problem

@ExpiredData While true, I was addressing the challenge author.

@Draco18s challenge complete

3 - Python 2
419/64+57 -> SCORE: 63.546875

This is one masterpiece of hackery. Edited to comply with rule 1. chr uses lowercase h, not uppercase. Will edit when I have time to find a substitute.

Update 9/25/2020: Yeah I'm not coming back to this, question is closed anyway.

This is assuming the first answer is Python 3
e=ord
o=e("o")
a=e("a")
n=e("\n")
t=e(")")
b=e("(")
i=e("i")
W=e(" ")
p=o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+o+a+n+n
o=chr
H=o(W+t)
d=o(p+n)
p=o(p)
l=o(a+e(",")+n+n+n)
r=o(i+t+t)
c=o(b+b+b+n+W)
print(o(b+W+n)+r+l+p+")c("+p+p+c+d+p+H+p+""""!" + b + " ," + a = c"""+p+H+p+""""dlroW" = b"""+p+p+""""olleH" = a"""+p)

TIO

1 - Python
a = "Hello"
b = "World"

c = a + ", " + b + "!"

print(c)

Try it online!
SCORE: 57
First answer.


text:
Print the previous answer in reverse - with a catch (pt. 2)
Your challenge is very simple: output the previous answer, in reverse.
However, as with this similarly-titled question, there's a catch: in this case, you cannot use characters from the answer before the last. For example:
Let's say the first answer looks like this:

1 - Python
print('hi!')

And the second answer looks like this: (see 'Chaining' section for more info)

2 - Javascript
console.log(")'!ih'(tnirp")

Now, it would be my job to write the third answer: a program to output the text )"print('hi!')"(gol.elosnoc, without using the characters p, r, i, n, t, (, ', h, i, ! and ). I can choose whatever language I like to complete this task.
Chaining
The first answer can output any text: but it must output something. The second answer should simply output the first answer in reverse, using any characters you like. The further rules about restricted characters, as described above, come into play from the third answer onwards.
Scoring
Your score is \$\frac{l_{n}}{l_{n-1}} - l_{n-2}\$, where \$l_x\$ represents the length of the \$x\$th answer, and \$n\$ is the position your answer is at in the chain. (all lengths are in bytes; if your answer is no. 1 or no. 2 then miss out \$l_{n-1}\$ and/or \$l_{n-2}\$ where necessary.)
Best (lowest) score by August 1st wins.
Formatting
Please format your post like this:
[Answer Number] - [language]

    [code]
    (preferably a TIO link)

SCORE: [Submission Score]

(notes, explanations, whatever you want)

Everything in square brackets is a required argument to fill in; everything in normal brackets is an optional argument; everything not in brackets is there to make the snippet work.
Rules

All characters, etc. are case sensitive.
Preceeding/trailing whitespace is allowed, within reason (I'm looking at you, Whitespace).
Every submission must be a unique language.
You must wait at least 1 hour before submitting a new answer if you have just posted.
You may NOT submit two answers in a row, you must wait for TWO more submissions before posting a new answer.
Of course, standard loopholes are disallowed.
Please make sure to triple check that your answer is valid. This is especially important, because someone may start writing their answer based on yours, so if it's wrong you can't really edit it any more... and the whole chain breaks down. Also, you can't edit answers for continuity purposes.
Standard I/O methods are allowed.

Answer list/used languages

$.ajax({type: "GET",url: "https://api.stackexchange.com/2.2/questions/187674/answers?site=codegolf&filter=withbody&sort=creation&order=asc",success: function(data) {for (var i = 0; i < data.items.length; i++) {var temp = document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];try {temp.innerHTML += " - Score: " +data.items[i].body.split("SCORE")[1].split("\n")[0].match(/(?<!h)[+-]?(\d+(\.\d+)?)/g).slice(-1)[0].trim() +"";} catch (TypeError) {temp.innerHTML += " (no score)";} finally {$('#list').append('
' + temp.innerText || temp.textContent + '');}}}})

   <base href="https://codegolf.stackexchange.com">

Are we not allowed to use the same code points (for non-ASCII aligned code pages) or characters?  What do you mean by "miss out"?

Is it length in bytes or chars, it doesn't clearly state in rules

@ExpiredData It says all lengths are in bytes

@MilkyWay90 by "miss out", I mean assume as if their part of the equation didn't exist. Don't replace them with values, but for instance assume that, since $l_{n−1}$ isn't defined, the fraction cannot be formed.

isn't the score always going to be majorly based on the answer two before yours, no matter the length of your own?

@JoKing Your own length primarily influences the score 2 ahead of you (and vice versa). The immediately adjacent answers are almost irrelevant. [whatever] / [literally irrelevant] - [mega huge] = [ridiculously low score] no matter how you look at it.

Thus, given that there must be at least two answers between each of your answers, you want your code to be as short as possible, to lower the score of the the answer two after yours, which must be a competitor.

7-str
`DwJRK…E•EDo†LZ–w<SK…T>>Q<Sv‡D<J<I<G<>•‡GMMK•<ʇ̃?ό‰—íɁÍ‰ð̈́‰’ñÇùÿȫ<w<…><>_RQRRMKSQKKRKMRRNMLKQKRITK‡w•„‡GPK•<LSRL[J[b•ULXQLNaJ\\Z•NLQ˜“Lj<`D-D-o;

Score: \$\frac{187}{171}-212 = -210.906432748538\$
Note that the code contains many unprintable characters.
The big string between the `s is the reversed code of the Stax answer encoded by adding 26 (I brute-forced this number) to each codepoint. The str code then undoes this by subtracting 26 from the string before outputting it (You can subtract integers from strings, which does math on each codepoint, in this language)
Try it online!

1 - 05AB1E
"Hello, World!"

SCORE: \$\frac{15}{1} - 0 = 15\$
Try it online!

The score for this would be $\frac{15}{1}-0=15$ - @MilkyWay90 see my response to your comment on the question.

Why use 05AB1E in the first answer :( Now we can't use it anymore. PS: Too late now, but you could have removed the trailing ". Trailing ", •, ‘, ’, “, ”, etc. are all implicitly when it's at the end of the program. :)

5. Runic Enchantments
")(esre"1´18k+"er.'"$7´884k$8´216k$7´690k$8´318k$8´220k$3´80k$1´87k$9´5k$7´814k$1´64k$1´61k$8´220k$1´18k$3´91k:$$7´776k$8´220k$8´310k$4´28k$3´04k$2´09k$1´69k$7´693k$1´61k$8´220k$"'tnirp"@

Try it online!
Encodes the Jelly portion as number literals. Its disgusting. Also, answer #7 will have a super low score. Which is also disgusting. Next.
SCORE: 212÷77-25 = -22.246753247

6 - Stax
"P2y~724{@BB0G427>u2;{HA0A2uu892"{16-mj{]m1:/8171234883181179138878E$"$k"]\"ȑåß×xo̪Öo³ȧÓ}oβ%˩ɭ"{133-m{$"-"/"0"*m\9"7$$:k19"]|@2lU*+{+k180]*

Run and debug online
Score: 171 ÷ 212 - 77 = -76.19
My first Stax answer. I’m sure it could be golfed better, but each byte is only worth \$\frac{1}{212}\$ points.

2 - Japt
`"HÁM, Wld!"`w

Try it - Note the unprintable (codepoint 142) between the W and the l.
SCORE: 15÷15-0=1

Everything between the backticks is simply the source of the first solution compressed with Shoco. The backticks decompress it and the w reverses the result.

3 - Jelly
“¡ḍ©ÑİƬ⁶“ṠƇƇv“¡¤Ẇ_»ż“⁾Ḋ‘Ọ

Try it online!
SCORE: 25 ÷ 15 - 15 = -13.33
No unprintable characters. Verification that no characters from 1 used.

@Shaggy Was just about to say that lol

I'd recommend deleting your post while you're fixing the problem and undelete it and edit it once you've fixed it

@MilkyWay90 should be fixed now. Sorry

@NickKennedy Okay, thanks. Now I can gett to work on my answer

@ExpiredData I think it’s the length rather than score, though I did think it was that too at one point!

Time to restart the bruteforcer yet again

4 - Groovy
print'“¡ḍ©ÑİƬ⁶“ṠƇƇv“¡¤Ẇ_»ż“⁾Ḋ‘Ọ'.reverse()

Try it online!
SCORE = 77/25 - 15 = -11.92


text:
How many Jimmys can fit?
In this simple but fun challenge, you were asked to determine if Jimmy would fall of their platform.  Jimmy has three body parts /, o, and \ arranged like this
/o\

Platforms are represented with -.  Jimmy will fall off their platform iff they have two or more body parts that are not directly above a platform.
Some examples:
   /o\
- -------

Jimmy will balance since all their body parts are above a -.
   /o\
    ------   ---

Jimmy will balanced since two body parts are above -s.
 /o\
-- ----  --

Jimmy will balance even though they are split between two platforms
  /o\
   -

Jimmy will not be balanced since two body parts are not above a platform.

Your task is to write a program that takes a platform as a lengthed container containing only -s and  s (e.g. a string) and outputs the number of Jimmys that can be placed on the platform such that none of them will fall and none of them will overlap.  A Jimmy may have one of their body parts to the left of the beginning of the string or the right of the end of the string.
This is code-golf so answers are scored in bytes with fewer bytes being the aim.
Test cases
Inputs
-  -  -

- -
--
-- --
----
- -- --
------- -

Respective outputs
0
0
1
1
2
2
2
3

JavaScript (ES6),  45 41  40 bytes
Saved 4 bytes thanks to @Shaggy
s=>(0+s+0).split(/.--|-.-|--./).length-1

Try it online!

41 bytes

@Shaggy Thanks! I knew something was wrong there, but I had to help my wife on some Super Mario Galaxy level in the meantime... and it was also a problem about broken platforms. :p

the --- wasn't sitting well with me either, until I was working on my port and realised they weren't needed. Think I'll call it a day here, grab a bag of cans and throw on SMG myself - haven't played it in an age.

And now all the other answers are using the same regex.

Python 2, 53 bytes
lambda s:len(re.findall('.--|-.-|--.',`s`))
import re

Try it online!
Based on Arnauld's regex. Greedily searches for all the non-overlapping length-3 substrings with two or more -. A trick is to do `s` to enclose the input string in quotes as padding to leave room for Jimmys to hang off on either end like
/o\/o\
'----'

Python 2, 57 bytes
f=lambda s:'--'in s[:3]*2and-~f(s[3:])or s>''and f(s[1:])

Try it online!
Requires a cheesy I/O format of the input already in quotes. Outputs False for 0.
A recursive function that places each Jimmy on the leftmost position allowed, by either placing Jimmy over the first three characters if they can hold Jimmy, or otherwise deleting the first character. A cute trick is to check if s[:3] contains two or more - by doing '--'in s[:3]*2, which concatenates two copies of s[:3] and checks for two adjacent -.

Japt, 16 bytes
Based on Arnauld's original JS solution. I tried a few different methods to get the necessary padding either side of the input but all came in at the same length - still searching for a shorter way...
ûUÊÄÄ è".--|-."ê

Test it
ûUÊÄÄ è".--|-."ê     :Implicit input of string U
û                    :Centre pad with spaces to length
 UÊ                  :  Length of U
   ÄÄ                :  Add 1, twice
      è              :Count the occurrences of
       ".--|-."ê     :  ".--|-." palindromised, resulting in the RegEx /.--|-.-|--./g

Perl 5 -p, 28 bytes
Uses the same method as @Arnauld's JavaScript.
$_=@a=" $_ "=~/.--|-.-|--./g

Try it online!

Excel, 96 bytes
A1 = platform.
Entered as array Formula Ctrl+Shift+Enter
=SUM(IF(LEN(TRIM(MID(IF(MOD(LEN(A1),3)=1," ","")&A1,3*ROW(INDIRECT("A1:A"&LEN(A1)))-2,3)))>1,1))

05AB1E, 16 bytes
ðì‚ε3ôʒ'-¢2@}g}à

Can definitely be golfed.. Sometimes it's annoying to see all these regex answers in a challenge when using 05AB1E, which is lacking regex of any kind. ;)
Try it online or verify all test cases.
Explanation:
ðì            # Prepend a space before the (implicit) input
  ‚           # Pair it with the unmodified (implicit) input
   ε          # Map both to:
    3ô        #  Split them into parts of size 3
      ʒ       #  Filter these parts by:
       '-¢   '#   Where the amount of "-"
          2@  #   Is larger than or equal to 2
      }g      #  After the filter: take the length to get the amount of items left
   }à         # After the map: get the maximum of the two
              # (which is output implicitly as result)

Ruby, 39 bytes
->s{s.scan(/(^|.)--|-.-|--(.|$)/).size}

Try it online!

38 bytes

Stax, 13 bytes
ƒó±KêyG←à╛Ωô∟

Run and debug it

Java 8, 41 bytes
s->(0+s+10).split(".--|--.|-.-").length-1

Try it online.
Port of @Arnauld's JavaScript answer, except that +0 is +10 to fix test cases like ----. This is necessary because the String#split builtin in Java will remove trailing empty Strings by default. This can be changed by adding an additional parameter to the split builtin (which is 0 by default in the split-builtin with a single String argument). To quote the usage of this additional parameter from the docs:

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array.
If the limit \$n\$ is greater than zero then the pattern will be applied at most \$n-1\$ times, the array's length will be no greater than \$n\$, and the array's last entry will contain all input beyond the last matched delimiter.
If \$n\$ is non-positive then the pattern will be applied as many times as possible and the array can have any length.
If \$n\$ is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded.

Because of this, usually .split("...",-1) is used to retain ALL trailing empty Strings, and I could have used it for this answer as well (Try it online). In this case changing the +0 to +10 saves two bytes over the ,-1, though. :)

Elm 0.19, 108 bytes
import Regex as R
f p=List.length<|R.find(Maybe.withDefault R.never<|R.fromString".--|-.-|--.")(" "++p++" ")

Based on the regex in Arnauld's JavaScript answer. Verify all test cases here.
Alternative solution without regex, significantly longer at 171 bytes:
f p=(String.foldl(\z{x,y,s,c}->let(t,d)=if s<1&&List.length(List.filter((==)'-')[x,y,z])>1 then(2,c+1)else(max 0 s-1,c)in{x=y,y=z,s=t,c=d}){x=' ',y=' ',s=0,c=0}(p++" ")).c

Verify all test cases here.

Jelly, 12 bytes
n⁶,Ż$s€3§Ẓ§Ṁ

Try it online!
Based on @KevinCrujissen’s 05AB1E answer so be sure to upvote him too.

Charcoal, 25 bytes
Ｐθ↖Ｆθ¿›№ＫＭ-¹«⊞υωＭ³→»→⎚ＩＬυ

Try it online! Link is to verbose version of code. Explanation:
Ｐθ↖

Print the platform without moving the cursor, then move the cursor up and left as that is the first potential Jimmy position.
Ｆθ

Look for as many Jimmies as there are platform positions.
¿›№ＫＭ-¹

Check to see whether there is more than one piece of platform at this position.
«⊞υω

If so then note a valid Jimmy position...
Ｍ³→»

... and move three characters to the right so that the Jimmies don't overlap.
→

Otherwise the next potential Jimmy position is one character to the right.
⎚ＩＬυ

Clear the platform and output the count of discovered positions.

PowerShell, 38 bytes
Port of Arnauld's JavaScript answer.
(" $args "-split'.--|-.-|--.').count-1

Try it online!


text:
Write a function
I honestly can't believe this challenge does not already exist.
The challenge
Write a function.
The specifics

Your program must define some sort of callable function. This includes anything commonly known as a function, a lambda function, or a subroutine. All of these types of callables will be referred to as a "function" in this post.

Input to the function is optional and not required.
A return value from the function is also optional and not required but control must return to the calling program.

The function must be assigned to some sort of variable so that it is possible to be accessed at a later time. This includes indirect assignment (in most common languages where declaring a named function automatically adds the name into the current scope) and direct assignment (assigning an anonymous function to a variable directly).
The function does not need to be named.
The function must be created by you - you cannot just assign a default function from the language to a variable.
None of the standard loopholes, please.

This is code-golf, so lowest score in bytes wins.

Comments are not for extended discussion; this conversation has been moved to chat.

I don't get why this was reopened when none of the reasons it was closed in the first place have been addressed, just hidden away by mods in a chat

Also, since when can you vote to reopen your own post??

You need to be a lawyer rather than a programmer to compete in this challenge.

This should definitely not have been reopened in its current state.

x86 / x64 machine code, 1 byte
c3

Assembly:
ret

Try it online! (nasm)
¯\_(ツ)_/¯

But this doesn't give the function a name or store a reference to the function in a variable.

@TannerSwett It can be called by address.

You can add a label in assembly. It does not increase the size of the compiled code, and gives the function a name.

Jelly, 0 bytes

Try it online!
A monadic link that returns its argument. Since it is the first function to appear in the script, it can be called using 1Ŀ.
Thanks to @lirtosiast for pointing out that a 0 byte link/function would work in Jelly.
I.e.

3,4,5 1Ŀ
Try it online!

The 0 byte answer should work.

@KevinCruijssen yes! Good spot

@NickKennedy You can use
...
 to preserve leading/trailing spaces/newlines in code-blocks. I've edited your answer accordingly. :)

@KevinCruijssen thanks!

My knowledge of jelly is pretty thin but don't you need a newline to end the link?  It seems to be used in the example.

@SriotchilismO'Zaic it’s debatable I think - I guess without the newline, the link can only be used to process a command-line argument, and so arguably it’s being used as an anonymous function, but the newline itself isn’t part of the link/function.

@SriotchilismO'Zaic that'd mean that the Python answer (and many other languages where newlines are important) would need to include a trailing newline too, as def f():1 f() doesn't call the function either

@dzaima Hm, yeah good point.  I don't think I am going to comment on all the existing answers though.  I think this probably just points to a lack of clarity in the original question.

@SriotchilismO'Zaic really the need of a trailing newline for functions where it's needed is applicable to any question that allows a function as an answer, it's definitely not a fault of this specific question

Whole challenge is mostly divided into two parts: create a function and provide a way to call it. Some have way to call it without assignment (like in x86/64 assembly answer because of free jumps), few find a way to take advantage of fact that nothing is still an empty function. When we combine those, we get this…

Javascript, 6 bytes
f=_=>0

Includes variable assignment.  Not much to see here.

To make it looking more emoji-like: o=_=>o

Another emoji d=_=>b

@tsh, alas, b is not defined in this case.

What about f={}? One could argue that a(n object used as a) dictionary is a mathematical function from a set of keys to set of values.

@DanielO:  One could certainly argue that.  But in my opinion, one could even more effectively argue that you can't call it, so it's not a function.  In javascript, a function call is unambiguously represented with parentheses.

@DaniilTutubalin But this only matters if you invoke it. And there is no such requirement about the function whether should run without throwing an exception.

Haskell, 3 bytes
o=9

This code defines a polymorphic function called o which takes one type parameter and one typeclass instance parameter. When this function is called, it takes the given typeclass instance, gets its fromInteger member, calls that member with the Integer value for 9, and returns the result.
Granted, what I just described is merely the behavior of the Haskell function 9, and my code merely defines a function called o which is equivalent to 9.
Now the only question is, is the 9 function "created by you," or is it "a default function from the language"?
I think that it is "created by you." My reason for saying this is that if you read the specification for Haskell, you will (I assume) find no mention of a 9 function anywhere. Instead, the specification states that you can create a number literal by stringing together one or more digits. Therefore, by writing a string of digits, I have written a function—even if I just so happen to have only used one digit.

clever, type level functions

Python 3, 9 bytes
def f():1

Try it online!

ZX Spectrum BASIC, 6 bytes
DEF FN f()=PI

Hex dump: CE 66 28 29 3D A7. CE is a 1-byte keyword for DEF FN (including the trailing space), while A7 is a 1-byte keyword for PI. Call using FN f(). Example program:
  10 PRINT FN f(): DEF FN f()=PI

Output:
3.1415927

R, 9 bytes
body(t)=0

Try it online!
I think this complies with the rules. The function t takes no input and outputs 0. This works because there already exists a function called t (the transposition function) and it redefines the body of the function; it would not work with say body(a)=0 (no object called a) or body(F)=0 (F is a logical, not a function). I think it complies because it is still created by me: I am not reusing what the pre-defined function does, simply its name.
I don't think I've ever seen this used by R golfers, but there may be situations where it allows us to save a few bytes on challenges where we need a helper function.
A more standard solution would have been:
R, 13 bytes
f=function()0

Try it online!
Function which takes no input and outputs 0. This is 1 byte shorter than the function which takes no input and outputs nothing, which would be
f=function(){}

If we try to define a function with no body (f=function()), R interprets this as an incomplete command (this might not be true in older versions of R).
As pointed out by OganM, we take this down to 11 bytes with
R, 11 bytes
function()0

Try it online!
which technically complies with the challenge requirement that the function be assigned to some sort of variable, since it is (ephemerally) assigned to .Last.value.

function()0 should work for your second answer since the function need not be named. Neat trick on body<-, I've tried to use body and the like to do some of the weird challenges to mess with the language

@Giuseppe "The function must be assigned to some sort of variable", so I don't think function()0 complies of the rules of this challenge.
I'd be happy to give a bounty to an answer which uses the body()=" trick successfully.

function()0 would be assigned to .Last.value() though that would be pushing it

@OganM Nice point!

pryr::f(x) if we allow pryr.

Perl 6, 5 bytes
$!=!*

Try it online!
Creates a Whatever lambda that returns the boolean not of its parameter, and assigns it to the variable $!.

C (gcc), 5 bytes
Defines a function f that takes no arguments and technically returns an undefined integer value.
f(){}

Try it online!

"takes no arguments" — lies badly. That's one of common misunderstandings about C: empty argument list means undefined amount of undefined type arguments without portable way to access them. As a sidenote, this is also C/C++ incompatibility.

Whitespace, 7 bytes

Creates a subroutine that returns control to the caller.
Explained in context:
[N
S S N
_Create_Label][N
T   N
_Return]

Try it online!

[Wolfram Language (Mathematica)], 1 byte
This one is slightly questionable:
f

Defines f, which can be "called" e.g. by f[], which "returns" the expression f[]

Hey, it can be called, and the return value is optional. This counts.

If this solution is acceptable, then the zero-byte answer is just as good: your "definition" of f doesn't do anything (apart from remembering "I've seen f") and can be left out. You can call f[] nonetheless, still returning unevaluated f[]. However, in any case you're mostly playing tricks with the pattern-replacer and not instructing to evaluate a function.

@Roman I've considered adding the zero byte version, but in the end I felt like that's even more questionable: this actually creates the symbol Global`f, while the empty version doesn't do that (you could argue that Null is assigned to %1, but Null is a built-in "function"). But as I've noted in the answer, whether the one byte solution is valid is also not entirely clear...

Forth (gforth), 5 bytes
This is a function named f that does nothing.
: f ;

Try it Online
In the TIO code, I added a footer of see f, which prints the definition of the function.

Lua, 8 bytes
f=load''

Try it online!
Defines a (global) function f.
This uses Lua load function to compile given string which happens to be empty in our case (empty code is valid code) into function which does exactly what we wrote in its body: nothing.
For ones wondering, standard solution would be
function f()end

but this is longer (15 bytes).

POSIX sh, 6 bytes
s()(1)

Using curly braces requires one more character.

Java, 10 Bytes
this should match the rules of the challenge
void f(){}

I'm pretty sure f=a->a; is valid as well. :)

@Kevin Cruijssen I am no Java expert and I never used the Java array notation. How could I make your solution getting compiled? I initially "tested" my method in this TIO and then appended your approach there. Now, the compiler expects an identifier. Any explanation or wrong usage by me?

It's a Java 8+ lambda function. So either of these two would work in this case. Here a more in depth explanation of Java 8+ lambdas in case you aren't familiar with them yet.

Perl 5, 7 bytes
sub f{}

Try it online!

Kotlin, 8 bytes
val f={}
An empty function stored in a variable f.
Call it using f() or f.invoke().

shortC, 1 byte
A

Try it online!
Transpiles into this C:
 int main(int argc, char **argv){;}

Pascal, 22 bytes
procedure A;begin end;

C (gcc), 14 13 bytes
(*f)()=L"Ã";

Try it online!
This defines a function f returning int and accepting an unspecified number (and type) of parameters, the machine code of which is contained within the string literal. The unicode character Ã (stored in memory as 0xc3 0x00 0x00 0x00 on a little endian machine) corresponds to the x86 ret instruction that returns from the function. Non x86 architectures may require different opcode(s) to return.
gcc may require the -zexecstack flag to avoid a segfault.

Tcl, 6 5 11 bytes
set f {_ ;}

Try it online!
Including the assignment to the variable f as part of the bytecount to comply with rules.  With this change, the more conventional definition below ties the one above for bytecount:
proc f _ {}

Is this a named function? The function must be assigned to some sort of variable so that it is possible to be accessed at a later time.

@mbomb007  I see your point, and fixed it accordingly

Ruby, 6 bytes
Proc called f which accepts no argument and returns nil.
f=->{}

Try it online!

Haskell, 5 bytes
f x=0

Try it online!

XSLT, 134 bytes
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template name="a"></xsl:template></xsl:stylesheet>

A template is the closest thing this language has to a function. It can definitely be called; it takes zero arguments and "returns" the empty string.

F# (.NET Core), 9 bytes
let f a=a

Try it online!

Python 3, 10 bytes
f=lambda:0

Try it online!

Can't you just do def f():0 to save a byte?

@EdgyNerd Dat answered before me with that code, and i don't want to copy it

Oh ok, never mind then

Rust, 6 characters
f=||0;

A closure (also called lambda) that takes no parameters and always returns 0.
(As far as I understand the challenge, only the assignment has to be included, the variable declaration not.)
Try it online!

AppleScript, 10
on a()
end

Explained, compiled, and including invocation:
on a()    -- declare event handler "a"
end a     -- end declaration

-- invoke it:
a()

Japt, 2 bytes
_

Called as $U ($.
_ can be replaced with @, Ï, or È.
Try it

SmileBASIC (>=3), 9 bytes
DEF A
END

Function is called by A.

Alternatively DEF A*END in SB4

Wolfram Language (Mathematica), 2 bytes
#&

Try it online!
Unfortunately, just & does not work (an anonymous function that does nothing).

You need to save the function to a variable according to the rules, e.g. f=#&

@LukasLang it's automatically saved to %1 so there's no need for an explicit assignment to a variable like f.

Good point, that should be enough to fulfil the rules

Octave, 4 bytes
xkcd Random Number Generator
@()4

Assigns an anonymous function to the default return variable ans. Call using ans(<parameters>). Any number of input parameters are allowed.
Code length is a random number of bytes.
Sample run on ideone.

Runic Enchantments, 1 byte
B
>00B$',$$;

Try it online!
The second line is in the footer on TIO as all it does is initialize the program and invoke the function, and print the return values thereof (that being a pointer to the next instruction after the return statement--utilizing vs. discarding these values normally distinguishes a function call with a return), and as such should not be included in the bytecount any more than static void main(int[] args) { f(); } would be.
Similarly it shows the function "being assigned to a variable" (that being its literal coordinates, 0,0) and "invoked later" at position 3,1. For example, this program invokes the same function after performing some other operations and does so at a different point in the code. Note that the IP does not change direction automatically and may result in unexpected behavior, so functions typically start with a directional command, however in golfing it is insured that the IP is already going in the desired direction, resulting in not needing the extra byte(s).
Abusing language features, 0 bytes

/   B̭
 >00/$',$$;
Try it online!
The first line (blank) is the 0-byte function. The second acts as function call and return. The third line initializes the program and produces output.
I definitely don't think that this should count, but thought I'd at least include it after I realized that I could arrange things this way. If bytes were to be counted from B call to B call in order of program flow, the function contains 8 bytes (four spaces, one /, one B, and two bytes for the ̭ directional modifier).

I was indeed wondering if there were any other normally verbose language (I posted LUA) that might have something special in place.

@ouflak Fair, but doubtful. I'm not even sure I can even really count my 0 byter, as it takes advantage of a 2D language feature and TIO's counting metrics to cheat.

dc, 2
[]

Try it online!
This pushes a dc macro to the stack.  I'm not sure if this is satisfies "The function must be assigned to some sort of variable" or not.  If not, then it can be stored to a variable for 2 extra bytes:
dc, 4
[]sf

Try it online!

Binary lambda calculus, 1 byte
0100_0010

In lambda calculus: (λf. _)(λx. x)
The underscore denotes where the rest of the program should go.
The function can be accessed through its De Bruijn index.

I like this, BLC is underrated

Attache -R, 2 bytes
{}

Try it online!
An empty lambda. This approach takes advantage of the -R flag, which automatically saves the results of the topmost expression as _1 (also accessible through _). It can be used later, but only by the next expression which does not create a topmost expression. Usually, the next line.
Attache, 5 bytes
f:={}

Try it online!
A more conventional approach. Saves an empty lambda to the variable f.
Attache, 6 bytes
f[]:=0

Try it online!
Another conventional approach. Defines a named function f with no arguments, returning 0.

C#, 10 Bytes
Same as Java.
void f(){}

Just like the Java answer, I'm pretty sure f=a->a; is allowed.

Commodore 64 Basic, 13 bytes
1DEFFNI(X)=X

The identity function.  This, or any other function with a 1-byte body, is the shortest possible function in C64 Basic.
(Oddly, the empty function is considered a valid function by the C64 interpreter.  But since actually calling it generates a runtime syntax error, it fails the "control must return" criterion.)

Should also work on all variants of Commodore BASIC from BASIC 2 through to BASIC 7

Swift, 8 bytes
let f={}

Stores in f a void function with no parameters.

Inform 7, 10 bytes
To x:stop.

This defines a "phrase" (the simplest form of callable function), which does nothing and returns. It can then be called by name:
When play begins, x.

Inform 6, 5 bytes
[f;];

The syntax for defining a routine in Inform 6 looks something like this:
[ name arg1 arg2 ;
    contents;
    return;
];

So [f;]; defines a routine named f which takes no arguments and does nothing.

Zozotez: 8
(:'q(\))
;; test
(q) ; ==> NIL

Explanation:

: is set
'q is the quoted symbol (the binding) q
\ is lambda so (\) is short for (\ () ())

Common Lisp: 11
(defun q())
;; test
(q) ; ==> NIL

R5RS/R6RS/R7RS Scheme: 12
(define(q)1)
;; test
(q) ; ==> 1

Clojure, 10 bytes
Returns nil.
(defn f[])

CJam, 4 bytes
{}:F

Call it with F.
If just leaving a function on the stack is enough, then we can remove 2 bytes:
{}

Lua, 15 bytes
s=function()end

Try it online!

C++14, 12 bytes
Empty lambda with no params
auto f=[]{};

Gema, 4 characters
f:=0

Actually a domain, which is a bit like namespace, but in Gema is the way to define both new pattern arguments and new functions.
(I guess the function's result could be nothing, but on f:= the interpreter segfaults. ☹)
Try it online!

jq, 8 characters
def f:0;

A function that takes no parameters and always returns 0.
Try it online!

R + dplyr, 20 bytes
library(dplyr)
.%>%.

Try it at RDRR!
Returns a functional sequence, the identity function.
Much longer than the other R answer but interesting in its own right.

Pyret, 7 bytes
a=_ + 0

Returns exactly what is passed to it. Underscore paired with an operand implicitly makes a function.

PowerShell, 0 bytes

Try it online!
You can save this code as a file with .ps1 extension (for example, f.ps1) and call it .\f.ps1. You can directly call this function from another code as scriptblock &{}. The function is inside the brackets.

Clever. Wish I'd spotted this one myself as I rather like to fiddle around PowerShell.

REXX, 0 bytes
A REXX program may call another REXX program as an external function. Given an empty file as above, saved as f.rexx, you may call it from another program as:
call f

Or, if you're unconcerned by the difference between proper functions and subroutines, call it as:
f()

REXX, 8 bytes
f:return

This is a minimal procedure when called from within the same program. Call using call f or f() if you're not concerned about the philosophical difference between functions and procedures.

Commodore C64 BASIC, 30 BASIC bytes (tokens) used.
 0pO785,210:pO786,255:?usr(0)

This sets the USR BASIC memory pointer to 0xffd2 in the Kernal, which outputs a character on the current device (device 3 being the screen, set to device 4 or 5 and the output is to a printer, and 8 - 15 will be a disk drive, 1 is for tape).
You may therefore write your own machine code function that returns to BASIC if you put the memory location of your routine as above at location 785 (0x0311) as low-byte/high-byte. This must always be 16 bits.

Commodore 64 Basic, 9 bytes
You call the subroutine by GOSUB "\line number" and returns to the caller by RETURN. The function can be accessed anytime by calling the same line number, but the control should always return.
0reT   //Program continues after last Gosub executed
8goS0  //Call subroutine at line number 0

To execute this smallest program type: RUN8.
This program use tokens similarly to Shaun's answer.
Some facts of this program:

There is no input to the actual function, but the function can access global variables.
There is no return value from the function.
The function has no name.
The function is assigned a 16-bit variable that represents the basic line number (of low and high byte order).

This is the smallest I can think of, but of course expanding the number of digits in the line numbers will acually increase the codesize of the basic program.
For an demonstration with text-output, run this program by typing RUN8:
0 PRINT "INSIDE SUBROUTINE" : RETURN
8 PRINT "CALLING SUBROUTINE" : GOSUB 0
10 PRINT "RETURNED FROM SUBROUTINE"

This also works: 0 return 1 gosub myfunction run with go to 1 (go to and goto in Commodore BASIC are equivalent) - or to save bytes, try: 0reT 1goS again execute with go to 1 - will not with in C128 BASIC but will on the C64. For testing change line zero to 0?"myfunction":reT

@ShaunBebbers So I can shave off one byte to my example. Though, would be nice to have several functions than just one, even though the rules say "Write a function".

To summarise, on the C64/VIC-20 if you go to 0 you can simply go to (or goto if you like) as the interpreter will assume zero if no number is entered after the statement. Same principle applies with gosub and run

yes, it will save one PETSCII character if that's what you are counting. If you want to know how many bytes used by the interpreter, use the fre(0) function

No, if I counted the interpreter I could write this in machine code or 6510 asm. I count each petscii char (in basic) as one byte instead. My entry is a basic code program.

Not that this is important (not to me anyway) but according to fre(0) 0reT 1goS uses 14 bytes in all.

33, 2 bytes
{}

The name of a function is whatever is in the destination string when the function is defined. Since the string registers are initialised empty when the program starts, this is valid and callable.

GolfScript, 5 bytes
{}: ;

This assigns a no-op to a space. In order to call the function, type a space.

I don't think the second example counts because it seems like more of an IIFE - can you access that function to call anywhere in memory, or is it lost after it gets immediately called?

Keg, 4 bytes
@a|@

To call the function:
@a@

This is unimplemented, but it is in the documentation.

Pip, 4 bytes
a:{}

Try it online!
Pip, 0 bytes?
I don't know if this counts but the empty program in Pip is a function. It can be called by (f). If not then the 1 byte program a should count

Pari/GP, 3 bytes
x->

Try it online!

Agda, 22 chars
Surprisingily difficult because of the required type signature and the lack of a preimported anything.
f : Set → _
f x = Set

asm2bf, 9 bytes
lbl 1
ret

It builds to following brainfuck code (omitting boilerplate):
]>+<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-
]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>><<<<<<<<<[-]>[-]>>>>>>>>>>>>>>>[-
]>[>>]<<->[<<<[<<]>+>[>>]>-]<<<[<<]>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<
[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]

Zsh, 3 bytes
Anonymous function... Try it online!
()x


text:
Can the cursor reach the bottom?
In a matrix of characters, a cursor is a movable position between two adjacent characters, before the first character or after the last character in a line, like that "I"-shaped indicator which moves while you type.
In this challenge, a cursor position is considered valid if at least one of its two sides touches a space. The cursor travels through valid positions in a matrix, by moving up, down, left or right by one position each time. It could also move left or right though the line separator, to the end of the previous line, or the beginning of the next line respectively.
Given a character matrix as input, and a cursor initially at the top left corner, your task is to determine whether it can reach the bottom line.
This is a code-golf and decision-problem problem; the rules of this question is the same as what these two tags specified.
Rules

You can assume that the input consists only of .,  , and newlines. (Only these three characters and no more characters; otherwise its behavior is undefined.)
You may require there must or must not be a trailing newline in the input, if you want to.
Your code should output either a truthy value (if the condition is true), or a falsy value (if the condition is false).

Examples
Example input(where ░ is the space character):
░.....░
░......
.░.░.░.
.░░░░░░
......░

The cursor can reach the bottom in this case. This process of moving the cursor will work: down, right(touches spaces on the left), down(touches spaces on the right), down, right(touches spaces on both sides) 6 times, and down(touching spaces on the left).
This will also work(░ still represent spaces):
░░
.░
.░

The cursor starts at the up-left corner. After moving right two times, it can move down twice, which touches the bottom of the lines.
This example will not work(░ represent spaces again):
░...
...░

The cursor cannot move down, as there is no sufficient whitespace to be touched. There are only newline characters on the right of the input, and there are no newline characters on the left(otherwise a line would have spanned two lines.)
The cursor can also move up and left, in order to solve a maze-like input as in this one:
░....
░░░░.
...░.
.░░░.
░....
░░░░░

In this case, the cursor has to move left in order to get through spaces and get to the bottom line.
Here is another important test case: the cursor can move left or right to another line.
░░░░
...░
░...

In this case, the cursor can reach the last line, as the cursor can move left or right in order to get to the next line. Moving the cursor down is blocked on the right position of row 2, column 4; however, the cursor can still get to the last line if it moves right (touching spaces).
This is a fairly interesting test input:
░░..░
░...░
....░

In this case, the cursor can reach the last line, by moving down and left to the end of the first line, then down twice to reach the end of the bottom line.

Can we only go down and towards the right as the test cases seem to reflect? Or is going back up, or towards the left possible as well in finding our path? But in general the challenge is to determine if a path from top to bottom is possible, pretending the newlines are an additional space at the right-hand side?

Ahh, now I finally understand it! My first comment was incorrect. This isn't a path-finding with the new-line on the right active as additional cell. It's path-finding while going over the borders of the matrix instead of inside the character-cells themselves. So in the first test case, this would be the path. Now it makes sense, including how the newline works. Should have paid closer attention to the word 'cursor'..

Maybe it should be clearer somehow that we travel over the border of the matrices (like a cursor). Based on the downvotes and close-votes of others I can imagine I'm not the only one who was confused by the wording of the example and test cases.

In your latest edit, does it mean there must not be a trailing newline on the last line in your original spec? If yes, I'd suggest changing it as it appears too random, but if you insist, please edit that into the specification, not only as an example.

I might have mis-understood your specification "it cannot move left or right through a line separator to another line". Can you explain it? (I thought you meant that the cursor cannot go to the next line via moving right on the end of a line.) If I did, I will delete that test input.

Jelly, 47 43 bytes
p®§Qæ%L}>Ƈ0ịƇ
=⁶oŻ$€µZL;1;N$©ṛF1çƬFṀ’:®Ḣ‘=L

Try it online!
A full program that takes a list of strings as its argument and returns 1 if the bottom line is reachable and 0 if not.
Explanation
Helper link
Test moves up, down left and right and extend reachable position list. Left argument: most recently added reachable position list; right argument: boolean list of whether each possible position is valid
 p®            | Cartesian product with each of the values stored in the register (the width of the position list, 1 and the negation of each)
   §           | Sum each of these
    F          | Flatten
     Q         | Uniquify
      æ%L}     | Symmetric mod using the length of the valid position list: this will mean any positions that move off the top or bottom will be negative
          >Ƈ0  | Filter out those reachable positions which are negative
            ịƇ | Filter out those which are invalid

Main link
Takes a single argument, a list of Jelly strings representing the grid
=⁶                             | Check of equal to space
   oŻ$€                        | Logical or each row with itself prepended with zero; this yields rows 1 longer, and will indicate whether each cursor position is valid
       µ                       | Start a new monadic chain
        ZL                     | Zip and get the length (will be the length of each row)
          ;1                   | Concatenate 1
            ;N$©               | Concatenate the negations and store in the register (i.e. width, 1, -width, -1)
                ṛF             | Replace with the flattened grid of position validity
                  1çƬ          | Call the helper link, starting with 1 as left argument and using the flattened position validities as right. Repeat until unchanged. Return all collected values.
                     F         | Flatten, getting all reachable positions (may include duplicates)
                      Ṁ        | Maximum position reached
                       ’       | Decrease by 1 (because of 1-indexing)
                        :®     | Integer divide by the register
                          Ḣ    | Head (will effectively be max position integer divided by width)
                           ‘   | Increase by 1
                            =L | Check if equal to length (i.e. height) of position grid

I'm intrigued. Care to explain?

@Adám added. Thanks

APL (Dyalog Unicode), 60 bytesSBCS
Full program. Prompts for character matrix from stdin. Prints 1 or 0 to stdout. Requires zero-indexing (⎕IO←0) which is default on many systems.
P←{' '0∊⍨s←(×⍨≢⍺)⊃,⍵:1∊⍵⋄s}
1∊⊢⌿{P⌺3 3⊢(⍴⍵)⍴1@0P⌺3,⍵}⍣≡3/3⌿⎕

Try it online! (space characters replaced by ░ for clarity)
The method here is basically to seed fill from the top left corner, but alternating between 1D and 2D seed fill to account for line wrapping and vertical/diagonal motion. Diagonal motion is simple horizontal motion followed by vertical motion, since the cursor sits in between adjacent characters.
The first line defines a helper function P(rocess) which will be called on each neighbourhood.
P←{…} "dfn"; ⍵ is the neighborhood, ⍺ is the number of padded elements for each dimension:
 ,⍵ ravel (flatten) the neighbourhood into a list
 (…)⊃ pick the following element from that:
  ⍺ the paddings per dimension (so a 1 or 2 element list, depending on ⍵ being 1D or 2D)
  ≢ the tally of that (1 or 2)
  ×⍨ the square of that (lit. multiplication selfie; 1 or 4)
 s← assign to s(elf; i.e. the centre of the neighbourhood)
' '0∊⍨ is that a member of [" ",0]?
 : if so:
  1∊⍵ return whether the neighbourhood has a one
 ⋄ else:
  s return s(elf unmodified, i.e. leave as-is for now)
The second line is the main part of the program:
⎕ prompt for evaluated input via the console (stdin)
3⌿ triplicate each row (ensures we have at least 3 — makes no difference to connectivity)
3/ triplicate each column (ensures we have at least 3 — makes no difference to connectivity)
{…}⍣≡ apply this function repeatedly until two successive results are identical (i.e. until stable):
 ,⍵ ravel (flatten) the matrix into a list
 P⌺3 apply P to each neighbourhood of 3 elements
 1@0 replace the current value at position 0 with a 1 (this seeds the top left corner)
 (…)⍴ reshape that into the following shape:
  ⍴⍵ the original shape of the matrix
⊢⌿ get the bottom row (lit. vertical right-reduction)
1∊ is there any 1 there?


text:
Point-free madness
This challenge is about Haskell point-free style polynomial functions.
Although you don't need to know Haskell language to do this challenge, Haskellers might have an advantage here.
Point-free means roughly that variables(points) are not named and the function is created from compositions of others functions.
For example, in Haskell, the function f : x->x+1 can be defined by:
f x = x+1 which uses the variable x and is not point-free. But it can be simplified to its point-free version: f=(+1). Likewise, you have f x=x^k -> f=(^k), and f x=x*k -> f=(*k), f x y=x*y -> f=(*)
More complex functions can be constructed using the Haskell's function composition operator (.):
f x = x->2*x+1 is converted to f = (+1).(*2): Multiply by 2 then add 1.
In this challenge you will have to create a point-free style Haskell code generator.
This generator will take a polynomial function of multiple variables as input and output corresponding code in Haskell language and in point-free style.
This is way harder than the previous simple functions, so if you don't know Haskell at all, or if you are not comfortable with operators (.), (>>=), (<*>) on functions, You should follow the Construction Process which is detailled bellow or start directly from its Python Implementation.
Example
Say you want to write the polynomial function x, y -> x²+xy+1 point-free.
Your program might output the folowing code:
((<*>).(.)((<*>).(.)(+)))                           -- sum 2 functions of 2 variables
    (
        ((<*>).(.)((<*>).(.)(+)))                   -- sum 2 functions of 2 variables
            (
                (
                    ((.)((.(^0)).(*)))              -- g x y = y^0 * f x   => g x y = x^2
                    (((.(^2)).(*))(1))              -- f x = 1*x^2
                )
            )
            (
                ((.)((.(^1)).(*)))                  -- g x y = y^1 * f x   => g x y = x*y
                (((.(^1)).(*))(1))                  -- f x = 1*x^1
            )
    )
    (
        ((.)((.(^0)).(*)))                          -- g x y = y^0 * f x   => g x y=1
        (((.(^0)).(*))(1))                          -- f x = 1*x^0
    )

This is a really ugly yet valid Haskell code, and this is really not the shortest one ((.).(.)(+1).(*)<*>(+) works as well), but we will see how it can be generalized to any multivariable polynomial.
Construction Process:
One possible algorithm is to first write each monomial function in point-free style (step 1), then create operators to add functions two at a time (step 2), and apply this to the list of monomials, writing f+g+h as (f+(g+h)) (step 3).

Write each monomial, taking each of the factors successively. Example: 11*a^12*b^13*c^14.

Start with (11), a 0-argument function.
Take the previous function f0 and write ((.(^12)).(*))(f0); this is a 1-argument function a->11*a^12
Take the previous function f1 and write ((.)((.(^13)).(*)))(f1); this is a 2-argument function a->b->11*a^12*b^13.
Finally, take the previous function f2 and write ((.)((.)((.(^14)).(*))))(f2). Thus a->b->c->11*a^12*b^13*c^14 is converted to point-free style as ((.)((.)((.(^14)).(*))))(((.)((.(^13)).(*)))(((.(^12)).(*))(11))).
In general, continue transforming f to something of the form ((.) ((.) ((.) ...     ((.(^k)).(*))   )))  (f) until your monomial is built and takes the desired number of arguments.
Warning: If using this construction algorithm, each monomial must take the same number of arguments. Add some ^0 for missing variables (a^2*c^3 -> a^2*b^0*c^3)
You can test your monomial generator here with this example and the next iteration: Try it online!

Create the operator \$O_n\$ that adds two functions of \$n\$ arguments:

\$O_0\$ is (+)
For \$n\geq0\$, \$O_{n+1}\$ can be constructed recursively as ((<*>).(.)( O_n ))
E.g. ((<*>).(.)(((<*>).(.)(+)))) adds two 2-argument functions.

Chain the addition: The operator from step 2 only adds two monomials, so we must manually fold addition. For example, for monomials f, g, h, write f+g+h => O_n(f)( O_n(g)( h ) ) replacing f, g, and h with their point-free equivalents from step 1, and \$O_n\$ by the correct operator from step 2 depending on the number of variables.

Implementation in Python
This is an ungolfed implementation in Python 3 which reads polynomials as list of monomials where monomial is a list of integers:
def Monomial(nVar,monoList):
    if nVar==0:
        return "({})".format(monoList[0])
    else:
        left = "((.(^{})).(*))"
        mono = "({})".format(monoList[0])
        for i in range (0,nVar):
            p = monoList[i+1] if i+1<len(monoList) else 0
            mono = left.format(p) + "(" + mono + ")"
            left = "((.)" + left + ")"
        return mono

def Plus(nVar):
    if nVar==0:
        return "(+)"
    else:
        return "((<*>).(.)(" + Plus(nVar-1) + "))"

def PointFree(l):
    nVar = 0
    for monoList in l:
        if nVar<len(monoList)-1: nVar = len(monoList)-1

    pointfree = Monomial(nVar,l[0])

    plusTxt = Plus(nVar)

    for monoList in l[1:]:
        pointfree = plusTxt + "(" + Monomial(nVar,monoList) + ")(" + pointfree + ")"

    return pointfree

Input
The input is the polynomial function to be converted.
The input format shall consist of a list of Integers in any format you want.
For example, you might define the polynomial 5*a^5+2*a*b^3+8 as the list [[5,5,0],[2,1,3],[8]]
Output code
The output is the Haskell code for that polynomial as a function of n Integers,
written in point-free style with only numeric literals and base functions(no Import).
Of course, the above process and implementation comply to these rules.
For Haskell programmers, this means no list comprehension, no lambdas and only Prelude functions(no import, language extensions..):
(+) (-) (*) (^) (.) (<*>) (>>=) flip sum zip uncurry curry ($) ...
Test cases
Your program should work for all valid inputs, but will be scored on on these five polynomials:
f1 a b c d = 5*a^4*b^3*c^2 + a^2*b^3*c^4*d^5
f2 a b c   = -5*a^5*c^8 + 3*b^3*c^4 + 8
f3 a b     = 5*a^5+3*b^3+8
f4 a       = a^3+a^2+a+1
f5         = 1+2-3

Tests cases with the Python code given above:Try it online!
Once you have run your program on these samples, copy/paste your output code into the following program (in the "Code" section) and run it in order to check your outputs:
Try it online!
If your functions are correct, it will output:
f1 : +++ OK, passed 100 tests.
f2 : +++ OK, passed 100 tests.
f3 : +++ OK, passed 100 tests.
f4 : +++ OK, passed 100 tests.
f5 : +++ OK, passed 100 tests.

Scoring
Code length + (sum of the test cases output length)/8.
-300 if your program consist in a point-free style Haskell function (with the same rules as for output).
I'll give a Bounty of 250 points if you beat my score of 73.125 (272 + 809/8 - 300).
The Python solution given above is 797 bytes long, and outputs functions of length: 245, 282, 180, 132, and 24 so the score would be 797 + (245+282+180+132+24)/8 = 904.875.
The smallest score wins!!

Comments are not for extended discussion; this conversation has been moved to chat.

Haskell, 278+448/8-300=34
(foldr.pure.pure.((++).(foldr(('(':).(++".)")<$id).((++).("(sum.zipWith(*)"++).show.map head<*>(".flip(map.(product.).zipWith(^))"++).(++")").show.map tail)<*>tail.head)<*>(++" pure)").("("++).foldr(("(("++).(++".flip(:)).)")<$id)"id".drop 2.head))<*>show.sum.concat<*>tail.head

Saved 14 bytes by having a closer look at parens as suggested by @Damien, then saved 8 more using another hint from them.
Since input is "list of Integers in any format you want", I take list of lists with first elements the multiplicative constants of the summands, and the rest all the corresponding exponents in reverse order. So the example polynomial 5*a^5+2*a*b^3+8 is given by  [[5,0,5],[2,3,1],[8,0,0]]. (Didn't try [(5,[0,5]),(2,[3,1]),(8,[0,0])] - would that be allowed?)
The result for this example polynomial is this:
(((sum.zipWith(*)[5,2,8].flip(map.(product.).zipWith(^))[[0,5],[3,1],[0,0]]).).)(((id.flip(:)).) pure)

See the results for the test cases or try your own polynomial at the TIO-Link:
Try it online!
Check the results for the test cases here:
Check it online! (testing code from OP with my results)

Yes, it's allowed. Great job!

You can still save many bytes removing parenthesis

@Damien Yes, quite a lot of them indeed, still not completely sure I got them all.

I found the same, you can also replace <$> by . and pure$ by <$id

05AB1E, score: 167 (111 bytes + 448/8)
¬g©i˜Oëøć',ý’.Œ¬With(’DŠ’(¬€ÿ*)[ÿ].ÒÀ(‚é.(‚ª.)ÿ^))’sø',ý€…[ÿ]',ý…[ÿ]s…ÿÿ)®G"(ÿ.)"}„id®ÍF’((ÿ.ÒÀ(:)).)’}s“ÿ(ÿ©¬)

Since I don't know Haskell, I figured I'd just port the output of @ChristianSievers' Haskell answer, so make sure to upvote him!!
Input is taken in a similar matter as well (first being the multiplicative constant, and after that the exponents in reverse order). So for example: test case \$5a^4b^3c^2+a^2b^3c^4d^5\$ is given as input-list [[5,0,2,3,4],[1,5,4,3,2]].
Try it online or verify all test cases.
Verify the outputs with OP's validator.
Explanation:
¬                       # Get the first inner list in the (implicit) input-list
 g                      # Get the length of that list
  ©                     # And store it in variable ® (without popping)
i                       # If that length is 1:
 ˜O                     #  Take the flattened sum of the input-list
ë                       # Else:
 ø                      #  Zip/transpose the input-list; swapping rows/columns
  ć                     #  Extract head; pop and push head and remainder
   ',ý                 '#  Join this first list by ","
      ’.Œ¬With(’        #  Push dictionary String ".zipWith("
                D       #  Duplicate it
                 Š      #  Triple swap the items on the stack (a,b,c → c,a,b)
   ’(¬€ÿ*)[ÿ].ÒÀ(‚é.(‚ª.)ÿ^))’
                        #  Push dictionary string "(sumÿ*)[ÿ].flip(map.(product.)ÿ^))",
                        #  where the three ÿ are filled with the values on the stack
   s                    #  Swap to take the remainder again
    ø                   #  Zip/transpose it back
     ',ý               '#  Join each inner-most list by ","
        €…[ÿ]           #  Surround each inner string in []-blocks
             ',ý       '#  Join those by "," again
                …[ÿ]    #  And surround the entire thing by []-blocks again
    s                   #  Swap the two strings on the stack
     …ÿÿ)               #  And fill them in into the string "ÿÿ)"
 ®G      }              #  Now loop ®-1 amount of times:
   "(ÿ.)"               #   And fill in the top string on the stack into string "(ÿ.)"
 „id                    #  Then push string "id"
    ®ÍF              }  #  Loop ®-2 amount of times:
       ’((ÿ.ÒÀ(:)).)’   #   And fill the top string of the stack into dictionary
                        #   string "((ÿ.flip(:)).)"
 s                      #  Swap the two strings of the stack again
  “ÿ(ÿ©¬)               #  And fill them into the dictionary string "ÿ( pure)"
                        # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why:

’.Œ¬With(’ is ".zipWith("
’(¬€ÿ*)[ÿ].ÒÀ(‚é.(‚ª.)ÿ^))’ is "(sumÿ*)[ÿ].flip(map.(product.)ÿ^))"
’((ÿ.ÒÀ(:)).)’ is "((ÿ.flip(:)).)"
“ÿ(ÿ©¬) is "ÿ( pure)"

Unfortunately ÿ doesn't work for inner items in a list and requires an explicit €, otherwise ',ý€…[ÿ]',ý…[ÿ] could have been 2F',ý…[ÿ]} instead.