text:
Decode the Dreaded Alphabet Cypher™
This challenge is inspired by one of my other challenges: Pointlessly make your way down the alphabet
That challenge asked you to take a string of text, and for each letter produce a sequence of letters moving down the alphabet to 'a'.
For this challenge I'd like to decode the output of that challenge (minus the line breaks), to find a human-readable string from a much longer human readable string.

Here is some text which has been encoded using the Dreaded Alphabet Cypher™
hgfedcbaedcbalkjihgfedcbalkjihgfedcbaonmlkjihgfedcba wvutsrqponmlkjihgfedcbaonmlkjihgfedcbarqponmlkjihgfedcbalkjihgfedcbadcba
It consists of descending alphabetical sequences, ending in an 'a'. The first character in each of these sequences is a letter in the decoded text. (A space is still a space).
The challenge

Write code to convert a Dreaded Alphabet Cypher™ encoded string into a decoded, human-readable string.
No need to validate if it is a Dreaded Alphabet Cypher™ string, I'm not interested in how it handles invalid input.
Use any language you please.
Please include a link to an online iterpreter.
The input will only consist of lower-case letters and spaces. No upper cases, punctuation etc.
Code golf, try to write short code, standard loopholes etc.

Test Cases
Input:
hgfedcbaedcbalkjihgfedcbalkjihgfedcbaonmlkjihgfedcba wvutsrqponmlkjihgfedcbaonmlkjihgfedcbarqponmlkjihgfedcbalkjihgfedcbadcba

Output:
hello world

Input:
abacbadcbaedcbafedcbagfedcbahgfedcbaihgfedcbajihgfedcbakjihgfedcbalkjihgfedcbamlkjihgfedcbanmlkjihgfedcbaonmlkjihgfedcbaponmlkjihgfedcbaqponmlkjihgfedcbarqponmlkjihgfedcbasrqponmlkjihgfedcbatsrqponmlkjihgfedcbautsrqponmlkjihgfedcbavutsrqponmlkjihgfedcbawvutsrqponmlkjihgfedcbaxwvutsrqponmlkjihgfedcbayxwvutsrqponmlkjihgfedcbazyxwvutsrqponmlkjihgfedcba

Output:
abcdefghijklmnopqrstuvwxyz

(beware the multiple a's)
Input:
aarqponmlkjihgfedcbaonmlkjihgfedcbanmlkjihgfedcba a aarqponmlkjihgfedcbaonmlkjihgfedcbanmlkjihgfedcbasrqponmlkjihgfedcbaonmlkjihgfedcbanmlkjihgfedcba hgfedcbaasrqponmlkjihgfedcba anmlkjihgfedcba aarqponmlkjihgfedcbadcbavutsrqponmlkjihgfedcbaarqponmlkjihgfedcbakjihgfedcba

Output:
aaron a aaronson has an aardvark

Input:
hgfedcbaaponmlkjihgfedcbaponmlkjihgfedcbayxwvutsrqponmlkjihgfedcba gfedcbaonmlkjihgfedcbalkjihgfedcbafedcbaihgfedcbanmlkjihgfedcbagfedcba

Output (is a secret, shh)

May the input contain leading or trailing spaces, or several spaces in a row?

@Arnauld I'm happy with trailing and leading spaces, but not within the result itself.

Sorry, I meant the input, not the output. (I've edited my previous comment.)

@Arnauld The input could have trailing and leading spaces.

May our input & output types differ (e.g. string in, list of characters out?) - maybe we have a meta consensus...?

@JonathanAllan sounds fine to me

Alexa, announce "hgfedcbaedcbalkjihgfedcbalkjihgfedcbaonmlkjihgfedcba wvutsrqponmlkjihgfedcbaonmlkjihgfedcbarqponmlkjihgfedcbalkjihgfedcbadcba"

JavaScript (ES9),  37 33  26 bytes
Returns an array of characters.
Either a negative look-behind:
s=>s.match(/(?<![b-z])./g)

Try it online!
Or a positive look-behind:
s=>s.match(/(?<=a| |^)./g)

Try it online!

25 bytes
If the input is guaranteed not to contain leading or double spaces (or we're allowed to remove and collapse them respectively), the positive look-behind can be made 1 byte shorter:
s=>s.match(/(?<=a|\b)./g)

Try it online!

Haskell, 32 bytes
f s=[y|(x,y)<-zip('a':s)s,x<'b']

Try it online!
For each pair of consecutive characters, if the first one is 'a' or ' ', output the second one. Prepends an 'a' to the string so that the first character is always output.

Jelly, 6 bytes
OŻI‘Tị

A monadic Link accepting a list of characters which yields a list of characters.
Try it online!
How?
OŻI‘Tị - Link: list of characters, S   e.g. "  baadcba  acbaedcba  "
                                       i.e. [' ',' ','b','a','a','d','c','b','a',' ',' ','a','c','b','a','e','d','c','b','a',' ',' ']
O      - to ordinal (vectorises across S)   [ 32, 32, 98, 97, 97,100, 99, 98, 97, 32, 32, 97, 99, 98, 97,101,100, 99, 98, 97, 32, 32]
 Ż     - prepend a zero                 [  0, 32, 32, 98, 97, 97,100, 99, 98, 97, 32, 32, 97, 99, 98, 97,101,100, 99, 98, 97, 32, 32]
  I    - incremental differences            [ 32,  0, 66, -1,  0,  3, -1, -1, -1,-65,  0, 65,  2, -1, -1,  4, -1, -1, -1, -1,-65,  0]
   ‘   - increment (vectorises)             [ 33,  1, 67,  0,  1,  4,  0,  0,  0,-64,  1, 66,  3,  0,  0,  5,  0,  0,  0,  0,-64,  1]
    T  - truthy indices                     [  1,  2,  3,      5,  6,             10, 11, 12, 13,         16,                 21, 22]
     ị - index into (S)                     [' ',' ','b',    'a','d',             ' ',' ','a','c',       'e',                ' ',' ']
                                       i.e. "  bad  ace  "

J, 22 13 12 bytes
–9 bytes, thanks @Jonah!
#~1,1-{:I.}:

Try it online!

13 bytes: #~1,98>3 u:}: (Try it online!)

Perl 5 (-p), 15, 16 bytes
s/[b-z]\K.*?a//g

Try it online!
or using options trick
Perl 5 (-nF/(?<![\x20a])(?!^)[b-z]*a/), 7 bytes
print@F

Try it online!

Python 3, 43 bytes
lambda s:[r for l,r in zip(' '+s,s)if'b'>l]

An unnamed function accepting a string which returns a list of characters.
Try it online!

To accept & return lists use ...zip([' ']+s... instead (45)
To accept & return strings use lambda s:''.join(r for l,r in zip(' '+s,s)if'b'>l) (50)

C (clang), 100 98 96 95 94 92 90 88 64 46 bytes
Saved 24 bytes thanks to @Neil!!!
Saved 18 bytes thanks to @dingledooper (removed #include<stdio.h>)
f(char*c){while(*c)for(putchar(*c);*c++>97;);}

Try it online!

Why not just while(*n>97)?

Also, by putting putchar(*c); before the while loop, I was able to replace all uses of n with c.

In fact, by changing the while loop into a for loop you can move the putchar(*c) into the initialiser, saving you a pair of {}s.

@Neil Thanks so much, that's amazing!  And now I can finally have a post-increment as part of the condition expression. :-)

Thanks for posting this; the loop structure was useful for an x86 machine code implementation

05AB1E, 9 8 bytes
-1 byte thanks to Kevin Cruijssen
AηíR¬S.:

Try it online!

8 bytes by replacing ASR with ¬S.

@KevinCruijssen Nice catch, thanks!

Japt -g, 10 9 8 bytes
óÈ¥YcÄÃy

Try it
ó           split between those characters that return true when passed through...
 È    Ã     function :
  ¥         x equal to..
   YcÄ      character next to y
       y   transpose

Flag -g used to get 1st element

Saved 1 thanks to @Shaggy

1dYc can be YcÄ

I don't know why ó> or ò< won't work here; was trying them earlier.

I was trying something similar too but nothing worked

And yet ... https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=UzwnYQ

@Shaggy i moved to japt chat

R, 57 56 bytes
-1 byte thanks to Giuseppe.
function(s)intToUtf8(c(v<-utf8ToInt(s),0)[c(0,v)%%32<2])

Try it online!
Could probably be made shorter with a regex, but this is more R-like. Converts to integers (vector v), then keeps only the first character and the characters which follow a space or an a. Since the corresponding codepoints are 32 and 97, we can check whether \$v_i\mod 32 <2\$ to get the relevant entries.

56 bytes using in-line assignment instead of a function argument

JavaScript, 35 32 31 bytes
s=>s.replace(/ |.*?a/g,x=>x[0])

Try it online!

Haskell, 59 bytes
f""=""
f(x:s)|x<'b'=x:(f s)|1>0=x:(f$tail$dropWhile(>'a')s)

Try it online!
No match for regex solutions, but I figured I'd try a recursive solution.

57 bytes

Japt -S, 9 8 bytes
¸®ò§ mÎ¬

Try it
¸®ò§ mÎ¬    :Implicit input of string
¸           :Split on spaces
 ®          :Map
  ò         :  Partition between characters where
   §        :  First is <= second
     m      :  Map
      Î     :    First character
       ¬    :  Join
            :Implicit output, joined with spaces

Ruby, 28 bytes
->s{s.scan(/(?<=a|\b)./)*""}

Try it online!
This is a port of Arnauld's Javascript answer to Ruby.

K (oK), 14 bytes
{x@&1,98>-1_x}

Try it online!
Inspired by FrownyFrog's/Jonah's J solution

SNOBOL4 (CSNOBOL4), 106 bytes
	I =INPUT
S	I LEN(1) . X	:F(O)
	O =O X
	R =
	REVERSE(&LCASE) X REM . R
	I X R REM . I	:(S)
O	OUTPUT =O
END

Try it online!
	I =INPUT			;* Read input
S	I LEN(1) . X	:F(O)		;* extract the first letter or goto O if none exist
	O =O X				;* append that letter to the output
	R =				;* set R to the empty string
	REVERSE(&LCASE) X REM . R	;* Set R to the letters up to 'a', starting at X.
					;* R is empty string if X is space or 'a'
	I X R REM . I	:(S)		;* Set the REMainder of I after (X + R) to I; goto S
O	OUTPUT =O			;* output the string
END

Jelly, 10 bytes
Ḳµ=Ṃk⁸ZḢ)K

Try it online!
A monadic link taking a Jelly string and returning a Jelly string. When run as a full program takes a string as its argument and implicitly prints the output string.

C# (Visual C# Interactive Compiler), 33 bytes
x=>x.Where((_,l)=>l<1||x[l-1]<98)

Try it online!

Red, 74 bytes
func[s][parse s[any[copy t thru"a"(prin#"`"+ length? t)opt[sp(prin sp)]]]]

Try it online!

braingasm, 20 18 bytes
,[.32-n[65-$[,]],]

It's been a while since I worked on braingasm. There seems to be a compare function, but I guess I didn't come around to implement a way to use the result. Well, this works:
,                    #  Read a byte from input
 [               ]   #  While the current byte is not zero
  .                  #    Print it
   32-               #    Decrease by 32
      n[       ]     #    If the result is non-zero (meaning it wasn't a space):
        65-          #      Subtract 65, leaving 'a' => 0, 'b' => 1, 'c' => 3, etc
           $[,]      #      That many times, read a byte from input
                ,    #    Read another byte

Doesn't handle newlines or anything other than lowercase letters and spaces in the input.

Pip, 12 bytes
aR`\w*?a`_@0

Try it online!
Explanation
a             The input, as a command-line argument
 R            Do a regex replacement:
  `\w*?a`      Match a non-greedy series of letters ending in a
         _@0   Replace with the first character of the match

C (clang), 66 48 bytes
edit: -18 bytes thanks to @dingledooper (removed #include)
P;D(char*T){*T?P>97||putchar(*T),P=*T++,D(T):0;}

Try it online!
int P;          // previous character
D(char*T)
{
    if (*T)     // check for end of string
    {
        if (!(P > 'a'))     // output current if previous was 'a' or ' '
            putchar(*T);
        P = *T;             // update previous
        D(T + 1);           // find next
    }
}

You can remove the #include <stdio.h>, by the way

@dingledooper that's interesting, I didn't know that C allows calling standard functions without including the appropriate header.

@xibu: It's not recommended, but yes C89 has default-promotion rules for what happens when calling a function for which no prototype exists.  If the actual definition of the function is compatible with the args you passed it, it works.  If not, UB with no detection at compile time of the mismatch.

x86 machine code, 12 bytes
(Runs in any mode, 16-bit, 32-bit, or 64-bit.)
This is based on @Noodle9's C algorithm, but with rearrangement into do{}while asm loop structure.
NASM listing: address, machine code (hex dump of the actual answer), source
 1                             decda:  ; (char *dst=RDI, const char *src=RSI)
 2 00000000 AC                     lodsb             ; AL = *src++
 3                             .loop:                ; do{
 4 00000001 AA                     stosb                 ; *dst++ = AL
 5                                .skip_until_a:         ; do{
 6 00000002 3C61                    cmp  al, 'a'
 7 00000004 AC                      lodsb
 8 00000005 77FB                    ja  .skip_until_a    ; }while((AL=*p++) > 'a')
 9 00000007 84C0                   test al,al
10 00000009 75F6                   jnz .loop         ; } while(AL != terminator)
11                             ;    stosb             ; append a terminating 0
12 0000000B C3                     ret
                       ; output end pointer returned in RDI

Try it online!
The input is an implicit-length (0-terminated) C string.  The output is an explicit-length buffer.  This function returns (in RDI) a pointer to one-past-the-end.
(The caller already knows where the output buf starts, so it has C++-like .begin and .end iterators).  Making this function append a terminating 0 would cost 1 extra byte for another stosb after the loop, unless there's a way to rearrange things that I'm not seeing.

A sample caller that passes the output of decda(argv[1]) to a write system call is included in the TIO link.  You can inc edx in that caller to prove that the output didn't over-write beyond where it's supposed to.
I had been thinking of using loop .loop instead of test al,al/jnz but then the inner loop would need a dec ecx or something.  (Without that, it loops until writing RCX output bytes, which only works if the caller knows the decrypted length, not the source length.)  Worth considering for a 32-bit-only version that can use 1-byte dec ecx, unless that could reach loop or loopne with ECX<=0 for valid inputs.

Very nice!  I assembled and tested this on 16-bit MASM 1.1 and passes all tests perfectly.  :)

@640KB: cool, I only tested it on x86-64 Linux.  Well-golfed machine code is often independent of mode thanks to using implicit increments and sizes so I was pretty sure about my claim of working in any mode, but nice to have it tested :)

(Correction to my last comment: ModRM.rm memory addressing modes have a different interpretation with 16-bit address-size than with 32 or 64.  e.g. rm field = 000 is [rax] in 64-bit vs. [bx+si] in 16-bit.  So the exact same machine-code bytes working the same in 16-bit mode only happens when memory access uses lods/stos and similar, not cmp cl, [rbx] or whatever.)

C# (Visual C# Interactive Compiler), 69 bytes
Hard to beat Regex on this one
s=>System.Text.RegularExpressions.Regex.Replace(s,"([b-z]).*?a","$1")

Try it online!
Returns an array of Matches (characters), 64 bytes
s=>System.Text.RegularExpressions.Regex.Matches(s,"(?<![b-z]).")

Try it online!

Ruby, 20 + 1 bytes
gsub /(?<!a|\b)./,''

1 extra byte for the p command line option:
$ ruby -p alphabet_cypher.rb <<< "hgfedcbaedcbalkjihgfedcbalkjihgfedcbaonmlkjihgfedcba wvutsrqponmlkjihgfedgfedcbarqponmlkjihgfedcbalkjihgfedcbadcba"
hello world

Try it online!

Keg, -ir, -lp, 9 7 bytes
(⑩(a-|_

Try it online!
2 bytes saved thanks to @A̲̲ suggesting to use a for loop over a while loop
Answer History
{!|⑩(a-|_

Try it online!
{!|⑩(a-|_
{!|             #While there are still items on the stack:
   ⑩            #Print t.o.s without popping
    (a-|            #Subtract the code point of a from tos and repeat that many times:
        _           #Pop items off the stack

7 bytes. A simple optimization from while to for. (Your current program also generates an error in the end, so..)

@A  No, not at all. I... I wouldn't have thought of using a for loop... I was going to add a 'loop while there are still items on the stack' command to get this down to 6 bytes.

Perl, 20 bytes
s:[^a]*a(.):a$_\1:g;

is almost there.  Unfortunately, it will lose the first letter, and I don’t know how to get around that.

Just add an a on the beginning! "a$_" =~ ....

Doesn’t $ match the end of the string?  And the underscore?

$_ is the string! "a$" is equivalent to concatenating "a" and $ ...

I edited according to how I interpret your comment, but either it's wrong or I misunderstood.  What I put in would make every output start with 'a'.  Can you edit it so that it is correct?  (Not that it competes with the length of a few others.)

Oh, no, I meant, apply the regex to "a$" (I'm assuming you use "perl -ne" or "perl -pe", so each line will be available as $).

OK, that adds seven more bytes if I stick to ASCII.

Gema, 41 characters
\A\P?=?
 \P?=$0
?\P?=@cmps{?;?;$2;$2;}
?=

Unfortunately recognizers can not be combined. ☹
Sample run:
bash-5.0$ gema '\A\P?=$0; \P?=$0;?\P?=@cmps{$1;$2;$2;$2;};?=' <<< 'cbagfedcba cbacba'
cg cc

Try it online!

C++,  464 bytes
I'm still a beginner so will be grateful for any advice.
#include <iostream>
#include <string>
using namespace std;

int main() {
  string input , output;
  getline(cin,input);
  output = input[0];

  for (int i = 0 ; i<input.size() ; i++) {
      if (input[i] == 'a')  {
          output += input[i+1];
      }  else if (input[i] == ' ') {
          output += input[i+1];
      }  else {
          continue;
      }

  }
  cout << output;
}

Try it online!

I don't know much about C++, but 212 bytes

Also, welcome to CGCC! I hope you enjoy golfing answers to challenges while you're here!

Get a warning for 159 bytes

As a first step, definitely remove all whitespace (including newline) and unneeded {}.  And always use single-letter variable names.  You can include an "ungolfed" version of your code in your answer (with newlines and comments) so people can read it.  See also Tips for golfing in C++

The <string> header is already included in <iostream>, the number of times you need std:: is way less bytes than using namespace std;, std::string::operator[](size_t pos) will return '\0' for pos == size(). and your if statement can be collapsed to checking if the current character is less than 98('b'). 122 bytes. :-)

And just found out about #import to save another byte 121 bytes.

Building on @Noodle9 119 bytes

Python 3.8 (pre-release), 50 bytes
import re
f=lambda s:re.sub('([b-z]).*?a',r'\1',s)

Regex stolen from Arnauld's JavaScript answer.
Try it online!

You can save 2 more bytes easily...

@game0ver I'm not familiar with the rules of the site, but does that count as a function?

Yes lambda is autonomous except for e.g. a recursive function where you need to refer to f...

@game0ver But you can't just do something like print((lambda s:... import re)(input())) right?

If you mean to place that all in the Footer then no. Your code must be an autonomous complete function/program. A lambda can be used standalone in a e.g. map etc...

works fine in earlier versions of python3 and even in python 2.7.

Python 2, 87 86 84 bytes
lambda i:"".join(x[:2]if'a'>x else x[0]for x in i.replace('a','a#').split('#')[:-1])

Try it online!
Non-regex effort. Replaces a with a plus a disposable character then splits on the disposable character and outputs either the first or first two letters of each list element depending on whether the first is a space or not.

Jelly, 20 bytes
O0;ṡ2_/>0ƊÐḟṪ€Ọ
ḲÇ€K

Try it online!
probably too long lol
Explanation
O0;ṡ2_/>0ƊÐḟṪ€Ọ  This challenge, for one word
O                turn all the chars to their ASCII forms
 0;              prepend 0
   ṡ2            split into (overlapping) slices of length 2 (pairs)
          Ðḟ     filter: remove elements where
     _/          reducing over subtraction (which is equivalent to the first minus the second, in each pair)
       >0        is greater than 0 (if it's strictly descending)
            Ṫ€   take the second element of each pair
              Ọ  convert back to chars
ḲÇ€K             Compiled Program
Ḳ                split on spaces
 Ç€              apply the helper to each word
   K             join on spaces

Charcoal, 8 bytes
Φθ‹§θ⊖κb

Try it online! Link is to verbose version of code. Explanation:
 θ          Input string
Φ           Filtered where
    θ       Input string
   §        Cyclically indexed by
      κ     Current index
     ⊖      Decremented
  ‹         Is less than
       b    Literal string `b`
            Implicitly print

Wren, 67 bytes
Non-regex effort. I can't use regex because Wren doesn't support it..
Fn.new{|x|x.replace(" "," a").split("a")[0..-2].map{|i|(i+"a")[0]}}

Explanation
Fn.new{|x|                                                        } // New anonymous function with parameter x.
          x.replace(" "," a")                                       // Append spaces with the a character in order to make them individual.
                             .split("a")                            // Split into a list with the character a.
                                        [0..-2]                     // We have a trailing unused a, so we need to remove it.
                                               .map{|i|          }  // Foreach this list:
                                                       (i+"a")      // Append this item with an a character(since we have used it for the splitting function)
                                                              [0]   // Return the first item in this list

Try it online!

Java (JDK), 35 bytes
s->s.replaceAll("([b-z]).*?a","$1")

Try it online!

J, 18 bytes
({.;.2~'a'=])&>@;:

Try it online!

You don't need the outer parenthesis.

Burlesque, 21 19 bytes
{'`+]2CO:so)[-}ww\[

Try it online!
Non-regex solution, can save 2 bytes if permitted to return list of chars
{
 `'+] # Prefix each word with a backtick
 2CO  # Create n-grams of length 2 (abc => {ab bc})
 :so  # Filter for those which are in alphabetical order
 )[-  # Take the last letter of each n-gram
}ww   # For each word
\[    # Concatenate to string

Husk, 8 bytes
wmom←ġ<w

Try it online!

PHP, 67 bytes
According to the definition, we don't have to worry about invalid input. So I'm not actually checking if all the letters between the intended letter and "a" are properly following the reverse alphabet order, or even if there's the right number of letters. Feels a bit dirty, but it works for all valid input :)
for($x=0;$c=$argn[$x++];){$l=$l?$l:$c;if(ord($c)<98){echo$l;$l=0;}}

Try it online!

Thunno 2 B, 6 bytes
0ƤṢ⁺Vi

Try it online!
Port of Jonathan Allan's Jelly answer.
Explanation
0ƤṢ⁺Vi  # Implicit input
0Ƥ      # Prepend a 0
  Ṣ     # Deltas
   ⁺    # Incremented
    V   # Truthy indices
     i  # Index in
        # Implicit output


text:
Can Alice win the game?
Can Alice win the game?
The game's rules are as follows. First, a finite non empty set of positive integers \$X\$ is defined. Then, Alice and Bob take turns choosing positive integers, with Alice going first. Each integer must be strictly less than the previous one, and the game ends when one of the players chooses \$1\$.
Alice wins if the numbers she and Bob chose sum to a number in \$X\$, otherwise Bob wins.
Example games
Define \$X=\{20, 47\}\$. Alice chooses \$19\$, Bob chooses \$2\$, Alice chooses \$1\$. We have \$19+2+1=22\$ which is not in \$X\$ so Bob wins.

Define \$X=\{5, 6, 7, 8\}\$. Alice chooses \$4\$, Bob chooses \$3\$, Alice chooses \$1\$. We have \$4+3+1=8\$ which is in \$X\$ so Alice wins.
Challenge
Your challenge is to write a program or function without standard loopholes which, when given a collection of positive integers \$X\$, will output or produce some consistent value if Alice has a winning strategy, and a different consistent value if Alice does not have a winning strategy.
A winning strategy is a strategy which will let Alice win no matter how Bob plays.
Note that in the first example game Alice did not have a winning strategy: If her first choice was any number other than \$19\$ or \$46\$ then Bob could choose \$1\$ and win. On the other hand if her first choice was \$19\$ or \$46\$ then Bob could choose \$2\$ and win.
In the second example, Alice did have a winning strategy: After choosing \$4\$, she could choose \$1\$ after any of Bob's possible choices and win (or Bob could choose \$1\$ and she would win immediately).
Input and output
The input will be a collection of positive integers in ascending order, in any convenient format, given with any convenient input method. This collection represents the set \$X\$. The output will be one of two distinct values chosen by you, depending on whether or not Alice has a winning strategy with the given collection. Example IO:
Input    -> Possible Output
20 47    -> false
5 6 7 8  -> true
5 6 7 10 -> true (Alice chooses 4. If Bob chooses 3, Alice chooses 2; otherwise she chooses 1.)
5 6 7 11 -> false (A chooses n>6, B chooses n-1. A chooses 6 or 5, B chooses 2. A chooses 4, B chooses 3. A chooses n<4, B chooses 1.)

Rules

No standard loopholes
Shortest code in bytes wins

Note
This was the result of trying to make a finite version of the Banach Game.

Can we assume that X will be in ascending/descending order?

@frank Good question. Yes, you may assume it will be in ascending order.

How should we handle 1 being in X?

@frank It is valid, and Alice can obviously win by choosing 1.

JavaScript (ES6),  89 85 83  81 bytes
Takes input as a set. Returns either \$0\$ or \$1\$.
Note: Although it doesn't make sense from a theoretical perspective, the set is expected to be defined in ascending order so that the highest value appears at the end once it's converted back to an array.
f=(s,n=~[...s].pop(),b,t=0,g=i=>--i>n?b^f(s,i,!b,t-i)||g(i):0)=>~n?b^g``:s.has(t)

Try it online!
Commented
  f = (         // f is a recursive function taking:
    s,          //   s = input set
    n = ~[...s] //   n = opposite of the value played by the previous player,
        .pop(), //       or -(maximum value of the set + 1) for the first iteration
    b,          //   b = flag telling whether it's Bob's turn
    t = 0,      //   t = sum of all (positive) values played so far
    g = i =>    //   g is a recursive function taking a counter i <= 0
      --i > n ? //     decrement i; if i is greater than n:
        b ^     //       invert the result of the following call if it's Bob's turn
        f(      //       recursive call to g:
          s,    //         pass s unchanged
          i,    //         pass the new value of i
          !b,   //         invert the flag b
          t - i //         subtract i from the sum
        )       //       end of recursive call
        || g(i) //       if the above result is falsy, try a recursive call to g
      :         //     else:
        0       //       stop recursion
  ) =>          //
    ~n ?        // if n is not equal to -1:
      b ^ g``   //   invoke g with i = [''] (zero'ish)
                //   and invert the result if it's Bob's turn
    :           // else:
      s.has(t)  //   return true if t is in s (Alice wins), or false otherwise

Ooh, I never thought of using Sets in code golf. .has() is so short :)

R, 86 83 bytes
-1 byte by using !m instead of m<1; -1 byte by realizing I only need one long OR || (the first one can be a short OR |); -1 byte by toggling B and using subtraction instead of equality of booleans.
a=function(x,m=max(x),B=T)!m|all(x-1)-B||any(sapply(1:m,function(y)!a(x-y,y-1,!B)))

Try it online!
Exhaustive recursive search. Takes input as a vector. Outputs TRUE or FALSE.
At each step, subtracts the value chosen by the player from all the values in the set x.
Alice wins if at her turn, the updated x includes 1. Bob wins if at his turn, the updated x does not include 1. To this end, the function includes a boolean B, worth TRUE when Alice plays and FALSE when Bob plays, and checks all(x != 1) != B. If this condition is verified then the player wins, else the player wins if there is a move which makes the other player lose (last condition in the code, uses recursion).
The initial !m (equivalent to m!=0) is there to check whether at the last move, the other player played 1 even though it is a losing move.
Edit: Arnauld added an explanation to his JavaScript answer while I was typing; it seems we have similar algorithms.

Jelly, 37 36 bytes
Ḣ’,_@ɗ€Ḣ;€CÑ€¬Ẹ
1Ç¬ḢoḊ’Ạ=ɗ/$Ʋ?
Ṁ,;0Ç

Try it online!
Translation of @RobinRyder’s R solution so be sure to upvote that one!

I can't read Jelly, but FYI I golfed 3 bytes in my solution - maybe this can be translated in your solution?

@RobinRyder thanks. I’d already the first optimisation, and the second two unfortunately don’t save me bytes in Jelly.

Python 2, 102 101 100 bytes
f=lambda A,t=0,s=1,m=0:t<1if(s in A)^t else[any,all][t](f(A,1-t,s+i,i)for i in range(2,m or max(A)))

Try it online!
Returns True/False for if Alice has a winning strategy.
Recurses alternating between Alice and Bob (with t==0/1, respectively). s-1 is the running sum of choices so far; and m-1 is the maximum integer value allowed for a player to choose.
If s is in A and it's Alice's turn, she wins by choosing 1. If s is not in A and it's Bob's turn, he would choose 1 and Alice loses. In both cases, that would stop the recursion.
Otherwise, if m==0, then this is Alice's first turn; and she cannot win if she chooses a value greater than or equal to max(A).
If it is Alice's turn, then she can win if there is any valid integer choice that eventually ends up winning.
Conversely, on Bob's turn, Alice wins only if none of Bob's possible choices guarantee eventually in a loss for Alice; which is to say that Alice wins on Bob's turn only if all his choices eventually yield an Alice win.

source: Stack Exchange

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

sort: votes


text:
Find the length of a number's "base-jumping" path
Consider a positive integer N written in base b. A sequence is generated from this number by finding the largest digit d in the expansion of N and writing N in base d+1, repeating until the base the number is written in can be decreased no further. For example, the sequence generated by 346 (10) in starting base 16 has length 6: 15A (16) = 295 (11) = 346 (10) = 1003 (7) = 11122 (4) = 110211 (3). Note that the next term in the sequence would be in base 3 again, which is invalid since the base does not decrease.
The goal of this code golf challenge is to write a program/function that takes two inputs (a decimal integer and a starting base - order doesn't matter and the two numbers must be integers) and outputs the length of the sequence generated according to the above rules.
Some test cases:
(24, 4) = 2
(19, 10) = 1
(346, 16) = 6
(7557, 97) = 20

Isn't (7557, 97) = 20? ([97, 89, 85, 78, 70, 68, 44, 40, 38, 34, 19, 18, 16, 14, 12, 10, 8, 7, 5, 3])

Suggested test case: (15*256+1,4)

Jelly, 7 bytes
b@Ṁ‘ɗƬL

A dyadic Link accepting b on the left and N on the right which yields the sequence length.
Try it online!
How?
b@Ṁ‘ɗƬL - Link: b; N
     Ƭ  - Collect up until no longer unique, applying:
    ɗ   -   last three links as a dyad - i.e. f(X[initially b], N):
 @      -     with swapped arguments:
b       -       convert (N) to base (X)
  Ṁ     -     maximum
   ‘    -     incremented
      L - length

Ruby, 44 bytes
->n,b{r=1;r+=1while b>b=n.digits(b).max+1;r}

Try it online!

Python 2, 67 bytes
edit: bug fix
S=lambda n,b,p=0:p-b and S(n,max(n/b**x%b for x in range(n))+1,b)+1

Try it online!
Explanation:
def S(Nr, Base, PrevBase=0):
    if Base != PrevBase:     # break recursion if Base repeats
        # find maximum digit in current base
        M=max([ (Nr//Base**x) % Base for x in range(Nr)])
        # return number of remaining steps plus one
        return 1 + S(Nr,M+1,Base)
    return 0

Fails for 15*256+1,4 (gives 2 instead of 1)

@Kritixi Lithos thanks, the problem is fixed now. Luckily runtime doesn't matter for code golf.

J, 40 37 bytes
[:<:@#(h,])^:([>h=.1+[:>./#.inv)/^:a:

Try it online!
-3 bytes thanks to Galen Ivanov

Why not make it an oneliner

Indeed.  Thanks Galen.

Julia 1.0, 46 44 bytes
N*b=(d=max(digits(N,base=b)...)+1)==b||N*d+1

This uses a recursive approach together with the short-circuit operator || and makes use of the fact that Julia promotes booleans to integers under addition, so true + 1 == 2. This also overwrites the * operator, which you wouldn't normally do, but this lets me write f(N,d) infix as N*d to save 3 bytes.
Try it online!

Japt, 22 19 14 bytes
{aU=VìU rÔÄ}f1

Try it
Takes input as base,number
{           }f1     repeat until function return false  starting with 1, increment in
 a                  difference between 1st input U and..
  U=                U, which is assigned..
    VìU             2nd input V to base U
        rÔ          reduced to max
          Ä         add 1

Saved 5 thanks to @Shaggy suggestion to use reduce to max instead of sort, plus using counter of f() instead of manually count using T

14 bytes?

Charcoal, 24 bytes
ＮθＮηＷ∧⊞Ｏυη⁻⊖η⌈↨θη≧⁻ιηＩＬυ

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

Input N and b.
Ｗ∧⊞Ｏυη⁻⊖η⌈↨θη

Push b to the predefined empty list to build up the sequence, then convert N to base b, and subtract the largest resulting digit from b-1. Repeat until this is zero.
≧⁻ιη

Calculate the new base.
ＩＬυ

Output the length of the sequence. (-1 byte to output the sequence itself.)

Python 2, 87 bytes
h=lambda n,b:n>=b and max(n%b,h(n/b,b))or n
f=lambda n,b,c=0:b!=c and f(n,h(n,b)+1,b)+1

Try it online!

and f(...)+1 ~> and-~f(...= would save a byte. != ~> - would save another.

JavaScript (ES6), 60 bytes
Takes input as (n)(b).
n=>g=b=>(x=(h=n=>n&&Math.max(n%b,h(n/b|0)))(n)+1)<b?1+g(x):1

Try it online!

C# (Visual C# Interactive Compiler), 83 bytes
x=>y=>{int g=y,t=0;for(;x>(x=new int[32].Max(l=>g-(g/=x)*x)+1);t++,g=y);return++t;}

Try it online!

J, 22 bytes
[:#([:>./1+#.inv~)^:a:

Try it online!
Simplified version of Jonah's solution.
How it works
[:#([:>./1+#.inv~)^:a:  Left: number N, Right: initial base B
   (             )^:a:  Collect all intermediate values up to fixpoint:
           #.inv~         Compute digits of N in base B
         1+               Increment
    [:>./                 Max; this becomes the new value of B
[:#                     Length of the result

05AB1E, 8 7 bytes
Δвà>¼}¾

-1 byte thanks to @Grimmy.
Start-base \$b\$ as first input; number \$N\$ as second input.
Try it online or verify all test cases.
Explanation:
Δ     # Loop until the top of the stack no longer changes:
 в    #  Convert the (implicit) input-integer N to (implicit) input-base b as list
  à   #  Pop the list and push the maximum
   >  #  Increase it by 1 (which will be the new base b for the next iteration,
      #                    with the same (implicit) input-integer N)
 ¼    #  And in every loop-iteration: increase the counter_variable by 1
}¾    # After the loop: push the counter_variable
      # (after which it is output implicitly as result)

No need to repeat the в. Alternative 7: Δвà>}N>.

@Grimmy Ah, of course. And I knew about that alternative. I actually had that one in mind as well, but liked this one more (especially because it also works in the legacy version and I prefer to keep the loop-index inside the loop when using it - if I have a choice like here). Thanks for the -1, though

K (ngn/k), 18 bytes
{#{1+|/y\:x}[x]\y}

Try it online!

Red, 89 bytes
func[n b][k: 0 until[k: k + 1 m: n t: 1 until[t: max t m % b 1 > m: m / b]b = b: 1 + t]k]

Try it online!

MIT-Scheme, 117 bytes
(define(g n r)(if(= n 0)0(max(modulo n r)(g(quotient n r)r))))
(define(f n r)(if(=(+(g n r)1)r)1(1+(f n(1+(g n r))))))

(newline added for readability)
g is a helper function that computes the maximum digit of the number in a radix, and f is the main function.

Haskell, 104 bytes
i=iterate
d n b=1+maximum(take(n+1)$snd<$>i((`divMod`b).fst)(n,0))
u(a:b:c)|a==b=1|2>1=1+u(b:c)
(u.).i.d

Haskell has no base conversion function. So I have to implement it normally.
snd<$>i((divModb).fst)(n,0) returns an infinite list with zero as the first element, followed by represented by the representation of n at base b, followed by infinite number of zeros. (((divModb).fst)(0,0) returns (0,0))
I just iterate function d until the value stopped changing and count the number of iteration. (In haskell, you do that by iterateing the function infinitely and take only the first few elements)

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


text:
An "Iniative" game mechanic
This challenge is inspired by turn based videogames like "Heroes of Might and Magic"

Implement this game mechanic:

There is some units(Imps, Swordsmans etc...) in our game
Every unit have an integer "initiative"
Your program must decide which unit's turn now - based on unit's initiative
The more initiative means more frequent turns(for example unit with 10 iniative will move 5 times more often than 2 iniative unit)
Unit with highest initiative moves first
Input: Array of pairs of [unit_name: string, unit_initiative: integer]
Output: Unit names in moving sequence separated by line break (\n)
Make 50 turns total

Test case:
Units:
[["Imp", 500], ["Mammoth", 50], ["Swordsman", 250], ["Elf", 350]]
turn sequence(50 turns) output:
Imp
Elf
Imp
Swordsman
Elf
Imp
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Imp
Elf
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Mammoth
Imp
Elf
Imp
Swordsman
Elf
Imp
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Imp
Elf
Imp
Swordsman
Elf
Imp
Elf
Imp
Swordsman
Mammoth
Imp
Elf
Imp
Swordsman

Other rules:

Use your favorite language
Write shortest code possible
Attach a link to an online iterpreter
Please follow standard code golf rules

Welcome to the site. You need to provide an objective scoring criterion. From the ‘other rules’ bit, I assume you’re intending to make this a code golf challenge, so this should be tagged as such. The usual scoring for code golf is bytes. Optional challenges don’t tend to work because if you’re optimising code length you’ll ignore the optional challenges.

To add on, the optional challenges are also a problem since they look like they can be interpreted in a way that trivializes the task.  They are very vague as to what they require so you might, remove all the units on the first turn, to avoid doing any computation, and say that this is fulfilling the first optional task.

Inputs and outputs specified;
Optional challenges removed;
"Write shortest code possible" added to "Other rules";

Thanks for taking the time to fix the challenge.  I am still unsure of the task.  A couple of questions I have are: What sort of order is required if any? for example in your example could I just give Imp 500 turns in a row, then the elf 350, then the swordsman 250, then the mammoth 50 and then repeat?  Or do I have to do some specific order? Or is there a rule that the order must follow?  In order for this to be clear it must be possible to look at the output of a program on given inputs and objectively determine whether that program is valid.

Jelly, 20 15 bytes
P:ṭ×¥Ɱ"Ɗ,€"ẎṢṪ€

Try it online!
A dyadic link taking a list of initiative scores as its left argument and a list of characters as its right and returning a list of the characters in movement order.
Jelly, 14 bytes
İṭ×¥Ɱ"$,€"ẎṢṪ€

Try it online!
This version is one bytes shorter but I expect may sometimes get the order wrong because of inaccuracies in floating point calculations.


text:
What is a short code for generating this matrix in R?
I can see that it is 101 'moving to the right' but I cannot think of a short way to generate it in R language.
\$\begin{bmatrix}
0 & 1 & 0 & 0 & 0 & 0 \\
1 & 0 & 1 & 0 & 0 & 0 \\
0 & 1 & 0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 & 1 & 0 \\
0 & 0 & 0 & 1 & 0 & 1 \\
0 & 0 & 0 & 0 & 1 & 0 \\
\end{bmatrix}\$

Welcome to the site.  Your title and your tags mention R, but the body of your question does not.  This is a question in R right?  If so this is a [tag:tips] question (you can learn about them here), It would be best if you included your own best try so that answerers can know what level you are currently at.

Am I right in assuming that there is a typo on the last row of your figure? Shouldn't the last 1 be at position [6,5] instead of [6,6]?

That's right, many thanks!

Is this even a challenge for others or is it a legitimate question OP has?

@MarkJeronimus I would assume that the challenge writer knows how to write up a matrix in long form.  I prefer to assume good faith until evidence appears otherwise, but even if this question was asked in bad faith I'm not sure this matters, it looks like this is an interesting enough question to warrant several answers so even if the OP is not interested in golfing techniques it can still teach others.

R, 24 23 22 20 bytes
diag(0,6)+c(!-1:4,1)

Try it online!
Just use R's recycling! This does give a warning, but otherwise is fine.
Thanks to Robin Ryder for the 2 byte golf.

I see the warning and understand why it's there but would this create any issues down the line?

@Mattex I can't think of any, apart from how tough it is to read and understand what's going on, lol.

@Mattex updated my answer.

many thanks buddy.

20 bytes with diag instead of matrix.

@RobinRyder nice! That is a good tip for generating a square matrix of zeros! I'm on mobile right now, so feel free to edit that in if you like

R, 30 27 bytes
+!abs(outer(1:6,1:6,`-`))-1

Try it online!
Another alternative. Note this matrix shows which integers between 1 and 6 are exactly 1 apart. (i.e. \$|i - j| = 1\$).
Thanks to @RobinRyder for saving a byte! I was forgetting + could be used as a unary operator. Thanks also to @Giuseppe for saving 2 bytes!
If a matrix of logical values is permissible, then this also works:
R, 26 bytes
abs(outer(1:6,1:6,`-`))==1

Try it online!
This is also the closest to my shortest Jelly solution to this:
Jelly, 5 bytes
6ạþ=1

Try it online!

In the first solution, you don't need the initial 0.

R, 34 bytes
x=cbind(rbind(0,diag(5)),0)
x+t(x)

Try it online!
Outputs
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    0    1    0    0    0    0
[2,]    1    0    1    0    0    0
[3,]    0    1    0    1    0    0
[4,]    0    0    1    0    1    0
[5,]    0    0    0    1    0    1
[6,]    0    0    0    0    1    0

Builds a \$5\times5\$ diagonal matrix, pads with 0s at the top and the right, and adds it to its own transpose.

My mistake, matrix now corrected in quoestion and Robin Ryder's answer was of help.


text:
How divisible are you?
You are to create a program which, when given a positive integer \$n\$, outputs a second program. This second program, when run, must take a second positive integer \$x\$ and output one of two distinct values depending on whether \$x\$ is divisible by \$n\$. Those values must be consistent for a given \$n\$ but can be different values for different \$n\$.
However, for each value of \$n\$, the outputted program may only contain bytes whose code points are divisible by \$n\$. You may use any pre-existing code page to score and restrict your answer, but the code pages used for both programs must be the same. In addition, both programs must be in the same language (including versions. Python 3 \$\ne\$ Python 2). Your score is the highest consecutive value of \$n\$ your program works for. That is, your program must work for \$n = 1, 2, 3\$ and \$4\$ in order to have a score of \$4\$. All solutions must work for \$n = 1\$ and \$n = 2\$ at a minimum. The program with the highest \$n\$ wins.

Sandbox. It was pointed out that Lenguage is able to get an infinitely high score, so I would appreciate people avoiding trying to play that "loophole" - it's not original, nor especially funny, in my opinion.

>>> ''.join(chr(i) for i in range(32,127,2))
' "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^bdfhjlnprtvxz|~'so I can't evenprint -- why don't I like [restricted-source`](https://codegolf.stackexchange.com/questions/tagged/restricted-source)? )

In what form can the output be -- two distinct values for yes/no? Truthy/falsy? Does this have to be consistent between programs?

@Doorknob Two distinct values for yes/no. They must be consistent when run with the same x and n but can be different values for different n

Should the 2nd program work independently of the 1st, or may we assume it will only be run after the first? For example, if program 1 loads a library, may we use that library in program 2 without loading it again?

@RobinRyder No, the two programs must be (aside from n) independent

I would suggest allowing us to simply list the various 2nd programs for different values of n, since that it is where the crux of the challenge lies. Otherwise, the 1st program will probably often look like if n==1 cat(program for n=1) else if n==2 cat(program for n=2) else if n==3...

Can we assume an upper bound on x? Would 2^32 be fine?

@Grimmy Any reasonable upper bound is fine, given language constraints

It's not a language constraint, 05AB1E has big integer arithmetic, but I still can't get n=9 if I need to handle arbitrarily large integers (see bottom of my answer).

@Grimmy In that case, yeah, restricting the input size (to a reasonable value) is perfectly acceptable

Do all the programs have to use the same type of input method? That is, can program A input a number, B uses an array of digits, and C uses a string?

@EmbodimentofIgnorance No, you may mix and match accepted methods

05AB1E, n=13, 189 bytes
'Ì6×ÐI" ÿB`0¢ "D"₁h44₁44÷÷÷ÝÐÃм₁hhhÐÃ44u4÷÷÷₁h44₁44÷÷÷ǝ÷ƶê4₁÷÷ 1 Èÿ°À4ô¤¬ xÒÍÍ<_Zÿ11*Ò88w8*н¡Ë18*Ë xh`H°` ₂6₂6₂6$--«üuÆ-«üuÆ-«üuÆΘ ÒæP<<<<<<<<<<n(Zd XXšXXÜýвXšXš¥Æ≠≠ ÿÿð¨и0Ì<0ǝÀ0ÿäÀ`∍`Ā"#Iè

Try it online! or validate codepoint divisibility.
n=1: 1 simply returns 1, since all integers are divisible by 1.
n=2: È is the built-in for that, and its codepoint is even.
n=3 TIO:
3B        # convert input to base 3
  `       # get the last digit
   0¢     # count occurences of 0 in that digit

n=4 TIO:
°         # 10**input
 À        # rotate left
  4ô      # split in chunks of 4 digits
    ¤     # get the last chunk
     ¬    # get the first digit of that chunk

n=5 TIO:
x         # double the input
 Ò        # prime factorization
  ÍÍ<     # subtract 5 from each prime
     _    # equal to 0?
      Z   # maximum

n=6 works identically to n=3.
n=7 TIO:
11*               # multiply the input by 11
   Ò              # prime factorization
    88w8*н        # first digit of 88*8, namely 7
          ¡       # split the prime factorization on 7
           Ë      # are all sublists equal?
            18*   # multiply by 18
               Ë  # are all digits equal?

n=8 TIO:
x         # double the input
 h        # convert to hex
  `       # get the last digit
   H      # convert from hex
    °     # 10**x
     `    # get the last digit

n=9 TIO:
₂           # push 26
 6          # push 6
  $         # push 1 and input
   -        # subtract: 1 - input
    -       # subtract: 6 - (1 - input) = 5 + input
     «      # concatenate: "26" + (5 + input)
      üu    # for each pair of digit, uppercase the second one
            # (used to convert to a list of digits, but drops the first digit)
        Æ   # reduce by subtraction: 6 - sum(digits(5 + input))
            # the above sequence is repeated twice, yielding 6 - sum(digits(sum(digits(sum(digits(5 + input))))))
         Θ  # is it equal to 1?

Note that this algorithm doesn’t work for arbitrary large numbers (but it still works up to 10^10000000000, which is good enough).
n=10 TIO:
Ò                  # prime factorization of the input
 æ                 # power set
  P                # product of each subset
   <<<<<<<<<<      # subtract 10 from each
             n     # square each
              (    # negate each
               Z   # maximum
                d  # is it >= 0?

Divisibility by 10 is usually the easiest, but unfortunately there’s no compliant way to get the last digit.
n=11 TIO:
X                  # push 1
 Xš                # prepend 1: [1, 1]
   XXÜ             # 1, with trailing 1s trimmed off (aka empty string)
      ý            # join: 11
       в           # convert input to base 11
        Xš         # prepend 1
          Xš       # prepend 1
            ¥      # deltas
             Æ     # reduce by subtraction
              ≠≠   # is it equal to 1?

n=12 TIO:
ÌÌÌÌÌÌÌÌÌÌÌÌ           # add 24 to the input
 ð                     # space character
  ¨                    # drop the last character (empty string)
   и                   # make a list of input empty strings
    0Ì<0ǝ              # replace the first element with 1
     À                 # rotate left
      0ÌÌÌÌÌÌä         # split in 12 parts of approximately equal length
                       # (if the input isn’t divisible by 12, the first sublists will be longer)
       À               # rotate left
        `              # dump all to the stack
         ∍             # cycle the before-last sublist to match the length of the last sublist
          `            # get the last element
           Ā           # truthify

n=13 ([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]): TIO
₁h44₁44÷÷÷               # hex(256) / (44 / (256 / 44)) = 12
 Ý                       # range [0..12]
  ÐÃ                     # duplicate (well, triplicate then pop the third copy)
    м                    # remove (leaves a list of 13 empty strings)
     ₁hhhÐÃ44u4÷÷÷       # 13
      ₁h44₁44÷÷÷         # 12
       ǝ                 # set the element at index 12 to 13
        ÷                # integer division
                         # dividing by the empty string yields the numerator,
                         # so the result is 12x the input, followed by input / 13
         ƶ               # multiply each element by its index
                         # the last element is now equal to input iff 13 divides input
          ê              # sorted uniquify
           4₁÷÷          # divide by 0 (sets all elements to 0)

Divisibility by 13 (I've added some comments to explain what's going on). That took a while.. >.> But now you can continue to the (hopefully much easier) 14. :D

I was right now editing my answer to n=13.

Dang.. :( And here I was proud of finally finding this, lol. (Ignore the typos in my explanation and that trailing ÷.. Too late to edit my comment above now.) I'm curious about your n=13 in that case.

@KevinCruijssen I'm done editing, you can see my n=13 in my answer now. Kinda crazy that we independently found two completely different n=13 solutions
at almost the same time! Yours is a byte shorter (and could be much shorter by using my computation for 13), but I'm gonna stick with my
original approach since it handles arbitrarily large integers.

Oh, nice approach as well! And I indeed had the feeling my push 13 could be done shorter, but didn't bothered to look further after I found it. Finding the 13 wasn't the problem, it was somehow using it to check divisibility. :) The ƶ certainly has a key-role with the bytes that are left. Anyway, I won't be bothering to look at the n=14 characters unless your answer is unchanged for multiple days, since as with answering answers in general, you're sometimes faster, and always shorter. ;p

@KevinCruijssen Ò is divisible by 14, so it shouldn't be that hard (:

What makes you claim that working only up to 10^10000000000 is good enough?

@pppery https://codegolf.stackexchange.com/questions/196556/how-divisible-are-you/196581?noredirect=1#comment467701_196556

Japt, 108 bytes, n = 6
g[P"1""v""¥r3""ì4 ¬t(´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D  <(°D,°D""s7-2

ë2,-1
Z<7-2-2-2""NÌÀNÌr6"]

Try it
1 (1, no value)
1       //Output 1

2 (1, 0)
v       //Builtin, is divisible by 2

3 (true, false)
¥       //Input equals
 r3     //Input rounded to nearest multiple of 3

4 (true, false)
ì4                                                         //Convert to base-4 digits
   ¬                                                       //Concatenate to string
      ´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D,´D            //--D 14 times, D = -1 now
    t(                                                     //Take -1 element of the string
                                                 <         //Is that less than
                                                  (°D,°D   //++D 2 times (1)

5 (true, false)
s7-2       //Convert to base-5 string

ë2,-1      //Get every 2nd element of the string, starting from the last index, save in variable Z
Z<7-2-2-2  //Is Z less than 1?

6 (false, true)
NÌ       //Last element of input array
  À      //Doesn't equal
   NÌr6  //Last element of input array rounded to nearest multiple of 6

Sadly, I think it's not possible to get n=7. There is not a single parentheses character, and there is no way to access the input variable U besides ¡ (maps each element in array/string to undefined by default, returns NaN if caller is number) and Ë (maps each element in string/array to iteself, returns NaN if caller is number). And since we don't have } or Ã (used to close functions), we cannot use ¡ or Ë effectively at all.

Jelly, 103 bytes, n= 9
“1“d2Ṫ“3ḍ“d4 0ị⁼0”⁾d«;“2_7ƊȦ”¤ṭ“HHHHHN6ƭ€0ị<0”ṭ“~“8¡~“1ß¬?”j”‘¤ṭ“00000008 8ƭ⁸¡”ṭ”‘x4¤”~;$;“6¡~ñ-H?”¤ṭ⁸ị

Try it online!
Return values:
n div not
1 1    -
2 0   1
3 1   0
4 1   0
5 1   0
6 1   0
7 1   error
8 8   0
9 -1  error

Explanation
n=1
1 | 1

n=2
d2  | divmod 2
  Ṫ | tail

n=3
3ḍ | divisible by 3

n=4
d4      | divmod 4
   0ị   | last
     ⁼0 =0

n=5
d    Ɗ  | divmod following as a monad:
 «2     | - min of input and 2
   _7   | - minus 7
      Ȧ | each and all

n=6
HHHHHN6ƭ€     | For each number 1..z, half five out of every six numbers and negate the sixth
           0ị   | Last
             <0 | <0
n=7
~          | Bitwise not (effectively -1-z)
 ‘8¡       | Increment by 1 eight times
    ~      | Bitwise not
     ‘     | Increment by 1
      1ß¬? | If non-zero, call this link again. Otherwise return 1

n=8
00000008 8ƭ⁸¡ | Loop z times; for 7 out of 8 iterations, set value to 0 and for the eighth, set to 8

n=9
~            | Bitwise not
 ‘‘‘         | Increment by 1 three times
    ‘6¡      | Increment by 1 six times
       ~ñ-H? | If non-zero, call this link again. Otherwise return -1

Note (as pointed out by @Grimmy) that n=7 and n=9 will fail on larger inputs (>14651 and 14202 respectively) because of the recursion limits in Jelly/Python.


text:
How many times, are they multiples?
You are given three parameters: start(int), end(int) and list(of int);
Make a function that returns the amount of times all the numbers between start and end are multiples of the elements in the list.
example:
start = 15; end = 18; list = [2, 4, 3];
15 => 1 (is multiple of 3)
16 => 2 (is multiple of 2 and 4)
17 => 0
18 => 2 (is multiple of 2 and 3)
result = 5

The function should accept two positive integer numbers and an array of integers as parameters, returning the total integer number. Assume that start is less <= end.
examples:
Multiple(1, 10, [1, 2]); => 15
Multiple(1, 800, [7, 8]); => 214
Multiple(301, 5000,[13, 5]); => 1301

The shortest solution is the victor!!! May he odds be ever in your favor...

Nice challenge! Presumably the winning criterion is shortest code? In which case you should say so explicitly, and add the [tag:code-golf] tag.

Can we assume that start will always be less than end?

You say integers. So start, end or the elements in list may be non-positive?

Thanks for the feedback, I was lacking that in the problem.

I'd like to ask a question (as I'm really new in this channel), how do I decide the winner? since each language has it's own limitations... Or is it simply a personal preference?

05AB1E, 5 bytes
ŸÑ˜åO

Try it online!

Explanation
Ÿ       - the numbers between start and end
 Ñ      - get their divisors
  ˜     - deep flatten this list
   å    - find the instances of the elements in the list in these divisors
    O   - Sum this

Haskell, 33 bytes
(a#b)x=sum[1|0<-mod<$>[a..b]<*>x]

Try it online!
Explanation:
(a#b)x                            --take two values a and b and the list x
                      [a..b]      --generate the range a, a+1, ... , b
                mod<$>[a..b]      --partially apply "mod" to each entry of the list
                mod<$>[a..b]<*>x  --apply the partially applied functions to all values of the list x
          [1|0<-mod<$>[a..b]<*>x] --generate a new list with a one for every zero in the previously computed list
(a#b)x=sum[1|0<-mod<$>[a..b]<*>x] --sum it all up

Nice method. I found a variant that ties and tried to shorten it point-free but could tie at best -- maybe you have a better idea.

@xnor I've also tried to get rid of the x, but without success, the (0^) trick is neat, please consider posting it as an own answer! (So far I have had no success in golfing your suggestions further.)

JavaScript (Node.js), 44 bytes
(a,x,y)=>a.map(n=>t+=y/n-(~-x/n|0)|0,t=0)&&t

Try it online!

Python 2, 38 bytes
lambda a,x,y:sum(y/i-~-x/i for i in a)

Try it online!
\$ \sum _{i \in list} \lfloor \frac{end}{i} \rfloor - \lfloor \frac{start-1}{i} \rfloor \$
The answer seems trivial and naive. So am I misunderstand something?

Your Python answer is right -- I was going to post the same. Congrats on figuring out the simplification. I'm disappointed nobody else had found the floor-division idea earlier, at least on my quick glance of the answers.

@xnor the formula comes up with my mind just after I read the question. But since the question is posted ~1d ago (and no one using it), I can't quite believe it could be correct. After posting the JavaScript version, I realized that by using Python I could save many bytes..

Perl 6, 21 bytes
{sum $^a..$^b X%%@^c}

Try it online!
Explanation
{                   }   # Anonymous codeblock returning
 sum                    # The sum of
     $^a..$^b           # How many numbers in the range a to b
              X%%       # Are divisible by any of
                 @^c    # The third parameter

MATL, 5 bytes
:i\~z

Inputs are a cell array containing the start and end values,  and then a column vector defining list.
Try it online! Or verify all test cases.
Explanation
:    % Range, with implicit input: cell array {start, end}. This gives the range
     % from start to end
i    % Input: list of numbers in the form of a column vector
\    % Modulo, with boradcast. This gives a matrix with each number in the range
     % modulo each number in the list
~    % Logical negation
z    % Number of nonzero entries. Implicit display

Python 3, 54 bytes
lambda s,e,L:sum(n%l<1for n in range(s,e+1)for l in L)

Try It Online!

R, 35 bytes
function(a,b,l)sum(b%/%l-(a-1)%/%l)

Try it online!
Implementation of tsh's method by Giuseppe. 3 bytes shorter than the previous version:
R, 45 38 bytes
-7 bytes thanks to Nick Kennedy and Xi'an.
function(a,b,l)sum(!outer(a:b,l,`%%`))

Try it online!
Boils down to summing the values of !(x %% y) for x in a:b and y in l (%% is \$mod\$ in R, so x %% y == 0 iff x is a multiple of y).

Though it removes your first use of Negate, https://tio.run/##K/qfpmD7P600L7kkMz9PI1EnSSdHs7g0V0Mxv7QktUgj0QoooJOgqpqgqfk/TcNQR8HQAIitjDS5wDwLAyDX3MoCxDU2AAqYGoBEkjUMjYFsoB4A is shorter.

@NickKennedy Yes, of course, thanks! Xian just told me as much… Don't know why I didn't think of it! I guess I was too eager to use Negate.

35 using tsh's method.

APL+WIN, 20 15 bytes
5 bytes saved thanks to Adam.
Prompts for end integer, start integer and then list:
+/,0=⎕∘.|⎕↓0,⍳⎕

Try it online! Courtesy of Dyalog Classic
Could be reduced to 9 bytes if we could enter two lists and not have to generate the first:
+/,0=⎕∘.|⎕

+/+/ → +/,

s+⍳1+⎕-s←⎕ → ⎕↓0,⍳⎕

C++ (clang), 113 110 109 108 106 100 93 99 91 89 bytes
using I=int;I s;void f(I a,I b,I*l,I z,I&s){for(s=0;a<=b;++a)for(I i=z;i--;)s+=a%l[i]<1;}

Try it online!
Saved 3 bytes thanks to @AZTECCO!!!
Saved 6 13 bytes thanks to @bznein!!!
Added 6 Saved 8 bytes thanks to @AZTECCO (and now it's playing by the rules)!!!

You can use #import to save 1

@AZTECCO Thanks, didn't know about #import. :-)

#include is standard.. See https://stackoverflow.com/a/172264/7699953 btw you can save 2 by using  s+=a%i<1; instead of s+=a%i?0:1;

@AZTECCO Ah, good to see Microsoft doing something useful for the code-golfing community. Thanks for the -2! :-)

I am not that familiat to codegolf rules, but is it mandatory to use vector? std::set would save 6 bytes. If we are to allow duplicated entries, std::list is still 102 bytes

@bznein Good point! No, vector isn't mandatory. It's more usual to allow you to input and output as suits you best. Thanks! :-)

If we can choose also output as we wish, can we use int&s as parameter to the function? #import<set> void f(int a,int b,std::set<int>l,int&s){for(;a<=b;++a)for(int i:l)s+=a%i<1;} is 90 bytes.
This will however require us to set s to 0 before calling the function, which might not follow the rules, but even initializing s inside the function leads to 94 bytes:
#import<set> void f(int a,int b,std::set<int>l,int&s){s=0;for(;a<=b;++a)for(int i:l)s+=a%i<1;}

@bznein Ingenious! Totally valid and oft used way to return data from a C++ function, so I'm guessing it's ok?

It's valid : https://codegolf.meta.stackexchange.com/a/4942/84844

@AZTECCO Thanks for the clarification, that's then another way to snip the lettery return!

Yes, anyway I'm not sure but I think you have to include declaration of s ''int s;'' in the bytecount

Sounds like the right thing to do, otherwise you could initialise it outside the byte count too. Still shorter! :-)

Suggestion : if you don't need to use a particular algorithm or many containers, it's better to use plain arrays most of the times. 85+ 6??

Nice! Was using a standard container for the for (int i:l) but this is shorter! :-)

@AZTECCO So many ints! Managed to save 2 bytes using using. :-)

Ruby, 41 bytes
->a,e,l{l.sum{|x|(a..e).count{|r|r%x<1}}}

Try it online!

JavaScript (ES6), 47 bytes
Takes input as (list, start)(end).
(a,x,s=0)=>g=y=>y<x?s:g(y-1,a.map(c=>y%c||s++))

Try it online!

K (oK), 16 bytes
{+//~z!\:x_!1+y}

Try it online!
Explanation:
{+//~z!\:x_!1+y} - function with 3 arguments [x;y;z] <- (start; end; list)
           !1+y  - a list 0 to end (inclusive)
         x_      - drop the first start numbers
     z!\:        - find the modulo of each number in the range start..end with each of list
    ~            - negate (0 becomes 1, non-zero becomes 0)
 +//             - reduce by addition and converge (repeat until result stops changing)

J, 22 bytes
1#.1#.0=[|/(}.i.,])/@]

Try it online!
Explanation:
The verbs (functions) in J can take one (right) or two (left and right) arguments. The left argument is the list, the right one - a list of the start and end numbers.
           (       )/@     insert the verb in () between the elements of
                      ]    the right argument (start and end)
                 ,         append
               i.          a list 0..end-1
                  ]        to the right argument (end)
             }.            drop start elements
          |/               insert modulo verb between the above list and
         [                 the left argument (the list)
       0=                  compare each with 0
    1#.                    sum by base 1 conversion
 1#.                       sum by base 1 conversion
                           (we do it twice, because the result of |/ is a table)

Some explanation would be good

@AZTECCO I added an explanation of the K answer. I'm going to add the J one soon.

Python 2, 54 bytes
f=lambda n,m,l:m/n and sum(n%i<1for i in l)+f(n+1,m,l)

Try it online!

Cool trick using the recursion and division!

APL (Dyalog Extended), 9 bytesSBCS
Full program, prompting for end, start, list, from stdin.
≢⍸=⎕|\⎕…⎕

Try it online!
⎕ prompt for end
⎕… prompt for start and generate progression vector
⎕|\ prompt for **list* and make division remainder table
= Boolean mask indicating where equal to zero
⍸ get the indices of the Trues
≢ tally them

Bash, 40 bytes
eval set !\$[{$1..$2}%{$3}]+;echo $[$*0]

Try it online!

APL(NARS), chars 13, bytes 26
{+/∊0=⍺∣../⍵}

⍺ it is the list of divisors, ⍵ it is the range. Test:
  1 2{+/∊0=⍺∣../⍵}1 10
15
  7 8{+/∊0=⍺∣../⍵}1 800
214
  13 5{+/∊0=⍺∣../⍵}301 5000
1301
  13 5 3 11{+/∊0=⍺∣../⍵}301 5000
3294

Jelly, 7 bytes
r/ḍ@€FS

Try it online!
A dyadic link taking a list of [start, end] as the left argument and the list of possible divisors as the right argument. Returns an integer indicating the total number of possible divisions.

Nice answer! My version was also a 7 byter (tryadic link).

Java (JDK), 115 67 bytes
(s,e,d)->{int t=0;for(;s<=e;s++)for(int j:d)t+=s%j<1?1:0;return t;}

48 bytes saved thanks to Olivier
Try it online!
First time golfing in Java, so this is a new experience for me.

Well, you can declare lambda methods: (s,e,d)->{...}. Also, you can remove spaces and probably use a few golfing tips. Here's my take on golfing your answer.

Icon, 59 bytes
procedure f(a,b,l)
n:=0
(a to b)%!l<1&n+:=1&\z
return n
end

Try it online!

Japt -x, 7 6 bytes
rõ ïvV

Try it
rõ ïvV     :Implicit input of arrays U=[start,end] and V=list
           > e.g., U=[15,18] V=[2,4,3]
r          :Reduce U by
 õ         :  Inclusive range
           > [15,16,17,18]
   ï V     :Cartesian product with V
           > [[15,2],[15,4],[15,3],[16,2],[16,4],[16,3],[17,2],[17,4],[17,3],[18,2],[18,4],[18,3]]
    v      :Reduce each pair by testing the divisibility of the first by the second
           > [0,0,1,1,1,0,0,0,0,1,0,1]
           :Implicit output of sum of resulting array
           > 5

Python  54 bytes
lambda K,M,H:sum(n%l<1for n in range(K,M+1)for l in H)

Welcome to the site! I've edited your answer to fit the standard format, feel free to edit in any explanations, or links to online testing environments such as Try it online!

Kotlin, 69 bytes
{s:Int,e:Int,l:List<Int>->(s..e).toList().sumBy{v->l.count{v%it==0}}}

Try it online!

Husk, 6 bytes
#0×`%…

Try it online! Nothing very special.

Vyxal d, 5 4 bytes
ṡ$vḊ

-1 byte thanks to @lyxal
Try it online!
Explanation:
ṡ     # Range from a to b
 $    # Swap (last input is now on top)
  vḊ  # For each in the range, test for divisibility with the last input
      # Deep flatten and sum with the d flag

Try it Online! for 4 bytes

@lyxal Nice, I suspected there would be a better way to get that last input

Charcoal, 11 bytes
Ｉ⁻Σ÷ηζΣ÷⊖θζ

Try it online! Link is to verbose version of code. Explanation:
    η       Second input (End)
     ζ      Third input (List)
   ÷        Vectorised integer division
  Σ         Sum
         θ  First input (Start)
        ⊖   Decremented
          ζ Third input (List)
       ÷    Vectorised integer division
      Σ     Sum
 ⁻          Subtract
Ｉ           Cast to string
            Implicitly print

Pyth, 15 bytes
/.nm%LdeQ}.*PQ0

Try it online!
Takes input as start, end, list
Explanation:
         }        # Inclusive range
          .*      # Splat (list becomes list of arguments)
            PQ    # All but the last element of the input
                  # --> inclusive range from start to end
   m              # map each number of that
     L eQ         # to a map of each member of Q[-1] = list
    % d           # remainder modulo member (2, 4, 3 in example)
                  # --> List of lists of remainders
 .n               # flatten
/              0  # count zeroes

-5 bytes using multiple inputs and pfns

Perl 5 (-ap), 33 bytes
for$i(<>..<>){$i%$_||$\++for@F}}{

Try it online!

C# (Visual C# Interactive Compiler), 54 bytes
(a,b,l)=>l.Where(x=>a%x<1).Count()+(++a>b?0:f(a,b,l));

Try it online!
Recursive approach

It's recursive, but you don't define f. You should define it like this: f=(a,b,l)=>...

@OlivierGrégoire If it is recursive, you have to include the whole function definition: Func<int,int,IEnumerable<int>,int>f=(a,b,l)=>..., since f=(a,b,l)=>... is not a valid expression (f does not exist yet). However, it would just be shorter to do int f(int a,int b,IEnumerable<int>l)=>...

if you take in int[] instead of IEnumerable<int> you can use Length instead of Count(), removing 1 byte

SimpleTemplate, 86 bytes
Yeah, kinda long, but it works!
Receives 2 numbers (in any order) and an array/string of 1-digit numbers (e.g.: "243"), passed to the render() method of the compiler.
{@fori fromargv.0 toargv.1}{@eachargv.2}{@ifi is multiple_}{@incR}{@/}{@/}{@/}{@echoR}

Displays the result or nothing, if none is

Ungolfed
{@set count 0}
{@for i from argv.0 to argv.1}
    {@each argv.2 as number}
        {@if i is multiple of number}
            {@inc by 1 count}
        {@/}
    {@/}
{@/}
{@echo count}

Should be mostly straightforward.

You can try it on http://sandbox.onlinephpfunctions.com/code/b26cd7f75e0c4676038573c4274180891a890895
Change line 986 to test the golfed and ungolfed versions, and line 988 to get the input.

Mathematica, 52 bytes
f[s_,e_,l_]:=(q=Quotient;Total[q[e,#]-q[s-1,#]&/@l])

This uses the simplification formula from @tsh
A less clever solution at 66 bytes but more directly following the OP:
f[s_,e_,l_]:=Total[Length@Intersection[Divisors@#,l]&/@Range[s,e]]

Excel VBA, 77 Bytes
Immediate window function that takes start from [A1], end from [B1], and list from column C ([C:C]). Output is directed to the immediate window.
[C:C].SpecialCells(2) is used to iterate j over only the cells in Column C which contain a value, as non-valued cells produce an error.
For i=[A1]To[B1]:For Each j In[C:C].SpecialCells(2):s=s-(i/j=i\j):Next j,i:?s


text:
Is this platform game level winnable?
Given a level from a simple platform game, your task is to make a program or function to determine if a level is winnable. Platform game levels are 4 characters tall and any number of characters wide. There is exactly one platform for each horizontal space in a level:
           =======    =
==    =           =
   ===                 =====
  =    ====        ===

The game consists of jumps. Jumps start from the space above the platform which is being jumped from, and end in the space above the platform which is being jumped to (these can be above the 4 platform height levels). To complete a jump, it must be possible to move from the start point to the end point in four or less (including the start/end points) up, down, left, and right moves which do not pass through a platform. Here are some examples (marked with A for start platform and B for end platform):
 >>>
 ^ B
=A
  =

 >>>>
=A  B=

>>
^B
A

Horizontal moves along a platform are just jumps which only move in one direction:
  >>
==AB===

The player would start on the leftmost platform, and wins by standing on the rightmost one (marked with vs):
v  === v
===   ==

Test cases
Winnable:

 ===      ==
=    =====
    =

    ==

=         ==
 ===  ====

   ==== =
===
       =
         ===

  ==  ==  =

=
 =  ==  == =

Unwinnable:
      ======

======

 =======   =
=         =
         =
        =

           =
   =
=     =
 == == ====

Rules
Your program should output one distinct value if a level is winnable, and a different one if it isn't. It can take input in any reasonable form, such as an ASCII art with any two distinct characters, a matrix, or a 2d array.
Code golf, so shortest answer per language wins.

The second test case has a gap -- is that allowed? May we take input column by column?

@xnor The gap is 2 wide, so it is jumpable. You may take input column-by-column.

Why is the last case unwinnable?

@NickKennedy Any jump would be 5 units. Falling is included in the jump limit.

@xnor Oh, oops, there should be some unreachable platforms above for that one. Thanks for pointing that out.

@RedwolfPrograms I see - it was the counting of the start that through me. I was expecting it to involve four moves (right, down, down, down).

There should be a testcase where the player needs to move left to complete the level

Another good pair of test cases would be where platforms alternate between the top and bottom position for a while, and you need to choose the upper or lower path at the start but only one of them gets to the finish.

Is the requirement "which [The moving] do not pass through a platform" really needed? Could anyone provide a testcase which may yield different result when this requirement is removed?

Suggested testcase: $ \begin{bmatrix} &&=&&&=\\=&&&=\&=&&&=\end{bmatrix} $

Suggested testcase: $ \begin{bmatrix} &=&&&=&&&=&&&=\\\=&&=&=&&=&=&&=&=&& \end{bmatrix} $

@tsh Imagine the last winnable testcase, but the first one is at height 3. You'd be able to jump to the one below, except you'd be stopped by the one in front of you.

@tsh The "[moves] which do not pass through a platform" rule can be safely ignored because of the "one platform per column" rule.  You can simply jump on any platform that blocks an otherwise legal jump.  (In the proposed counterexample, the platform in column 3 does not block a jump from column 1 to column 2.)

@Nitrodon But by jumping to the one on level 4 it is impossible to win

@RedwolfPrograms The platform on level 4 doesn't block anything.  In that test case, you would jump from the platform on level 3 (column 1) to the platform on level 1 (column 2).

@Nitrodon But if it were at level 3 the level 4 one would block you, since you'd have to pass through it

Suggests simple test case for block test [[0,0,0,1,0],
[1,1,1,0,0],
[0,0,0,0,0],
[0,0,0,0,1]]

Why is the second unwinnable test case unwinnable? Mario would have no problem with it.

Jelly, 23 22 bytes
ŒṪạþ`§<4NA1¦A»/T$¦ÐLṪṀ

Try it online!
New version, which now efficiently handles moves backwards. Takes input as a boolean matrix (row major). Returns 1 for winnable and 0 for not.
Thanks to @AZTECCO for first suggesting using the indices of platforms, and @tsh for a test case that made me rethink my approach.
Explanation
ŒṪ                     | Multidimensional truthy indices of each
  ạþ`                  | Outer table using absolute difference and with the same argument on both sides:
     §                 | Sum innermost lists
      <4               | - Less than 4
        N              | Negate
         A1¦           | Absolute top row
                  ÐL   | Apply the following until no changes:
            A   $¦     | Absolute the rows indicated by the following:
             »/        | - Max of each column
               T       | - Truthy indices (i.e. where there’s a 1 in the column)
                    Ṫ  | Finally take the last row
                     Ṁ | Max

Step b step
(each matrix shown collapsed as a grid, with - = -1):
1. Input
0010
0001
1000
0010
0001
1000

2.ŒṪ
Multidimensional indices.
[[1, 3], [2, 4], [3, 1], [4, 3], [5, 4], [6, 1]]

3. ạþ`§<4N
Convert to initial outer table with -1 for possible moves between columns and 0 where no move possible.
--0-00
--0--0
00--0-
-----0
0-0--0
00-00-

4. A1¦A»/T$¦ÐL
Absolute first row, then iteratively take each column with at least one 1 in it, and absolute the rows at those indices; results after each iteration shown.
Absolute row 1 ->

110100
--0--0
00--0-
-----0
0-0--0
00-00-

-> Absolute rows 1, 2, 4 ->

110100
110110
00--0-
111110
0-0--0
00-00-

-> Absolute rows 1, 2, 3, 4, 5 ->

110100
110110
001101
111110
010110
00-00-

-> Absolute rows 1, 2, 3, 4, 5, 6 ->

110100
110110
001101
111110
010110
001001

5. ṪṀ
Finally, take the max of the last row
1

My previous 61 byte version has explanation in the edit history; thanks to @JonathanAllan for golfing 3 bytes off that one!

ṙ1¬a4$+Ʋ€1¦ can be replaced with ^I$1¦%7 saving four bytes (so long as it is OK that a 1 below the starting 5 becomes a 0 - which I think it is, right?)

(...edit: a 0 below the starting 5 becomes a 1)

@JonathanAllan Thanks. I originally had something like that, but it means that the player can start by travelling down which isn’t allowed I don’t think it affects the test cases, but might alter edge cases.

Ah, well in that case I«0^Ʋ1¦%7 would save two; there is probably something shorter.

Ah - n⁶Żz0I×-4«Ʋ1¦C saves one more :)

@JonathanAllan thanks. I’ve yet to find a test case where moving down at the start makes a difference. Still, it does mean we’re sticking to the official rules of the challenge re moving through blocks!

@tsh my initial short version didn’t check moves backwards. My new version is more efficient and should find all possible solutions.

JavaScript (ES6),  129  126 bytes
Takes input as a binary matrix. Returns either \$0\$ or \$1\$.
f=(a,x=0,m,d=4,g=d=>k=a.findIndex(r=>r[x+d]))=>!~g(1)|[...'1350531'].some(v=>~g(--d)&&m^(M=m|1<<x+d)&&(k-=g``)*k<v&f(a,x+d,M))

Try it online!
How?
Given the current column \$x\$ and a horizontal jump distance \$dx\$, the helper function \$g\$ returns the 0-indexed row of the platform at column \$x+dx\$, or \$-1\$ if \$x+dx\$ is outside the playfield.
g = d =>             // d = dx
  k =                // save the result in k
    a.findIndex(r => // for each row r in a[]:
      r[x + d]       //   test whether r[x + dx] is truthy
    )                // end of findIndex()

Starting with \$x=0\$, the recursive function \$f\$ attempts to find a way to the last column by trying all valid jumps and keeping track of visited columns.
f = (                // f is a recursive function taking:
  a,                 //   a[] = input matrix
  x = 0,             //   x = current column
  m,                 //   m = bit-mask of visited columns
  d = 4,             //   d = dx
  g = …              //   g = helper function (see above)
) =>                 //
  !~g(1) |           // success if g(1) is equal to -1
  [...'1350531']     // list of exclusive upper bounds for dy²
                     // corresponding to dx = +3, +2, +1, 0, -1, -2, -3
  .some(v =>         // for each upper bound v:
    ~g(--d) &&       //   decrement d; success if g(d) is not equal to -1
    m ^ (            //   AND m is different from
      M = m |        //     the new bit-mask M
          1 << x + d //     where the bit corresponding to x + d is set
    ) &&             //   AND
    (k -= g``) * k   //   dy² = (g(d) - g(0))²
    < v &            //   is less than v
    f(a, x + d, M)   //   AND a recursive call at the new position is also true
  )                  // end of some()

It is possible that you'll need to move left at some point to win the level.  This solution does not account for that.

@Nitrodon Thanks for reporting this. Now fixed.

Japt, 42 bytes
Õcð í
o
v
à cá ®pV uWÃd_äÈcY ó x_raÃ<4 Ãr*

Try it
Test 1
Test 2
Test 3
Temporarily fixed by using permutations to allow backwards jumps (really inefficient) , going to try @Nick Kennedy solution soon.
z cð í  // get each column height and pair with column index
o       // save end position and remove from array
v       // same for start pos

à  cá        // combinations of permutations
  ®pV uWÃ  // restore end and start

d          // return true if any returns true to..
 _  ...  Ãr* // reduce result
  ä          // pass each consecutive x,y
   ÈcY ó     // 'reshape~transpose' => [ platform pair, index pair]
         x_raÃ // sum of absolute difference of each pair
               <4 // return if less for each pair

Saved 2 thanks to @Embodiment of Ignorance
Japt -Q, 76 bytes
Õcð í ïÈcY ó x_raÃ<4Ã®*JÃòUÎl
g0_ma
@T=Uc x UgUy_x_>0}Ãð _maÃT¥Uc x}a
o x >0

Try it
Translation of   Jelly answer  of @Nick Kennedy , a lot more efficient but longer , I think it can be shortened.
Explanation / translation Jelly => Japt (taken from Nick answer)
ŒṪ  => Õcð í        M ultidimensional truthy indices of each
ạþ` => ïÈcY  òUÎl   O uter table using absolute difference and with the same argument on both sides:
§   => ó x_ra       Sum innermost lists
<4  => Ã<4Ã         Less than 4
N   => ®*JÃ         Negate
A1¦ => g0_ma        Absolute top row
ÐL  => @T=Uc x...T¥Uc x}a     Apply the following until no changes:
   On my side I used T to store the total of the whole matrix to check if it changed because g() modify the original matrix.

A $¦ => Ug..._maÃ   Absolute the rows indicated by the following:
»/   => Uy_x_>0}    Max of each column :
   on my side I rotated the table and reduced to get the positive rows
T    => Ãð          Truthy indices (i.e. where there’s a 1 in the column)
Ṫ    => o           Finally take the last row
Ṁ    => x >0        Max : on my side >0

z  -> Õ -1 byte

®raÃx <4 -> x_raÃ<4 -1 byte\

I think this fails @tsh test case: https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1WPwIO0Kbwp2CuAgrnBWIHVXw2Rf5MhjWSDzIHhfcmHDPDQgw3Iq&input=WwoKW1swLDAsMSwwLDAsMV0sCiBbMCwwLDAsMCwwLDBdLAogWzEsMCwwLDEsMCwwXSwKIFswLDEsMCwwLDEsMF1dCgpdCi1t Your current solution doesn’t allow for moving backwards which is sometimes needed

@Nick Kennedy now I see.. It has to jump backwards to reach higher blocks.. I try to fix it ASAP! thank you

@AZTECCO I don’t know any Japt, but I expect my approach in Jelly could be translated. I build a table of which columns can reach which, and then iteratively extend paths from the first row.

Thank you @Nick Kennedy , for now I'm managing to fix it using combinations of permutations, although it works it is really inefficient, as I have a moment I surely try to translate your solution which is really interesting

@AZTECCO - I tried permutations too. It was fine for the 6 column case, but timed out for the larger cases on TIO

@Nick Kennedy I finally translated your solution! A bit longer though

@AZTECCO looks good. Interesting to see the side-by-side translation too.

@Nick Kennedy thanks! Idk if it's useful but I loved the idea to compare two different languages, btw did you seen I created a Jelly to Japt chat room ? I tried to ping you , I'm wondering if I should extend it to every language.. If you have a bit of time to look at an give some suggestions.. https://chat.stackexchange.com/rooms/101829/jelly-to-japt

@AZTECCO nice idea. Sorry I’d not seen it - I think putting the space in my name may have confused the way it picks up usernames.

R, 137 136 bytes
function(a,e=abs(outer(b<-which(a,T),b,`-`)),g=-(e[,1,,1]+e[,2,,2]<4),h=1){while(any(g<{g[h,]=abs(g[h,]);g}))h=colSums(g>0)>0;rev(g)[1]}

Try it online!
Essentially an R translation of my Jelly answer, but with some R golfs to take advantage of the way outer works on arrays. A function that takes as its argument a logical matrix with the rows corresponding to the rows of the original question. Returns 1 for winnable and -1 for non-winnable.

Python 3, 198 bytes
A messy solution with NumPy, takes a list of strings as input:
w=lambda l:t(g(array(where((array(list(map(list,l)))=='=').T)).T))
from numpy import*
g=lambda p:abs(p[:,None]-p).sum(2)<4
t=lambda m,x=0:x+1==len(m)or max([t(m,p)for p in where(m[x])[0]if p>x]+[0])

Try it online!
This assumes that no levels exist for which the bolded part here is of importance:

To complete a jump, it must be possible to move from the start point to the end point in four or less (including the start/end points) up, down, left, and right moves which do not pass through a platform.

I have been unable to imagine such a level and none are given as a test case. Likewise I can't imagine a level that requires a leftwards move so an appropriate test case there would be welcome also, if I'm mistaken. Thanks to Nitrodon for pointing me in the right direciton.
Python 3, 214 bytes
lambda l:t(g(array(where((array(list(map(list,l)))=='=').T)).T),[])
from numpy import*
g=lambda p:abs(p[:,None]-p).sum(2)<4
t=lambda m,v,x=0:x+1==len(m)or max([t(m,v+[x],p)for p in where(m[x])[0]if x not in v]+[0])

Try it online!
A solution that incorporates leftwards movement, with tsh's test cases included. This cost quite a few bytes, I'll have to sleep on it to golf it more.

A 2 up, 1 left move can be useful to reach a higher level.  The six-column test case posted by tsh in a comment is an example where this is required.

I see it now, thanks!