text:
Write the longest period iterating quine bounded by 500 bytes
Your job is to create the longest period iterating quine, where the length of each program in the sequence is bounded by 500 bytes.
That is, if you repeat the following steps:

Start with your initial program
Run the current program
Go back to step 2

You will eventually get back to your original program. The number of programs in the cycle is your score, which you are trying to maximize.
None of the programs may raise any errors. Each program must be run the same way as well (e.g. no different versions, implementations, compiler options, platforms, etc...) (EDIT: Yes, any external state such as that of a pseudo random number generator was included in the last statement. The external state must be "reset" after each run. If you use true random numbers, worst case is assumed.)
What separates this challenge from The longest period iterating quine (other than 100 v.s. 500) is that every program in the cycle must also be 500 bytes or less. This means that the longest possible cycle is (256^501 - 1)/255 or less. That of course is a big number, but not that big in terms of how much code it takes to calculate. So the challenge is about using as many of the (256^501 - 1)/255 possibilities as you can, not a busy beaver challenge.
The programs are not permitted to access its own source code. However an empty program is permitted if you want (as long as you follow the other rules).
Since checking the programs manually would be hard, you may figure out the score using theoretical methods. You must include an explanation of the score and correctness with your program. If you can not figure out the score, you may instead use a lower bound of the number of programs in the cycle as a defacto score. You are allowed to update this as you find better lower bounds, or if you find the exact actual score.
This is code-challenge, so highest score wins!
EDIT: It is recommended that you write what your score is in scientific notation, so that answers are more easily comparable. It is perfectly fine to have other forms of the score as well, especially if they are connected to your program more clearly. Also, readers are encouraged to edit previous answers to comply with this.

"the longest possible cycle is (256^501 - 1)/255 or less" --- this isn't necessarily true, the program may pass through the same state multiple times before returning to the original if it manipulates an external object (such as the RNG state or seed)

I attempted to write one in Python that cycles through every possible sequence of bytes of a certain length, using try and tokenize to skip the ones that can't be parsed as a string. Since the source is unicode, this should result in a greater cycle length than if it simply excluded bytes 34 and 92 (ASCII " and \ ). However, this turned out to be quite involved - I've officially given up on it for now, so I'm posting the idea in case someone else wants to try it.

@JDL that should be against the rules, IMHO - if it stores state elsewhere than in the source code, then it's not an a proper iterating quine.

@Nathaniel I wouldn't categorise it as storing state elsewhere, it is simply using entry points which are a valid part of the programming language it's implemented in. Arguably, anything which calls another function in the programming language is accessing states which are held outside its own source code.

@JDL no, those are different things. Any program in any language obviously has to rely on things that are implemented outside the source code, but storing state outside the source code is different. That would mean the output of the program is not a deterministic function of its source code, but instead depends on some other external context that has been changed by previous runs. That should not be allowed in a quine challenge, IMHO, and the OP's statement about the maximum cycle length indicates that it was intended to be disallowed here.

@Nathaniel, I disagree. (Your suggestion would also disqualify any language in which the instruction pointer has not just a location but a direction, such as lost as using your definition the instruction pointer stores state.) For example, a 5-state program that iterates 2-1-3-1-4-1-5-1-2-1-3-1-4-1-5-1 ... has a period of 8 despite using only five symbols and such a program is certainly possible, even as a quine.

Have posted a straw-man example using a made-up language to elicit other comments on this topic.

@JDL as I'm certain you're aware, in a deterministic language the instruction pointer only stores state during the execution of a program, and not between invocations of it. Your 5-state example isn't possible if the program's output is a deterministic function of its source.

@Nathaniel, see my "five-eight" example below. It is certainly possible. The key features of the language that make it possible are that commands are interpreted differently (but nonrandomly) based on the command history to date, and the the instruction pointer has some "momentum" so that the state-space is, in effect, larger than the number of characters.

@JDL One of the conditions is you have to run all the programs the same way. This includes external state.

Reading the source is not allowed, but are we allowed to access the memory location the program resides in?

@Rogem If you don't read the source, I suppose so. Also keep in mind that the external state must be the same for every invocation.

If each program must be run in the exact same way, may we specify that each program must be given a specific input?

@EmbodimentofIgnorance No, since code could be stored in the input.

Perl 6, \$126^{398} \approx 8.86 \times 10^{835}\$ iterations
$!=Q~~;<say "\$!=Q~{chrs(my@a=[R,] polymod :126[$!.ords]+1: 126 xx*)x?(@a-399)}~;<$_>~~.EVAL">~~.EVAL

Try it online!
This iterates through all the possible combinations of the first 126 bytes of length 398 and under (excluding strings with leading NUL bytes). If you want to see that it actually returns to the first iteration, you can reduce the length to 1 by changing the limit like so.
Explanation:
Each iteration increments the string, stored in base 126 form, and then converts it back to base 126. It does this until it reaches a string with length 399, and then resets the string back to empty again. If you're having trouble conceptualising the number, imagine it with ten bytes instead. Starting from 0, increment up to 4 digits, 1000 and reset. This is \$10^{4-1}\$ iterations (including 0 or empty string in my program's case).
$!=Q~~;         # Start with an empty string
< ... >~~.EVAL  # Set a string to $_ and EVAL it
  say "\$!=Q~{...}~;<$_>~~.EVAL"   # Print the program with the string replaced by
                       :126[$!.ords]   # The string converted from base 126
                                    +1 # Incremented
          [R,] polymod                : 126 xx*  # Back to base 126
chrs(                                )  # Back to a string
     my@a=                            x?(@a-399)  # Only if it isn't 399 characters

Wow, you did that really fast, I'm almost done with mine, but I'll probably be finishing it tomorrow (mine is going to be in Gol><>)

This calculation suggests that you way over estimated your score. The numerator is how many strings of length 397 there are using 126 symbols. (I had to distribute the fraction into the sum since wolfram alpha was acting weird.)

@PyRulez I think my number is correct, since it's basically iterating a base 126 number up to 399 digits... I think my explanation was off

@JoKing ah yes, I think the explanation was the problem. You changed 397 to 398, which makes your score no longer an overestimate. You might be underestimating it (since you only included strings of length exactly 398 in the score), but that's fine.

Runic Enchantments, 64654106; 122387-1 ≈ 2.638 × 10807 iterations
"3X4+kSq'ƃZ,r{1?{1[:1Z%1+:a=+:d=+:3X4+=+:6X2+=+:'€(c*?~1-1kq}͍f1+0Bl1=6*?S1-Skql͗2=4*?{͍]}B͍l1=6*?kS1-Sq]}@

Try it online!
Alert: The € is incorrectly displayed, it should be `` (0x80).
Rather than the stack, use a string and the stack operators modified with ͍ to modify a string rather than the stack (see prior revision). As such, each char is limited to 1 byte (0-127 range, minus the problematic characters), but with over 3 times as many of them (due to there being less processing boilerplate due to not having to skip Unicode combining characters, as well as some other byte savings) it achieves a higher number of iterations.
If encoding as a true big endian is allowed (that is, having byte values above 127 without interjecting 0x00 bytes) this can achieve 251387-1 ≈ 4.717 × 10928 iterations. However, TIO's Latin encoding prevents this as noted by Erik the Outgolfer in his Python 2 answer. I would need to check if it works locally before claiming this score.
Should be able to replace f1+0B with '0B (there's an unprinting 0x16 there), but it was fighting me (things didn't want to branch/skip/return correctly), so I left it alone. This would raise the big-endian structure from 387 to 388.

C# (Visual C# Interactive Compiler), flags: /u:System.Numerics.BigInteger and /r:System.Numerics
Score: 10332
Thanks to JoKing who increased my score from 10255 * 2 - 1 to now!
var i=Parse("0");var s="var i=Parse({0}{2}{0});var s={0}{1}{0};Write(s,(char)34,s,(++i).ToString().Length<333?i:0);";Write(s,(char)34,s,(++i).ToString().Length<333?i:0);

Try it online!
Explanation
Increments a BigInteger every iteration, until it's length becomes too large, which in that case we instantly revert back to the original quine.
//The BigInteger that will be incremented
var i=Parse("0");
//The string that encodes the quine
var s="var i=Parse({0}{2}{0});var s={0}{1}{0};Write(s,(char)34,s,(++i).ToString().Length<333?i:0);";
//Print out the string, with every {0} replaced with quotes and the {1} replaced with the original string
Write(s,(char)34,s,
//And the {2} is replaced to the BigInteger+1 if the BigInteger wouldn't be too long, else 0
(++i).ToString().Length<333?i:0);

DOS COM, 49 bytes, period 2^3608
00000000  be 31 01 89 f7 b9 f4 02  f9 ac 14 00 aa 39 ce 72  |.1...........9.r|
00000010  f8 31 c9 b4 3c ba 2b 01  cd 21 89 c3 b4 40 b9 f4  |.1..<.+..!...@..|
00000020  01 ba 00 01 cd 21 b4 3e  cd 21 c3 71 2e 63 6f 6d  |.....!.>.!.q.com|
00000030  00                                                |.|

Original assembly to create:
 BITS 16
 ORG 0100h
   mov si, l
   mov di, si
   mov cx, 500 + 0100h
   stc
n: lodsb
   adc al, 0
   stosb
   cmp si, cx
   jb n
   xor cx, cx
   mov ah, 3ch
   mov dx, f
   int 21h
   mov bx, ax
   mov ah, 40h
   mov cx, 500
   mov dx, 0100h
   int 21h
   mov ah, 3eh
   int 21h
   ret
f: db "q.com", 0
l: db 0

This little jewel writes the next phase to q.com rather than standard output because of nulls and other stuff the terminal cannot handle. The root quine technique is equivalent to stringification and the payload room is used as a 3608 bit counter. Due to the way DOS works, the initial state of the counter contains debris from whatever was in memory prior to its first execution.
The original 49 byte input is unreachable, so if you want to score this as 500 bytes go ahead.

Clean, \$251^{226} \approx 2.1 \times 10^{542}\$

25139 removed dependency on Text
251122 golfed incrementing function
251128 combined prefix and suffix source strings
251188 removed dependency on Gast.GenLibTest

Presented in xxd format due to nonprintables / invalid UTF-8:
00000000: 6d6f 6475 6c65 2071 3b69 6d70 6f72 7420  module q;import
00000010: 5374 6445 6e76 3b53 7461 7274 3d28 7325  StdEnv;Start=(s%
00000020: 2830 2c34 3129 2c3f 5b27 0101 0101 0101  (0,41),?['......
00000030: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000040: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000050: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000060: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000070: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000080: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000090: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000a0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000b0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000c0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000d0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000e0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000f0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000100: 0101 0101 0101 0101 0101 0101 275d 2c73  ............'],s
00000110: 2528 3432 2c39 3939 292c 712c 732c 7129  %(42,999),q,s,q)
00000120: 3b71 3d69 6e63 2721 273b 3f5b 683a 745d  ;q=inc'!';?[h:t]
00000130: 2363 3d68 2b69 6628 616e 7928 283d 3d29  #c=h+if(any((==)
00000140: 6829 5b27 ff09 0c26 5b27 5d29 2702 2727  h)['...&['])'.''
00000150: 0127 3d5b 633a 6966 2863 3e68 2969 643f  .'=[c:if(c>h)id?
00000160: 745d 3b3f 653d 653b 733d 226d 6f64 756c  t];?e=e;s="modul
00000170: 6520 713b 696d 706f 7274 2053 7464 456e  e q;import StdEn
00000180: 763b 5374 6172 743d 2873 2528 302c 3431  v;Start=(s%(0,41
00000190: 292c 3f5b 2727 5d2c 7325 2834 322c 3939  ),?[''],s%(42,99
000001a0: 3929 2c71 2c73 2c71 293b 713d 696e 6327  9),q,s,q);q=inc'
000001b0: 2127 3b3f 5b68 3a74 5d23 633d 682b 6966  !';?[h:t]#c=h+if
000001c0: 2861 6e79 2828 3d3d 2968 295b 27ff 090c  (any((==)h)['...
000001d0: 265b 275d 2927 0227 2701 273d 5b63 3a69  &['])'.''.'=[c:i
000001e0: 6628 633e 6829 6964 3f74 5d3b 3f65 3d65  f(c>h)id?t];?e=e
000001f0: 3b73 3d22                                ;s="

Try it online!
Increments a 226-byte string through all byte values excluding \0, \n, \r, ' and \.
The reason we avoid these characters is:

\0 makes the compiler angry
\n and \r can't appear in charlists
' would end the charlist
\ could cause problems if it comes before an escapable character

Once the string is all \377s it wraps around to all \001s, giving the original program.

The output (at least on TIO) is the character with ordinal value 128, but composed of the two bytes C2 80. Is this the same as the behaviour on your local machine?

@JoKing Oh, no, I get a single byte on my machine. TIO mangles output when it isn't valid UTF-8 (and input files too).

@JoKing I've changed the answer to a new format which makes it possible to see the correct behaviour on TIO.

Python 2, 500 bytes, \$252^{219}\$
#coding=L1
s=""""""
for i in range(220-len(s.lstrip("ÿ")))[:219]:s=s[:i]+chr(ord(s[i])%255-~(s[i]in"!$&"))+s[i+1:]
S='#coding=L1\ns="""%s"""\nfor i in range(220-len(s.lstrip("\xff")))[:219]:s=s[:i]+chr(ord(s[i])%%%%255-~(s[i]in"!$&"))+s[i+1:]\nS=%%r;print S%%%%s%%%%S';print S%s%S

Note that there is a trailing newline. It might get removed above if the syntax highlighter forces its way in.
Unfortunately, you can't execute this program in TIO, as it's encoded in Latin-1.
Above, s contains 219 0x01 bytes. After the program runs, its source is printed, except for one difference: s has been incremented like a base-252 big-endian number, so its leftmost character has been "incremented" to 0x02. The bytes 0x00, 0x22, 0x25 and 0x5C are avoided, so, if any character of the string becomes one of those after the incrementation, the character itself is incremented again.

0x00 (null): A Python source file can't contain null characters.
0x22 ("): There's a danger of three 0x22 bytes forming in a row, that is, """, or the last character of the string becoming ", so the string would be closed prematurely.
0x25 (%): printf-like string formatting is used before completion of the quine skeleton, so a % not adjacent to another % in s will cause trouble. Unfortunately, it's not possible to reorder the formatting to avoid this caveat.
0x5C (\): There's a possibility that the \ is used as an escape mark in the string, instead of verbatim, so it's avoided.

Therefore, 252 out of 256 bytes are usable. If s contains 219 0xFF (ÿ) bytes, it's simply reverted to 219 0x01 bytes, hence completing the cycle.
Given the above, we have \$252^{219}\$ possible strings, hence as many programs overall.
\$252^{219}=8067118401622543607173815381864126969021321378412714150085501148172\\081568355283332551767558738710128769977220628694979838777041634307806013053\\042518663967641130129748108465109552157004184441957823830340121790768004370\\530578658229253323149648902557120331892465175873053680188287802536817909195\\292338112618632542000472094347226540339409672851252596442228662174845397731\\175044304251123874046626291460659909127172435776359148724655575878680270692\\451120531744950544969860952702932354413767504109600742385916705785109741289\\800204288\$

Python 2, 57 bytes, 16444 ≈ 4.258 \$\times\$ 10534 iterations
-1 byte and \$\times\$16 iterations thanks to @AndersKaseorg
b=0x0;s="print'b=%#x;s=%r;exec s'%(-~b%4**888,s)";exec s

Increments a hexadecimal counter on each iteration and when it reaches \$16^{444}\$ it resets to \$0\$
Try it online!

0x%x → %#x frees a byte.

Gol><>, 70 bytes, 39039000 iterations
":1=l8:*6+=S&Q~:'~'=Q~~'H#'||lPaa*5*=?1:1=Q$~$~|:1)lPaa*5*(Q?:|r2ssH##

Wow, that is a lot lower than I thought it would be... Next step! Making it have more iterations!!!
Try it online!

it doesn't seem to delete anything once it reaches 500, just appends a NUL byte

Does this even work at all? I can't get the "increment the last char" to work

@ASCII-only Now this works, sorry about before, I had messed up a section while working on fixing the whole thing. It works now, sorry for the inconvenience!!!

@JoKing The NUL byte is the deleting process, now the program should delete until it is almost gone, then delete the NUL and increment the last char, if it is a ~, then it will be converted to a '#', returning back to normal!!!

Python 3.8 (pre-release), 500 bytes, 221290 ≈ 7.477 \$\times\$ 10679
#coding=L1
c=r"##################################################################################################################################################################################################################################################################################################|";exec(s:='from itertools import*;print("#coding=L1\\nc=r\\"%s|\\";exec(s:=%r)"%([*filter(c[:-1].__lt__,map("".join,combinations_with_replacement(map(chr,range(35,256)),290))),"#"*290][0],s))')

Try it online!
Try a smaller version online!
Python 3.8 (pre-release), 500 bytes, 93314 ≈ 1.269 \$\times\$ 10618
c=r"##########################################################################################################################################################################################################################################################################################################################|";exec(s:='from itertools import*;print("c=r\\"%s|\\";exec(s:=%r)"%([*filter(c[:-1].__lt__,map("".join,combinations_with_replacement(map(chr,range(35,128)),314))),"#"*314][0],s))')

Ascii version
Try it online!
Try a smaller version online!
Explanation
The value assigned to c iterates through all possible strings of length 290 (314 in the ascii version) formed from the characters in the range \x23 to \xff (\x23 to \x7f in the ascii version)
Since the string assigned to c is prefixed with a r backslashes in the string are not treated as the beginning of escape sequences, this allows the use of backslashes inside the string assigned to c without causing problems.
Since a string like r'\' still cause problems a | is added to the end of the string assigned to c.

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


text:
Print "beep boop bop" using complicated methods
This challenge is pretty simple: you need to alert / print / show to the user the text "beep boop bop" (or "beep\nboop\nbop", with newlines), but it needs to be obfuscated. (where you couldn't see anything saying "beep", "boop", or "bop"). Points are calculated where your point value is in characters (not bytes)

i don't see the pointvin overriding the community consensus on scoring solutions based on bytes rather than characters. Also note that [tag:obfuscation] is not an objective criterion, however, if you specifically mean that the strings beep, boop and bop cannot appear in the source, then that is fine (though a little boring)

Bash, 16 bytes
echo b{ee,oo,o}p

Perl 6, 21 bytes
put <bee boo bo>X~'p'

Try it online!
Prints all the words on one line by joining all the prefixes with the last letter p

source: Stack Exchange

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

sort: votes


text:
Password Bishop Goodness
Derived from this, now deleted, post.
Given a string, answer (truthy/falsy or two consistent values) if it constitutes a good Bishop password, which is when all the following conditions are met:

it has at least 10 characters
it has at least 3 digits ([0-9])
it is not a palindrome (identical to itself when reversed)

You get 0 bytes bonus if your code is a good Bishop password.
Warning: Do not use Bishop goodness as a measure of actual password strength!
Examples
Good Bishop passwords
PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3
Not Good Bishop passwords
PPCG123 (too short)
correct horse battery staple (not enough digits)
PPCG121GCPP (palindrome)
 (too short and not enough digits)
abc121cba (too short and palindrome)
aaaaaaaaaaaa (palindrome and not enough digits)
abc99cba (everything wrong)

@KrystosTheOverlord The term is defined in this challenge itself. ;-P

Aw, I was expecting some chess logic password rules…

I read through all the answers and not one claimed the bonus.

"You get 0 bytes bonus if your code is a good Bishop password" — this confuses me. Is it a real bonus or not?

@JDL you really get to substract 0 bytes from your score if you qualify for this very real bonus! What are you waiting for?

surely it would be far harder to write a legitimate solution that wasn't a good Bishop password (though I suppose you could add a comment at the end to make it into a palindrome)

One of your criteria is actually the reverse of what Bishop (2013) proposed. He proposed that passwords must be 10 characters or less, not more.

Are you telling me correct horse battery staple is not a good password? /s

Python 2, 61 59 54 51 bytes
lambda s:sum(map(str.isdigit,s))>2<s[:9]<s<>s[::-1]

Try it online!
-5 bytes, thanks to Erik the Outgolfer

-3 bytes, thanks to xnor

Choo choo!

@EriktheOutgolfer Thanks:)

You can do the length check as s[:9]<s, which combines well with the non-palindrome check: s[:9]<s!=s[::-1]

Japt, 17 14 bytes
Ê¨A&U¦Ô&3§Uè\d

-3 bytes rearranged by @Shaggy
Try it online!

Japt,  15 bytes (0 Bytes Bonus :v)
Ê¨10&U¦Ô&3§Uè\d

Try it online!

Dang! Should've checked the solutions before starting my own! 14 bytes

05AB1E, 12 bytes
gT@Iþg3@IÂÊP

Try it online or verify all test cases.
Explanation:
g      # Get the length of the (implicit) input
 T@    # Check if this length >= 10
Iþ     # Get the input and only leave the digits
  g    # Then get the length (amount of digits)
   3@  # And check if the amount of digits >= 3
IÂ     # Get the input and the input reversed
  Ê    # Check if they are not equal (so not a palindrome)
P      # Check if all three above are truthy (and output implicitly)

R, 80 70 62 64 63 bytes
any(rev(U<-utf8ToInt(scan(,'')))<U)&sum(U>47&U<58)>2&sum(U|1)>9

Try it online!
From digEmAll, and some rearranging too
sum((s<-el(strsplit(scan(,''),"")))%in%0:9)>2&!all(s==rev(s))&s[10]>''

Try it online!
Pretty straightforward, no real amazing tricks here. After user inputs string:

Separates and searches the string for more than 2 numbers. (3 or more digits)
Checks if not all elements are equal to the reversed version of the string (palindrome)
Checks that length is greater than 9 (10 or more characters)

I think you can replace !all(s==rev(s)) with any(s!=rev(s)) which will save one byte. I feel like the length check can be reduced too, but not sure how (either nchar or some kind of sum(x|1) hack)

actually, I think any(s>rev(s)) will work --- if a character is less than its palindromic counterpart, then at the other end of the password the converse will be true. That saves another byte.

can use grepl() instead of grep()|1 to save 1 byte, or better use ()%in%0:9

instead of length(s)>9 you could use s[10]>''. it will return TRUE if there is a tenth element, and NA (which is falsy) if there is no tenth element.

62 bytes using utf8ToInt

@digEmAll your example returns true when there is only one number, you will need to include a >2

@AaronHayman: you're right, I should have erroneously deleted it

64 but correct ;)

You can still get it to 61 using U[10]>0 instead of sum(U|1)>9, but maybe returning NA instead of FALSE is ugly

@AaronHayman: the problem is not returning NA, but that sometime it will return FALSE and sometime NA, depending on the condition not met. As far as I know one can return any thruthy/falsy value as long as they're consistent

63 with some rearrangement

Brachylog, 18 12 bytes
Thanks for the tips, Kroppeb and Fatalize!
¬↔?l>9&ịˢl>2

Try it online!
Explanation
The program is a single predicate, composed of two parts that are chained with &.
First:
¬       The following assertion must fail:
 ↔        The input reversed
  ?       can be unified with the input
        Also, the input's
   l    length
    >9  must be greater than 9

Second:
 ˢ     Get all outputs from applying the following to each character in the input:
ị        Convert to number
       This gives an integer for a digit character and fails for a non-digit, so
       we now have a list containing one integer for each digit in the password
  l    Its length
   >2  must be greater than 2

{∋.∈Ị∧}ᶜ can be {∋ị}ᶜ

Putting the "not palindrome" clause first, and changing the way to select digits, you can save 6 bytes: ¬↔?l>9&ịˢl>2

@Kroppeb Oh, interesting! I didn't consider ị, but it makes sense that it would succeed iff the character is a digit. Thanks!

@Fatalize Aha--reusing the ? like that is neat. Thanks!

APL+WIN, 36, 30 29 bytes
7 bytes saved thank to Adám
Index origin = 0
Prompts for input string
(10≤⍴v)×(3≤+/v∊∊⍕¨⍳10)>v≡⌽v←⎕

Try it online! Courtesy of Dyalog Classic
Explanation:
(10≤⍴v) Length test pass 1 fail 0

(3≤+/v∊∊⍕¨⍳10) Number of digits test

>v≡⌽v Palindrome test

The code also qualifies for the bonus as it is a good Bishop password.

@Adám. Thanks for saving 6 bytes. On ⎕IO agreed. v≡⌽v works fine if I prepend ~. As to use of x I tend to use it when stringing together boolean tests. Same result same number of bytes.

Do you have ≢ which is ~…≡? And even if you don't, you can merge ×~ into >

@Adám No I do not have ≢. I can merge ×~ into > for one more byte. Thanks. I am afraid my "putting game" still needs more practice ;)

Racket, 122 bytes
(define(d s)(let([t(string->list s)])(and(< 2(length(filter char-numeric? t)))(< 9(length t))(not(equal? t(reverse t))))))

Try it online!

APL (Dyalog Unicode), 25 bytesSBCS
{∧/(9<≢⍵)(3≤+/⍵∊⎕D),⍵≢⌽⍵}

Try it online!

Good. Now you can golf it by making it into a train: (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽ and then save one more byte by rearranging to avoid parens: (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕D Let em know if you need explanation of these steps.

Jelly, 12 bytes
~Tṫ3ȧL9<Ɗ>ṚƑ

Try it online!
[] if not enough digits (empty list, falsy), 0 if otherwise bad (zero, falsy), 1 if good (nonzero, truthy).

Java 8, 92 bytes
s->s.length()>9&s.replaceAll("\\D","").length()>2&!s.contains(new StringBuffer(s).reverse())

Try it online.
Explanation:
s->                        // Method with String parameter and boolean return-type
  s.length()>9             //  Check if the length of the input-String is more than 9
  &s.replaceAll("\\D","")  //  AND: remove all non-digits from the input-String
    .length()>2            //       and check if the amount of digits is more than 2
  &!s.contains(new StringBuffer(s).reverse())
                           //  AND: check if the input-String does NOT have the reversed
                           //       input-String as substring (and thus is not a palindrome)

JavaScript, 60 56 46 bytes
Takes input as an array of characters. Outputs 1 for truthy and 0 for falsey.
s=>/(\d.*){3}/.test(s[9]&&s)&s+``!=s.reverse()

Try It Online!
Saved 10 bytes(!) thanks to Arnauld.

Perl 6, 32 bytes
{$_ ne.flip&&m:g/\d/>2&&.comb>9}

Try it online!
Anonymous code block that simply enforces that all the rules are complied with.
Explanation:
{          &&         &&       }  # Anonymous code block
 $_ ne.flip                       # Input is not equal to its reverse
             m:g/\d/>2            # There are more than two digits
                        .comb>9   # There are more than 9 characters

Red, 117 111 bytes
func[s][d: charset"0123456789"n: 0 parse s[any[d(n: n + 1)|
skip]]all[n > 2 9 < length? s s <> reverse copy s]]

Try it online!

Perl 5 -p, 33 bytes
$_=/.{10}/&y/0-9//>2&reverse ne$_

TIO

K (oK), 31 28 bytes
-3 bytes thanks to ngn!
{(x~|x)<(2<#x^x^/$!10)*9<#x}

Try it online!

you could use +// (sum until convergence) instead of +/+/ (sum sum)

alternatively, you could use x^x^y to find the intersection between two lists: #x^x^,/!10. this can be shortened to #x^x^/!10 (^ is "without", x^/... is ^-reduction with initial value x)

one more thing, > (or <) can be used as "and not": {(x~|x)<(2<#x^x^/$!10)*9<#x}

@ngn Thank you! Nice way to find the intersection!

Clean, 66 bytes
import StdEnv
$s=s<>reverse s&&s%(0,8)<s&&sum[1\\c<-s|isDigit c]>2

Try it online!

s<>reverse s: s is not a palindrome
s%%(0,8)<s: the first 9 characters of s are less than all of s
sum[1\\c<-s|isDigit c]>2: s has more than two digits

Retina 0.8.2, 40 bytes
G`.{10}
G`(\d.*){3}
+`^(.)(.*)\1$
$2
^..

Try it online! Link includes test cases. Explanation:
G`.{10}

Checks for at least 10 characters.
G`(\d.*){3}

Checks for at least 3 digits.
+`^(.)(.*)\1$
$2

Remove the first and last character if they match.
^..

If there are at least 2 characters then it wasn't a palindrome.
.NET's balancing groups mean that this can be done in a single regular expression, but that takes 47 bytes:
^(?!(.)*.?(?<-1>\1)*$(?(1).))(?=.{10})(.*\d){3}

Try it online! Link includes test cases.

Python 3, 74 72 64 bytes
Thanks Neil A. for -2 bytes!
Thanks Jo King for -8 bytes!

lambda s:s[9:]and re.findall('\d',s)[2:]and s[::-1]!=s
import re

Explanation:
lambda s: # Create lambda
           s[9:] # Check if the string is at least 10 characters long
                     and re.findall('\d',s)[2:] #Check for at least 3 matches of the regex \d (which matches all digits)
                     and s[::-1] != s # Check if the string reversed is equal to the string (palindrome test)
import re  # Import regex module

Try it online!

-2 bytes by shifting the parentheses around

Pyth, 17 bytes
&&<2l@`MTQ<9lQ!_I

Try it online here, or verify all the test cases at once here.
&&<2l@`MTQ<9lQ!_IQ   Implicit: Q=eval(input()), T=10
                     Trailing Q inferred
      `MT            [0-10), as strings
     @   Q           Take characters from input which are in the above
    l                Length
  <2                 Is the above greater than 2?
            lQ       Length of Q
          <9         Is the above greater than 9?
               _IQ   Is Q unchanged after reversal?
              !      Logical NOT
&&                   Logical AND the three results together

Groovy, (47 bytes)
{p->p=~/.{10}/&&p=~/(\d.*){3}/&&p!=p.reverse()}

(Bonus inclusion is left as an exercise to the reader)

JavaScript (Node.js), 70 bytes
a=>a.length>9&(a.match(/\d/g)||[]).length>2&a!=[...a].reverse().join``

Try it online!
Returns 1 for true and 0 for false

C# (Visual C# Interactive Compiler), 67 bytes
n=>n.Count(char.IsDigit)>2&!n.Reverse().SequenceEqual(n)&n.Length>9

Try it online!

Pip, 19 bytes
#a>9&XD Na>2&aNERVa

Try it online! (all test cases)
Explanation
With a being the first command-line argument:
#a > 9      Length of a is greater than 9
&           and
XD N a > 2  Number of matches of regex [0-9] iN a is greater than 2
&           and
a NE RV a   a is not (string-)equal to reverse of a

Stax, 14 bytes
ûc╖»¬ë⌂╓âó╗cCé

Run and debug it


text:
The 465 Arrangement
Here's the challenge. Write some code to output all the integers in a range. Sounds easy, but here's the tricky part. It will start with the lowest number, then the highest. Then the lowest number which isn't yet in the array. Then the highest which isn't yet in it.
Example:
Lets take 1 to 5 as our start
The numbers are [1, 2, 3, 4, 5].
We take the first, so [1]. Remaining numbers are [2, 3, 4, 5].
We take the last, new array is [1, 5]. Remaining numbers are [2, 3, 4].
We take the first, new array is [1, 5, 2]. Remaining numbers are [3, 4].
We take the last, new array is [1, 5, 2, 4]. Remaining numbers are [3].
We take the first, new array is [1, 5, 2, 4, 3]. No numbers remaining, we're done.
Output [1, 5, 2, 4, 3]
Rules:

This is code golf, write it in the fewest bytes, any language.
No standard loopholes.
Links to an online interpreter, please? (E.g. https://tio.run/)
Two inputs, both integers. Low end of range, and high end of range.
I don't mind what the data type of the output is, but it must show the numbers in the correct order.

Examples
Low: 4
High: 6
Result:
4
6
5

Low: 1
High: 5
Result:
1
5
2
4
3

Low: -1
High: 1
Result:
-1
1
0

Low: -1
high: 2
Result:
-1
2
0
1

Low: -50
High: 50
Result:
-50
50
-49
49
-48
48
-47
47
-46
46
-45
45
-44
44
-43
43
-42
42
-41
41
-40
40
-39
39
-38
38
-37
37
-36
36
-35
35
-34
34
-33
33
-32
32
-31
31
-30
30
-29
29
-28
28
-27
27
-26
26
-25
25
-24
24
-23
23
-22
22
-21
21
-20
20
-19
19
-18
18
-17
17
-16
16
-15
15
-14
14
-13
13
-12
12
-11
11
-10
10
-9
9
-8
8
-7
7
-6
6
-5
5
-4
4
-3
3
-2
2
-1
1
0

Happy golfing!

Almost duplicate (the difference being that this one requires reversing the second half before merging).

is the input always going to be in the order of low end, high end?

@Sumner18 yes. The community here is dead-set against input validation, and I haven’t asked for a reverse-order input, so we can assume it’ll always be low - high.

Are warnings allowed? Sorry, I'm working on a solution and can get a very short solution in my preferred language if warnings are allowed.

@Sumner18 How these challenges usually work is that we don't care how invalid inputs are handled. Your code is only judged to be successful by how it deals with valid inputs (i.e. both are integers, the first is lower than the second)

@AJFaraday: you should add a note to the main post indicating that X will be always strictly lower than Y (i.e. X != Y), I missed this comment ;)

@AJFaraday, are you saying that we must take the lower integer as the first input? Or are we free to choose which order to take them in? I suggest the latter.

R, 38 37 36 bytes
function(a,b)rbind(a:b,b:a)[a:b-a+1]

Try it online!

-1 byte thanks to @user2390246
-1 byte thanks to @Kirill L.

Exploiting the fact that R stores matrices column-wise

Using rbind is much better than my approach, but you can save 1 byte by using [seq(a:b)] instead of unique.

You're right, I missed the comment where has been specified that a < b (never equal), so we can use seq(a:b)

@digEmAll My solution was essentially a literal interpretation of the puzzle, I never would have even thought of doing something such as this. Impressive, have an upvote!

-1 more

Haskell, 30 bytes
a%b=a:take(b-a)(b:(a+1)%(b-1))

Try it online!

Dammit! I have just found the exact same solution. Oh well

R, 65 64 61 60 bytes
-1 byte thanks to Robert S.
-4 more thanks to digEmAll

x=scan();z=x:x[2];while(sum(z|1)){cat(z[1],"");z=rev(z[-1])}

Try it online!

You can replace length(z) with sum(z|1) to save 1 byte :)

I don't understand how that works but I guess it does. sum(z|1) seems like it would always evaluate to at least 1, which would cause the while loop to loop endlessly. but apparently not

z is a vector. each element of that vector is |ed with 1. Which is always equal to 1. When you take the sum, you have a vector filled with TRUEs so the result is equal to the length of the vector. If the vector is empty, you the is nothing to | with so the output vector is logical(0). When you take that sum, it's 0

Haskell, 39 bytes
a#b|a>b=a:b#(a-1)|a<b=a:b#(a+1)|1>0=[a]

Try it online!

Python 2, 44 bytes
f=lambda a,b:[a]*(a==b)or[a]+f(b,a-cmp(a,b))

Try it online!

PowerShell, 59 48 bytes
param($a,$b)(($z=0..($b-$a))|%{$a+$_;$b-$_})[$z]

Try it online!
(Seems long...)
Takes input $a and $b, constructs the range 0 .. ($b-$a), stores that into $z, then loops through that range. The looping through that range is just used as a counter to ensure we get enough iterations. Each iteration, we put $a and $b on the pipeline with addition/subtraction. That gives us something like 1,5,2,4,3,3,4,2,5,1 so we need to slice into that from 0 up to the $b-$a (i.e., the count) of the original array so we're only left with the appropriate elements. That's left on the pipeline and output is implicit.
-11 bytes thanks to mazzy.

48 bytes

@mazzy Ah, I like that $b-$a trick -- that's clever!

05AB1E, 6 bytes
ŸDvć,R

Try it online!
Explanation
Ÿ        # push range [min ... max]
 D       # duplicate
  v      # for each element in the copy
   ć,    # extract and print the head of the original list
     R   # and then reverse it

Ÿ2ä`R.ι non iterative using interleave, but this is still much better.

@MagicOctopusUrn: I tried a non-iterative solution first, but it was even worse since I didn't know about .ι ;)

Similar as what I had in mind, so obvious +1 from me. I do like your alternative 7-byter as well through, @MagicOctopusUrn. :)

With arguments "12" and "35" it returns the array members largest-smallest pairs instead of smallest-largest pairs: 35 12 34 13 33 14 32 15 31 16 30 17 29 18 28 19 27 20 26 21 25 22 24 23

@KristianWilliams: Seems to be working for me.

Maybe specify that the input is high\nlow when you also edit in the explanation. But 35\n12 indeed seems to work fine.

@KevinCruijssen: I switched to a pair instead as that felt more intuitive anyways :)

Ah yes, I wasn't aware it expected high/low input. With the new pairing it's more intuitive and works as expected.

@MagicOctopusUrn I'm a bit late to the party but here's a non-iterative solution in 5 bytes

Haskell, 30 bytes
l%h=l:take(h-l)(h:(l+1)%(h-1))

Usage: 3%7 gives `[3,7,4,6,5]
For the inputs l, h the function calls recursively with the inputs l+1, h-1, and adds l,h to the beggining.
Instead of any halting condition, the code uses take(h-l) to shorten the sequence to the right length (which would otherwise be an infinite sequence of increasing and decreasing numbers).

Wolfram Language (Mathematica), 56 54 bytes
This is my first time golfing!
f[a_,b_]:=(c=a~Range~b;Drop[c~Riffle~Reverse@c,a-b-1])

Try it online!
Saved 2 bytes using infix notation.
Explanation:
f[a_,b_]:=                                   \function of two variables
c=a~Range~b;                                 \list of integers from a to b
                           Reverse@c         \same list in reverse
                  c~Riffle~Reverse@c         \interleave the two lists
             Drop[c~Riffle~Reverse@c,a-b-1]  \drop last |a-b-1| elements (note a-b-1 < 0)

Alternatively, we could use Take[...,b-a+1] for the same result.
Tests:
f[4, 6]
f[1, 5]
f[-1, 1]
f[-1, 2]

Ouput:
{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}

The "Try it online" link returns a 403. "Sorry, you do not have permission to access this item."

@RohitNamjoshi I updated the link

note that on TIO you can place header and footer code in the text boxes above and below the actual code box. This makes the code look cleaner, as well as allow you to take advantage the PPCG answer formatter (esc-s-g). Try it online!

@JoKing much appreciated, I had never used it before!

JVM bytecode (OpenJDK asmtools JASM), 449 bytes
enum b{const #1=Method java/io/PrintStream.print:(I)V;static Method a:(II)V stack 2 locals 4{getstatic java/lang/System.out:"Ljava/io/PrintStream;";astore 3;ldc 0;istore 2;l:iload 2;ldc 1;if_icmpeq t;aload 3;iload 0;invokevirtual #1;iinc 0,1;iinc 2,1;goto c;t:aload 3;iload 1;invokevirtual #1;iinc 1,-1;iinc 2,-1;c:aload 3;ldc 32;i2c;invokevirtual java/io/PrintStream.print:(C)V;iload 0;iload 1;if_icmpne l;aload 3;iload 0;invokevirtual #1;return;}}

Ungolfed (and slightly cleaner)
 enum b {
    public static Method "a":(II)V stack 5 locals 4 {
        getstatic "java/lang/System"."out":"Ljava/io/PrintStream;";
        astore 3;
        ldc 0;
        istore 2;
    loop:
        iload 2;
        ldc 1;
        if_icmpeq true;
    false:
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 0,1;
        iinc 2,1;
        goto cond;
    true:
        aload 3;
        iload 1;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 1,-1;
        iinc 2,-1;
        goto cond;
    cond:
        iload 0;
        iload 1;
        if_icmpne loop;
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        return;
    }
}

Standalone function, needs to be called from Java as b.a(num1,num2).
Explanation
This code uses the method parameters as variables, as well as a boolean in local #3 deciding which number to output. Each loop iteration either the left or right is output, and that number is incremented for the left or decremented for the right. Loop continues until both numbers are equal, then that number is output.
...I have a distinct feeling I'm massively outgunned on the byte count

Japt, 14 bytes
òV
íUs w)c vUl

Try it online!

13 bytes, using the same approach.

C# (Visual C# Interactive Compiler), 46 bytes
a=>b=>{for(;a<=b;Write(a+(b>a++?b--+"":"")));}

Saved 4 bytes thanks to dana!
Try it online!
C# (Visual C# Interactive Compiler), 65 bytes
void z(int a,int b){if(a<=b){Write(a+(b>a?b+"":""));z(a+1,b-1);}}

Try it online!

Stax, 7 bytes
É╓ÅìΔà▲

Run and debug it

R, 51 bytes
function(x,y,z=x:y)matrix(c(z,rev(z)),2,,T)[seq(z)]

Try it online!
Explanation:
For a sequence x:y of length N, create a two-by-N matrix consisting of the sequence x:y in the top row and y:x in the bottom row matrix(c(z,rev(z)),2,,T). If we select the first N elements of the matrix [seq(z)], they will be chosen by column, giving the required output.
Outgolfed by digEmAll

I just posted a very similar approach 30 seconds before you :D

@digEmAll Yes, but yours is a lot better!

cQuents, 19 bytes
#|B-A+1&A+k-1,B-k+1

Try it online!
Note that it does not work on TIO right now because TIO's interpreter is not up to date.
Explanation
#|B-A+1&A+k-1,B-k+1
                      A is the first input, B is the second input
#|B-A+1               n = B - A + 1
       &              Print the first n terms of the sequence
                      k starts at 1 and increments whenever we return to the first term
        A+k-1,         Terms alternate between A + k - 1 and
              B-k+1     B - k + 1
                       increment k

Haskell, 39 bytes
f(a:b)=a:f(reverse b)
f x=x
a#b=f[a..b]

Try it online!

MathGolf, 6 bytes
↨_x^─▀

Try it online!
Explanation with (1, 5)
↨        inclusive range from a to b    [1, 2, 3, 4, 5]
 _       duplicate TOS                  [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]
  x      reverse int/array/string       [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]
   ^     zip top two elements on stack  [[1, 5], [2, 4], [3, 3], [4, 2], [5, 1]]
    ─    flatten array                  [1, 5, 2, 4, 3, 3, 4, 2, 5, 1]
     ▀   unique elements of string/list [1, 5, 2, 4, 3]

The reason why this works is due to the fact that all elements in the output should be unique, so the unique elements operator will filter out the second half of the array, producing the correct output.

Brachylog, 15 bytes
⟦₂{∅|b↔↰T&hg,T}

Input is a 2-element list [lo, hi]. Note that underscore is used for negative numbers. Try it online!
Explanation
⟦₂               2-argument inclusive range: [1,5] -> [1,2,3,4,5]
  {           }  Call this recursive predicate to calculate the output:
   ∅               Base case: the input is empty list; nothing to do
    |              Otherwise (recursive case):      [1,2,3,4,5]
     b             Behead the input list            [2,3,4,5]
      ↔            Reverse                          [5,4,3,2]
       ↰           Call the predicate recursively   [5,2,4,3]
        T          Label the result T
         &         Also, with the input list,
          h        Take the head                    1
           g       Wrap it in a list                [1]
            ,T     Append T from earlier            [1,5,2,4,3]

APL (dzaima/APL), 21 bytes
⌈⊢+.5×-+∘(⌽×¯1*)∘⍳1+-

Try it online!

Japt, 7 bytes
Takes input as an array.
rõ
ÊÆÔv

Try it or run all test cases
         :Implicit input of array U=[low,high]
r        :Reduce by
 õ       :  Inclusive, reversed range (giving the range [high,low])
\n       :Reassign to U
Ê        :Length
 Æ       :Map the range [0,Ê)
  Ô      :  Reverse U
   v     :  Remove the first element

MATL, 8 bytes
&:t"1&)P

Try it online!
Explanation
&:      % Take two inputs (implicit). Two-input range
t       % Duplicate
"       % For each
  1&)   %   Push first element, then an array with the rest
  P     %   Reverse array
        % End (implicit). Display (implicit)

Forth (gforth), 52 bytes
: f 2dup - 1+ 0 do dup . i 2 mod 2* 1- - swap loop ;

Try it online!
Explanation
Loop from 0 to (End - Start). Place End and Start on top of the stack.
Each Iteration:

Output the current number
Add (or subtract) 1 from the current number
Switch the current number with the other number

Code Explanation
: f           \ start new word definition
  2dup -      \ get the size of the range (total number of integers)
  1+ 0        \ add 1 to the size because forth loops are [Inclusive, Exclusive)
  do          \ start counted loop from 0 to size+1
    dup .     \ output the current top of the stack
    i 2 mod   \ get the index of the loop modulus 2
    2* 1-     \ convert from 0,1 to -1,1
    -         \ subtract result from top of stack (adds 1 to lower bound and subtracts 1 from upper)
    swap      \ swap the top two stack numbers
  loop        \ end the counted loop
;             \ end the word definition

JavaScript, 40 bytes
l=>g=h=>h>l?[l++,h--,...g(h)]:h<l?[]:[l]

Try It Online!

Julia 0.7, 29 bytes
f(a,b)=[a:b b:-1:a]'[1:1+b-a]

Try it online!

05AB1E, 5 bytes
ŸÂ.ιÙ

Takes input as upper first.
Explanation:
ŸÂ.ιÙ   //full program
Ÿ       //push [min .. max]                stack: [[4, 5, 6]]
 Â      //push range and reversed range    stack: [[4, 5, 6], [6, 5, 4]]
  .ι    //interleave                       stack: [[4, 6, 5, 5, 6, 4]]
    Ù   //deduplicate                      stack: [[4, 6, 5]]

Try it online!

JavaScript, 35 bytes
f=(a,b,s=1)=>a-b?a+[,f(b,a+s,-s)]:a

Try it online!
Thanks to Arnauld, 1 byte saved.

Ruby, 37 36 33 bytes
f=->a,b{a>b ?[]:[a,b]|f[a+1,b-1]}

Try it online!
Recursive version with 3 bytes saved by G B.
Ruby, 38 bytes
->a,b{d=*c=a..b;c.map{d.reverse!.pop}}

Try it online!
Non-recursive version.

Cubix, 16 bytes
;w(.II>sO-?@;)^/

Try it here
Cubified
    ; w
    ( .
I I > s O - ? @
; ) ^ / . . . .
    . .
    . .

Explanation
Basically, this moves the two bounds closer together one step at a time until they meet.  Each time through the loop, we swap the bounds, Output, take the difference, and increment with ) or decrement with ( based on the sign.

tinylisp, 48 bytes
(d f(q((A B)(c A(i(e A B)()(f B((i(l A B)a s)A 1

Try it online!
Explanation
The code defines a recursive function f that takes two arguments A and B, which are initially the lower and upper bounds of the range.

Base case: if A = B, return a list containing the single element A
Recursive case: prepend A to the result of a recursive call:

If A < B, recurse with arguments B and A+1
If A > B, recurse with arguments B and A-1

For example, with initial arguments 1 and 5:
Value   Next call
1       5, 2
5       2, 4
2       4, 3
4       3, 3
3       Return

with a resulting list of (1 5 2 4 3).
Somewhat ungolfed:
(load lib/utilities)

(def f
  (lambda (A B)
    (cons A
      (if (equal? A B)
        nil
        (f B
          ((if (less? A B) add2 sub2)
            A
            1))))))

Java (JDK), 52 bytes
(l,h,o)->{for(int i=0;l<=h;i^=1)o.add(i<1?l++:h--);}

Try it online!

Ink, 45 bytes
=h(I,A)
{I<=A:{I} {I<A:{A} ->h(I+1,A-1)}}->->

(I don't think there's an online interpreter for Ink, sorry)
Try it online!
Defines a stitch called h, which takes two arguments I and A, which are the bounds of the range.
Outputs by printing values, separated by spaces, to stdout.
Explanation
=h(min, max) // Define the stitch.
{min <= max:{min}/* print min unless it's greater than max */{min < max: {max} /*Also print max if it's greater than min*/->h(min+1, max-1)/*Then divert, with the arguments changed*/}}
->-> // If we didn't divert earlier, divert to wherever the stitch was called from

Perl 5 -ln, 37 bytes
@.=$_..<>;say shift@.,$/,pop@.while@.

Try it online!

33bytes

Jelly, 6 bytes
rạṂ¥Þ,

Try it online!

Pyth, 10 8 bytes
{.iF_B}F

Try it here
Explanation
{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.

APL+WIN, bytes 17, 13, 26
4 bytes saved thank to Adám  plus 13 bytes see Jonah's comment
(⍴m)↑∊m,¨⌽m←(1↓m)+0,⍳-/m←⎕

Try it online! Courtesy of Dyalog Classic
Explanation:
m←(1↓m)+0,⍳-/m←⎕ Prompts high end of range followed by low end and generates vector

∊m,¨⌽m Reverse the vector, pair elements from both vectors and flatten.

(⍴m)↑ Select the elements to the length of the original vector

Can you not replace [1.1] with ⍪? And if you can't do that, then surely ∊m,¨⌽m works for the same byte count, no?

@Adám No I cannot use ⍪ unless I already have a single row matrix which I would then have to transpose. This has knock on effects to the final selection. On the second point agreed but again a style point give same byte count.

Doesn't monadic ⍪ cause ⌽m to be a 1-column matrix, and then m, pairs up scalars of m with rows of ⌽m? Try! And ∊m,¨⌽m is surely shorter than m,[1.1]⌽m!

@Adám From the manual: Join two arrays. The default for ⍪ is along the first dimension; the default for , is along the last dimension. There is no monadic option. ∊m,¨⌽m is indeed 4 bytes shorter. Thanks

Your explanations are a bit behind. I would describe ∊m,¨⌽m as zipping and your last line has ,m which doesn't belong there.

@Adám. Thanks. Not familiar with zipping. Hopefully my version makes sense.

Doesn't the input need to be the low and high numbers of the range?

@Jonah Missed that bit :( costs me 7bytes over simple vector!

yeah it's a shame, same thing with my J answer

@Jonah It gets worse when I have to handle negative low end values. Doubles the code :( Nearly always the case when we need to do input pre-processing.

Clean, 48 bytes
import StdEnv
$a b|a<>b=[a: $b(a+sign(b-a))]=[a]

Try it online!

C (gcc), 46 bytes
A recursive function, call as f(low, high). As an extra 0-byte bonus, if you call f(high, low) the opposite arrangement is produced.
f(x,y){printf("%i ",x);x-y&&f(y,x+1-2*(x>y));}

Try it online!
Degolf
f(x,y)
{
  printf("%i ",x); // Print the value of x
  x-y&& // If x-y == 0, the && operator shorts and the
        // recursion ends.
    f(y,x+1-2*(x>y)); // Adjust x by 1 towards y, and
                      // recurse with x and y swapped.
}

JavaScript (Node.js), 39 37 bytes
f=a=>b=>a+[,a-b?f(b)(a<b?a+1:a-1):[]]

Try it online!

F# (.NET Core), 69 67 bytes
Translation of @nimi's answer.
fun a b->let rec h=function|a::b->[a]@h(List.rev b)|n->n in h[a..b]

Try it online!

Shortcuts for iOS, 20 Actions, 4 KB
Shortcuts is a visual scripting language, so the code is linked as a screenshot and download.
Screenshot (very tall) / Shortcut iCloud link
How it works:
getVariable (input.s)
if Equals (input.s)

This tests if input.s exists. input.s will be nothing if it does not exist. In shortcuts, nothing does not equal itself.
otherwise

There is no way to test for not equal in shortcuts other than using the else side of an if statement
dictionary {a:input.a, b:input.b, c:1}
setVariable (input)

To set a single key in a dictionary, you need to get the variable, set dictionary value, and re-set the variable. Creating a new dictionary here saves one action but takes more bytes. I am optimizing for actions here.
getVariable (input.a)
if Equals (input.b)
  getVariable(input.a)
otherwise

If both a and b are the same, this range only has one value. Values passed to otherwise are returned by End, similar to how ternary operators work in many languages.
number 0
calculate - (input.s)
getVariable (input.a)
calculate + (input.s)

No set variable is required because instead, magic variables are used to get the values from the calculate actions
dictionary{a: input.b, b:(Calculation Result), c: (Calculation Result)}

The two calculation results refer to different actions. The first to the a+s, and the second to the 0-s.
runShortcut ch-arrangement

Run this shortcut again with the new input and return the result.
To run, pass a dictionary containing a and b to the shortcut. Output is the list as a string (comma seperated). Screenshot / Link
There is no online interpreter for this. You need an iOS device and the Shortcuts app.
Logic from @ovs's javascript answer

Clojure, 62 bytes
#(distinct(let[r(range %1(inc %2))](interleave r(reverse r)))

Try it online!
Wow Clojure is a terrible golfing language. Still fun though.

VBA (Excel), 62 bytes
Using immediate window and [a1] and [a2] as input.
a=[a1]:b=[a2]:For x=0To(b-a)/2:?a+x &IIf(b-x=a+x,"",b-x);:Next

J, 23 bytes
[:(#$],@,.|.)[+i.@>:@-~

Try it online!

C# (.NET Core), 66 bytes
a=>b=>{var s="";for(;b>=a;)s+=a+" "+(b==a++?"":b--+" ");return s;}

Try it online!

Haskell, 52 bytes
x?y=take(y+1-x).map head$iterate(reverse.tail)[x..y]

Try it online!

C (gcc), 54 53 52 bytes

Saved a byte two bytes thanks to Rogem.

s=1;f(x,y){printf("%d ",s*x),s=x-y?f(-y,~x,s=-s):1;}

Try it online!

C#(Visual C# Interactive Compiler), 62 bytes
void a(int i,int j){Write((j-i)%2==0?i++:j--);if(i<=j)a(i,j);}

Try it online!

I think you need a separator.

Gol><>, 22 bytes
IIT}:nP}:nM2K(?t2K=?h;

Fixed!!!
It had a major bug where it would sometimes append a zero when not necessary, but no longer!
Try it online!

Charcoal, 17 bytes
≔…·ＮＮθＷθ«≔⮌θθ⟦Ｉ⊟θ

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

Create an inclusive range between the two inputs.
Ｗθ«

Repeat until it is empty.
≔⮌θθ

Reverse it.
⟦Ｉ⊟θ

Remove the last element and print it on its own line.

Perl 6, 32 bytes
{flat($_ Z [R,] $_)[^*/2]}o&[..]

Try it online!
Not too complicated, but there's a couple of tricks that help make the program shorter
Explanation:
{                        }o&[..]   # Convert the two inputs to a range
      $_ Z [R,] $_                 # Zip the range with its reverse
 flat(            )                # Flatten
                   [^*/2]          # And take the first half of the elements

PHP, 93 92 81 bytes
Standalone program, 81 bytes:
for($a=range($argv[1],$argv[2]);$a;)echo$x++%2?array_pop($a):array_shift($a),' ';

Try it online!
As a function, 92 bytes:
function($l,$h){for($a=range($l,$h);$a;)$b[]=$x++%2?array_pop($a):array_shift($a);return$b;}

Try it online!
function ( $l, $h ) {
    for( $a = range( $l, $h ); $a; ) {
        $b[] = $x++ % 2 ? array_pop( $a ) : array_shift( $a );
    }
    return $b;
}

Well, I thought it was a worth-trying idea.  Perhaps in a more succinct language, this would work better.  The Golf is not strong with this one.

C (compiled with VC++ (Visual Studio 2017)) 264bytes
#include "stdafx.h"
void f(int l,int u){for(int t=1,h=0,H=0,i=0;i<u-l+1;i++,t^=1)printf("%d ",t?l+h++:u-H++);}void main(){f(1,5);}

choosing other Compiler may eliminate the Need for the include but vs2017 won't let me ommit it w/o Errors.
the idea is to just use variables to Keep track of how many numbers have to be added to the Minimum or have to be subtracted from the maximum (2seperate variables)
another variable is used to Keep track of from where the value has to be taken from front or from end. Setting it to 1 means lowest bit is set xor-ing it with 1 makes it toggle.
i run a loop with the amount of iterations it takes to solve the Problem.
inside the printf i use the Array Bounds and my variables to generate the number needed and increment my helper variables all at once. using the ternary Operator exp?then:else saves a few Bytes as it replaces a if-else Statement. further saving come through use of multiple variables defined in the for loop instead of only one (typically i) and putting the xor in the loop Header removes the Need for curly braces.
every Thing else i did is ommit spaces and linebreaks where possible and only use 1 character variable names and omitting ()s where ever possible

tested only with Bounds 1 and 5 but should work w/ everything else as well

1. Python 3.5, 123 bytes
Script takes two params: interval from, interval to.
from sys import*;v=[*range(int(argv[1]),int(argv[2])+1)];o=[]
for i in range(len(v)):v.reverse();o.append(v.pop())
print(o)

example:
$ ./script.py 1 5
[1, 5, 2, 4, 3]

$ ./script.py -5 6
[-5, 6, -4, 5, -3, 4, -2, 3, -1, 2, 0, 1]

Explanation
# create range input params
v=[*range(int(argv[1]),int(argv[2])+1)]

# define ampty output array
o=[]

# loop input-array-lenght times
for i in range(len(v)):

    # reverse input array
    v.reverse()

    # append last input element to output
    o.append(v.pop())

# print output array
print(o)

Java 8 (JDK): 113, 98, 124 bytes
(l,h)->{String s="";while(h>=l)s+=l+++" "+h--+" ";return s.substring(0,s.length()-(l-h==2?(l+(l<0?".":"")).length()+2:1));};

Thanka to Sriotchilism O'Zaic and Embodiment of Ignorance for saving me 15 bytes! Unfortunately those bytes were used to fix a bug Jo King mentioned.

Try it online
My first every golf code submission. Code is a functional interface that takes 2 integers and builds a string from those integers. The substring hack at the end hides a little quirk that duplicates the last element of the "array." Probably not the best solution, but for my first ever submission, I think I did well :)

Welcome to the site!  I haven't programmed very much in java, but this is a lambda right?  Would it maybe be shorter to return the result rather than output it?  System.out.print seems very long.

Also, you can golf two bytes by removing the parens around l++ and h++. Try it online!

><>, 20 bytes
:{:&=?v:1+&}
  oanr/

Try it online!

SNOBOL4 (CSNOBOL4), 95 bytes
	A =INPUT
	B =INPUT
L	OUTPUT =LE(A,B) A	:F(END)
	OUTPUT =GT(B,A) B
	A =A + 1
	B =B - 1	:(L)
END

Try it online!

Vyxal, 6 bytes
‹rI÷ṘY

Try it Online!
Explained
‹rI÷ṘY
‹      # decrement
 r     # range
  I÷   # split into two halves
    Ṙ  # reverse
     Y # interleave

Thunno 2, 4 bytes
IḲIU

Attempt This Online!
Takes the upper number first.
Explanation
IḲIU  # Implicit input
I     # Inclusive range between the two inputs
 Ḳ    # Bifurcate: reverse a copy
  I   # Interleave them together
   U  # Uniquify the list
      # Implicit output


text:
Drawing a tree from an array
Given a possibly nested, non-empty array of single-digit positive integers (not guaranteed unique), output the ASCII-art representation as a tree, using the box-drawing characters ┌ ┴ ┐ ─ │ ┬ ┼. (These were copied from Code Page 437, but you can use any equivalent representation).
Every integer of the array should be a leaf of the tree. Elements the same level deep in the array should be present at the same level of the tree. All elements should be separated by enough whitespace to be distinct (up to you to determine how wide, minimum of one space between).
For example, given array [[1, [2]], [3, [4, 5]]], output the following tree
 ┌─┴─┐
┌┴┐ ┌┴─┐
1 │ 3 ┌┴┐
  2   4 5

For array [1, 2, 3] the tree could look like
┌─┼─┐
1 2 3

But the array [[1, 2, 3]] would look like
  │
┌─┼─┐
1 2 3

While the array [1, [1, [1, [1]]]] could look like
 ┌─┴┐
 1 ┌┴─┐
   1 ┌┴┐
     1 │
       1

As a more complicated example, [1, [[[2, 3], 4], 5]] could be
┌┴───┐
1  ┌─┴┐
 ┌─┴┐ 5
┌┴┐ 4
2 3

or several other variations.

Input and output can be given by any convenient method.
You can print it to STDOUT or return it as a function result.
Either a full program or a function are acceptable.
Any amount of extraneous whitespace is acceptable, so long as the characters line up appropriately.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

[1,[[[2,3],4],5]] could be an interesting test case since it needs to have the root artificially extend so the right subtree doesn't collide with the left subtree.

@Poke Added as an example. There are several possible variations for that test case.

The first example for that test case can't be right. That suggests that the s second element next to the 1 is an array of 3 items: [2,3],4, and 5. But 4 and 5 are not adjacent.

That looks like [1, [[[2, 3]], [4], 5]] to me.

Which (if any) of these alternative input formats would be acceptable?

@neil I could agree with that, too. Didn't think about a one element array.

How should I chose from these outputs. Or are they both OK?

@Neil Yep - you're right. I wasn't thinking clearly when I made that example.

@Οurous Any of those inputs are fine.

@tsh Either of those outputs are OK.

What are we allowed to do / supposed to do to prevent the elements from colliding?

@SriotchilismO'Zaic Any amount of whitespace you want, minimum of one space between elements.

For your last example would it be ok if the 2 were not under the 1 and rather to the left or the right for example?

@SriotchilismO'Zaic Yes, that would be fine. The only requirement is that the elements are made distinct from each other.

Python 3, 400 393 390 bytes
L=len
S,*K=' ┴┼│123456789'
def T(x):
 try:return[str(x+0)]
 except:
  z=[*map(T,x)];q=max(map(L,z))
  for p in z:p+=[S*L(p[0])]*(q-L(p))
  b=[S.join(a)for a in zip(*z)];t=b[0];l=L(t);s=0;e=L(z);r=[S]*l
  if e<2:return['│'.center(l),*b]
  for i in range(l):
   if t[i]in K:s+=1;r[i]='┬┌┐'[(s<e)-(s>1)]
   elif 0<s<e:r[i]='─'
  c=l//2;r[c]=K[r[c]=='┬'];return[''.join(r),*b]

Returns a list of strings from top to bottom.
EDIT 1: Trimmed 7 bytes by avoiding duplication of ┴┼ (net save of 2 bytes), cutting out 0 from the one string, changing how drawing characters are selected from ┬┌┐ (use < instead of ==), and replacing a L(z) I missed with e
EDIT 2: -2 bytes thanks to ovs and -1 byte thanks to Kevin Cruijssen
Try it online!
Ungolfed
def layer(item):
    if isinstance(item, int):
        return [str(item)]
    else:
        subs = [layer(sub) for sub in item]
        longest = max(map(len, subs))
        for sub in subs:
            sub += [' ' * len(sub[0])] * (longest - len(sub))
        below = [' '.join(l) for l in zip(*subs)]
        top = below[0]
        l = len(top)
        if len(subs) == 1:
            return ['│'.center(l), *below]
        seen = 0
        expected = len(subs)
        builder = [' '] * l
        for i in range(l):
            c = top[i]
            if c in '┴┼│123456789':
                seen += 1
                if seen == 1:
                    builder[i] = '┌'
                elif seen == expected:
                    builder[i] = '┐'
                else:
                    builder[i] = '┬'
            elif 0 < seen < expected:
                builder[i] = '─'
        center = l // 2
        if builder[center] == '┬':
            builder[center] = '┼'
        else:
            builder[center] = '┴'
        return [''.join(builder), *below]

Builds a tree from the leaves up, one layer at a time.

I added the test-cases to your TIO link Try it online!

Nice answer! You can shorten this by two bytes by assigning the space to a variable like this: S,*K=' ┴┼│123456789'.

e==1 can be e<2 to save a byte (I don't think it ever can be 0, since the challenge states the input is non-empty - and empty inputs would have already failed at the max(map(L,z)) in that case anyway.)

Clean, 544 506 bytes
Escapes are used to avoid invalid UTF-8 on SE/TIO but counted as one byte as they're valid literals
import StdEnv,Data.List;::T=I Int|L[T];$l#m= @l#k=map maxList(transpose m)=flatlines[[last[' ':[(\_|v<0|w<[j]|q>hd w|q<last w|any((==)q)w|q==j='\305'='\302'|q==j='\301'='\304'='\277'='\332'='\263'=toChar v+'0')0\\[v,r,j:w]<-m|r/2==p&&q>=hd w&&q<=last w]]\\q<-[0..k!!3]]\\p<-[0..k!!1]];@(L l)#p=twice(\p=[[v,r+1:[e+sum([2\\[v:_]<-i|0<=v]++zipWith(\c j=j!!2-c!!3)t(takeWhile(\[z:_]=v+z< -1)(tl t)))-x!!1\\e<-x]]\\i<-inits p&t<-tails p&[v,r:x]<-p])(concatMap@l)#g=[g\\[_,2,g:_]<-p]=[[-1,0,(hd g+last g)/2:g]:p];@(I i)=[[i,0,0,0]];

Try it online!
Takes input in the format L[I 3, L[I 4, I 5], I 2]..
Connects the trees from the bottom up, left to right, then adjusts the distances from right to left.
Prettified, sort-of:
import StdEnv, Data.List;
:: T = I Int | L [T];
$ l
    #m = @l
    #k = map maxList (transpose m)
    = flatlines [
        [
            last[
                ' ':
                [
                    if(v < 0)
                        if(w < [j])
                            if(q > hd w)
                                if(q < last w)
                                    if(any ((==) q) w)
                                        (
                                            if(q == j)
                                                '\305'
                                                '\302'
                                        )(
                                            if(q == j)
                                                '\301'
                                                '\304'
                                        )
                                    '\277'
                                '\332'
                            '\263'
                        (toChar v + '0')
                    \\ [v, r, j: w] <- m
                    | r/2 == p && q >= hd w && q <= last w
                ]
            ]
            \\ q <- [0..k!!3]
        ]
        \\p<-[0..k!!1]
    ];
@ (L l)
    #p = twice
        ( \p
            = [
                [
                    v, r + 1:
                    map
                        (
                            (+)
                            (
                                sum [2 \\ [v: _] <- i| 0 <= v]
                                + sum (
                                    zipWith
                                        (
                                            \[_, _, _, c: _] [_, _, j: _] = j - c
                                        )
                                        t
                                        (
                                            takeWhile (\[v: _] = v < 0) (tl t)
                                        )
                                ) * (1 - sign (v + 1))
                                - x!!1
                            )
                        )
                        x
                ]
            \\ i <- inits p
            &  t <- tails p
            &  [v, r: x] <- p
            ]
        )
        (concatMap @ l)
    #g = [g \\ [_, 2, g: _] <- p]
    =[[-1, 0, (hd g + last g)/2: g]: p];
@ (I i) = [[i, 0, 0, 0]];

Charcoal, 127 123 bytes
↶≔⟦⟦θ⟧⟧ηＦη«≔⊟ιζ¿⁼Ｉζ⪫⟦ζ⟧ω⊞υ⊞ＯιζＦＬζ⊞η⁺ι⟦⊖Ｌζκ§ζκ⟧»Ｗυ«≔⌊υι≔Φυ¬⁼κιυＪ±⊗Ｌυ⊘⊖ＬιＩ⊟ιＷι«≔⊟ιζ¿ζ«←§┐┬‹ζ⊟ιＷ⁼ＫＫψ←─≔⁰ι»¿⊟ι┌¶┴¦│

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

Change the default drawing direction to up since we don't draw anything to the right.
≔⟦⟦θ⟧⟧η

The first step is to convert the nested array representation into an index representation which is a list of all the entries together with the indices of the subarrays, e.g. for the input q=[1, [[[2, 3]], [4], 5]] the 5 is q[1][2] and therefore the list we want is 1, 2. We start with a single entry to process which is a list containing a list of the current indices (i.e. none so far) and the original input.
Ｆη«

Loop over the arrays as we process them. (Conveniently Charcoal will continue to iterate over a list if you push to it during iteration.)
≔⊟ιζ

Get the next array to process.
¿⁼Ｉζ⪫⟦ζ⟧ω

Is this actually a scalar rather than an array?
⊞υ⊞Ｏιζ

If so, then the list we had actually belongs on the final list of lists of indices.
ＦＬζ

Otherwise, loop over each element in this array...
⊞η⁺ι⟦⊖Ｌζκ§ζκ⟧»

... and save it with its new index list so far for further processing. The maximum index of the array is also saved which is used to special-case the last element of the array.
Ｗυ«

We are now ready to loop over the list of index lists. However, the list is not in lexicographical order, so we can't iterate it directly.
≔⌊υι

Find the next element in lexicographical order.
≔Φυ¬⁼κιυ

Remove it from the list.
Ｊ±⊗Ｌυ⊘⊖Ｌι

Jump to the position of the scalar in the output. We can calculate this given that we can keep count of the number of scalars we output and we also know the number of entries in its index list.
Ｉ⊟ι

Actually print the scalar.
Ｗι«

Loop over the entries in the index list. Again, this isn't simple iteration, because the entries come in pairs, and we also need to be able to break out of the loop.
≔⊟ιζ

Extract the next index from the list.
¿ζ«

If this is not the first element in the list...
←§┐┬‹ζ⊟ι

... then print ┐ or ┬ depending on whether this is the last element in the list...
Ｗ⁼ＫＫψ←─

... and print enough ─s to fill up to the previous entry at this level...
≔⁰ι»

... and clear the variable to break out of the loop since we're done here.
¿⊟ι┌¶┴

Otherwise if this is (the first element of) a multiple-element list then print the ┌┴, leaving the cursor above the ┴ to deal with this level's parent.
¦│

Otherwise if this is a 1-element list then just print a │ and move up a line to deal with this level's parent.


text:
Passwords Strong Against Bishops
Not to be confused with Password Bishop Goodness!
Given a string, answer (truthy/falsy or two consistent values) if it constitutes a password which is strong against bishops.
A password is strong against bishops if it is a string consisting of alternating letters (in a-h) and digits (in 1-8) such that each pair of characters can be interpreted as a square on a chessboard, and if you place a white pawn on each square named in the password, then there is no way for a white bishop to travel, in any number of consecutive moves, from any square in the first (1) row to any square in the last (8) row.
Examples
Passwords strong against bishops

a1b1c1d1e1f1g1h1
a8b8c8d8e8f8g8h8
a1b2c3d4d5f5f4g3g4h2b5
h4g4f4e4c4b4a4c3e3
a1b1c1d1e1f1g1a8b8c8d8e8f8g8
b4b5d4d5f4f5g3h5

 For example, a1b1c1d1e1f1g1a8b8c8d8e8f8g8 corresponds to the position  and b4b5d4d5f4f5g3h5 corresponds to the position

Passwords weak against bishops

a4c4e4g4g5d6f6e3d2b2 (well-formed but not strong — thanks Jo King for this example!)
b1c1d1e1f1g1h1a8b8c8d8e8f8g8 (well-formed but not strong)
h4g4f4e4c4b4a4c3 (well-formed but not strong)
d4 (well-formed but not strong)
b4b5d4d5f4f5g2h5 (well-formed but not strong)
correct horse battery staple (ill-formed)
1a1b1c1d1e1f1g8a8b8c8d8e8f8g (ill-formed)
a (ill-formed)
aa (ill-formed)

What color squares does the bishop go on?

@EmbodimentofIgnorance from any square in the first (1) row to any square in the last (8) row. The bishop tries a path from all squares in the first row. Question: is 1a equal to a1 for being parsed as a chess square?

Can the bishop take pawns? Can opposing pawns take the bishop?

Your 2nd last test case contradicts your spec. You also need to explain how "each pair of characters can be interpreted as a square on a chessboard".

a1b2c3d4d5f5f4g3g4h2b5 is not strong against bishops, since a bishop can get to h5, then go down to d1

suggested case: a and aa

@EmbodimentofIgnorance: "a1b2c3d4d5f5f4g3g4h2b5 is not strong against bishops..." — No, the direct route from d1 to h5 is blocked by the pawn on g4. (I used chessboardjs.com to view the non-trivial examples.)

@TRITICIMAGVS, Ourous: I've clarified that both the pawns and the bishop are white, so neither is allowed to capture (or land on, or move through, or jump over) the other.

@Shaggy: When you posted that comment, the "2nd last test case" was correct horse battery staple, which is obviously not strong against bishops according to the spec as I read it. Can you perhaps clarify what you meant by "Your 2nd last test case contradicts your spec"? (Assuming it still matters, that is.)

@Veskah: The ill-formed/weak example 1a2a3a4a5a6a7a1h2h3h4h5h6h7h already answers your question as to whether 1a is an acceptable variation of a1. (It's not.)

Ah, sorry, I misread the spec - I read it as we would be given "a string consisting of alternating letters (in a-h) and digits (in 1-8) such that each pair of characters can be interpreted as a square on a chessboard" - i.e, we were guaranteed the input would match the RegEx [a-h][1-8]+.

This is still in need of an explanation of how each pair of characters corresponds to a square on a chessboard as well as a worked example or 2.

@Arnauld: Oops! I blame my instinctive zero-indexing. That g2 should have been g3. Fixed now. @Shaggy: I think you'll just have to look at http://chessboardjs.com or the Wikipedia page for chess or something. A full description of how "d4" corresponds to a square, or how a bishop moves, or whether a white piece can capture another white piece, is supposed to be out-of-scope for this specific puzzle.

Can the input contain capital letters, and if yes, do [A-H] also count? Or can we assume the input always consist of [a-z0-9 ] (based on the test cases given)?

Also, could you add an example for one of the truthy test cases. Because I understand that the squares of the password are filled with white pawns, but I don't understand where the white bishop is placed. And if any place is fine, why can't it travel to each row 1 through 8 in the first test case? It cannot travel to each column, since the a column is completely filled with pawns, but it can travel to each row without a problem, can it not? I have the feeling I'm missing something.. :S

@KevinCruijssen: Yikes. For a1a2a3a4a5a6a7a8, read a1b1c1d1e1f1g1h1! I don't blame you for being confused, now that I see that! Does that clarify? Also I'll look into adding some inline chess grids. As for [A-H], I'd say strictly speaking the puzzle says not to count them as letters.

Suggested test case b1d1f1h1g5d6f6e3d2b2c5 => false. It seems most answers fail, since the bishop is forced to go backwards to make it to the end

@Quuxplusone Ah, now it indeed makes a lot more sense. xD

Ruby, 115 182 163 bytes
->s{z=('00'..'99').map{|x|x=~/[09]/||s[(x[1].ord+48).chr+x[0]]};(11..18).map &g=->x{z[x]||[x-11,x-9,x+z[x]=9,x+11].map(&g)};s=~/^([a-h][1-8])*$/&&(z[81,9]-[9])[8]}

Try it online!
Returns 1 for strong and nil for weak. (The +67 bytes was for taking into account "backtracking.")
->s{
 z=                             # this is the board
 ('00'..'99').map{|x|           # coordinates are described as y*10 + x
  x=~/[09]/||                   # truthy if out of bounds...
  s[(x[1].ord+48).chr+x[0]]     # ...or impassable
 }                              # now only the passable squares are falsey
 (11..18).map                   # for each x position at y=1,
  &g=->x{                       # call helper function on that square
   z[x]||                       # if the square is passable (i.e. falsey),
    [x-11,x-9,x+z[x]=9,x+11]    # mark it impassable by setting to 9 (truthy)
     .map(&g)                   # call helper recursively for each neighbor
  }
 s=~/^([a-h][1-8])*$/           # make sure the input was valid,
 &&(z[81,9]-[9])[8]             # and check that the last row was never reached
}

A few tricks that were used:

Instead of the numerical range 0..99, we use the string range '00'..'99' so that the number is automatically left-padded to 2 digits and stringified. This makes out of bounds checking very short -- match with regex /[09]/.
Inside the helper function, while building the list of new coordinates [x-11, x-9, x+9, x+11], we simultaneously assign z[x] to 9 in the process, which happens to be a truthy value (marking the square visited).
In the last line, we want to check that the array z[81,9] does not contain 9. We do this by removing all instances of 9 (z[81,9]-[9]), then asking for the 9th element of the resulting array ([8]). Since we know the array originally had 9 elements, if any were removed, we'll get nil, whereas if they all remained, we'll get the last element of the array (which happens to always be 1).

Python 2, 330 318 313 309 370 bytes
import numpy as n
b=n.ones([8,8])
q=r=1
s=input()
l=len(s)
def g(x,y=0,p=0):
    if b[y,x]and p<32:
        if y<7:
            if x<7:
                g(x+1,y+1,p+1)
                if y:g(x+1,y-1,p+1)
            if x:
                g(x-1,y+1,p+1)
                if y:g(x-1,y-1,p+1)
        else:global q;q=0
for i in range(l/2):
    x=ord(s[2*i])-97;y=ord(s[2*i+1])-49
    if y>8or y<0 or l%2or x>8or x<0:r=0
    if r:b[7-y,x]=0
map(g,range(8))
print q&r

Try it online!
Try practical version online! (original can take 4^32 operations to check completely, I suggest using this one - same number of bytes)
Not a super short solution - I couldn't figure out how to make a lambda function version of g shorter than g itself.
-4 bytes thanks to Quuxplusone
+61 bytes accounting for backtracking (thanks for pointing that out Jo King and for the golfing tips)

Nice. q=r=1 would be shorter than q=1 r=1, right? And if r: shorter than if r>0:.

Python 2, 490 476 474
def f(p):
 a=[set(ord(c)-33 for c in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()];x=set((ord(p[i+1])-49)*8+ord(p[i])-97 for i in range(0,len(p),2))
 r=set(range(8))-x
 for i in range(99):r=set().union(*[a[c]for c in r])-x
 return all(c<56 for c in r)

Try it online!
This works by "flood-fill." First we create a list a of which squares are adjacent to which other squares, bishopwise. Then we create a set x of exclusions (based on the password). Then we initialize a set r of reachable squares, which starts out as just the first row (minus any exclusions), and repeatedly "flood" outward from there, 99 times, which should be more than enough. Finally, we test to see if any of the squares in the last row ended up in our reachable set. If so, we have a weak password! If not, we have a strong password.
Disadvantage, perhaps disqualifying (I don't know the usual rule here): If the password is ill-formed (such as "correct horse battery staple"), then we throw an exception instead of returning False. But we do always return True iff the password is strong!
Minus 16 bytes thanks to Jo King. We inline a in the one place it's used, and constant-fold some math.
def f(p):
 x=set(ord(p[i])-489+8*ord(p[i+1])for i in range(0,len(p),2));r=set(range(8))-x
 for i in[1]*99:r=set().union(*[[set(ord(k)-33for k in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()][c]for c in r])-x
 return all(c<56for c in r)

@JoKing thanks! There's still whitespace before two fors that I couldn't see how to remove. I found that replacing range(99) with repr(f) works on my local machine but not on tio.run's interpreter... but then I found that [1]*99 was shorter anyway! So that saved 4 more bytes.

whitespace before two fors that I couldn't see how to remove — Oh! Apparently Python treats 33for as two tokens (whereas for33 would be one token). Today I learned. Minus 2 more bytes, then.

Wolfram Language (Mathematica), 339 316 358 353 345 bytes
-23 bytes thanks to @Doorknob.
+42 bytes accounting for backtracking.
p[m_]:=StringPartition[#,m]&;l=Range@8;f[n_]:=Check[w=(8#2+#1-8)&@@@({LetterNumber@#,FromDigits@#2}&@@@(p@1/@p[UpTo@2]@n));g=Graph[Sort/@UndirectedEdge@@@Position[Outer[EuclideanDistance@##&,#,#,1],N@Sqrt@2]&@GraphEmbedding@GridGraph@{8,8}//Union]~VertexDelete~w;c:=#~Complement~w&;m=0;Do[m+=Length@FindPath[g,i,j],{i,c@l},{j,c[l+56]}];m==0,0>1]

Try it online!
I rewrote most of this to account for backtracking, I think there may be an easier way to define the graph g, Mathematica has GraphData[{"bishop",{8,8}}] which is the graph of all moves a bishop can make on a chessboard (Bishop Graph), but this graph includes connections further than nearest diagonal neighbor. If anyone knows a shorter way to do that let me know. Credit for the graph construction goes to this MathematicaSE answer.
Returns True for strong passwords, False for weak/ill-formed passwords. Note that for most of the ill-formed passwords it will produce a bunch of error messages and then return False. If this is not in line with the rules then they can be suppressed by changing f[n_]:=... to f[n_]:=Quiet@... costing 6 bytes.
Ungolfed:
p[m_] := StringPartition[#, m] &;

f[n_] :=
 Check[
  w = (8 #2 + #1 -
       8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@
        p[UpTo@2]@n));
  r = GridGraph[{8, 8}];
  g = Graph[Sort /@ UndirectedEdge @@@
             Position[Outer[EuclideanDistance@## &, #, #, 1],N@Sqrt@2] &@
              GraphEmbedding@r // Union]~VertexDelete~w;
  s = Complement[{1,2,3,4,5,6,7,8},w];
  e = Complement[{57,58,59,60,61,62,63,64},w];
  m = 0;
  Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
  If[m == 0,True,False]
  , False]

Breakdown:
p[m_]:=StringPartition[#,m]&

Takes a string argument and splits it into a list of strings each of length m.
Check[...,False]

Returns False if any error messages are produced, which is how we catch the ill-formed strings (i.e. assume they are well-formed, inevitably producing an error down the line).
(8*#2 + #1 - 8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@
        p[UpTo@2]@n));

Takes the string of pawn positions and splits it such that "a2h5b" becomes {{"a","2"},{"h","5"},{"b"}}, then LetterNumber will convert the letter to a number (a -> 1, etc) and FromDigits converts the numeral into an integer. If the string is not well formed, this step will produce an error which will be caught by Check, returning False. These two numbers are then converted to an integer corresponding to a square on the board.
r = GridGraph[{8, 8}];
g = Graph[
     Sort /@ UndirectedEdge @@@
          Position[Outer[EuclideanDistance@## &, #, #, 1],
           N@Sqrt@2] &@GraphEmbedding@r // Union]~VertexDelete~w;

Constructs the graph of all nearest-neighbor diagonal edges with the pawn positions deleted.
s = Complement[{1,2,3,4,5,6,7,8},w];
e = Complement[{57,58,59,60,61,62,63,64},w];

These are lists of unoccupied starting and ending vertices respectively
m=0
Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
If[m == 0,True,False]

Loops over the starting and ending vertices, for each pair FindPath will be a list of paths between them. If there are no paths between them, it will be an empty list, so Length@ returns 0. If there are no paths at all, then m will be zero, and we return True, otherwise return False.

A few tips: True and False can be 1>0 and 0>1 respectively. p[1]@#&/@ is equivalent to just p@1/@. Sequence@@ can be replaced with ##&@@. Instead of {LetterNumber[#[[1]]],FromDigits[#[[2]]]}&/@, you can use {LetterNumber@#,FromDigits@#2}&@@@.

@Doorknob thanks! Code golfing is teaching me all sorts of new things about Mathematica. I still don't 100% understand p@1/@, but I see the general idea. I suppose p@1 = StringPartition[#,1]&, it's slightly confusing to me I guess because p takes two arguments two different ways, one as m_ and the other as #...&, I guess this is just a matter of precedence. It makes sense though that p@m = p[m].

It has for me as well! The main change there is that for any function f that takes a single argument, f@#& has the same behavior as just f -- here, f is p[1]. (Then I changed the [] notation to @, which is always identical except for precedence.)

@JoKing that's devious, this is more complicated than I first thought, having to consider backwards movements as well. Thanks

@JoKing wrote a new one which accounts for backtracking.

Does TransitiveReductionGraph[GraphData["bishop",{8,8}]]  work?

@PeterTaylor wow great find, I'll mess with it, looks like it should work

@PeterTaylor so the TransitiveReductionGraph doesn't give exactly what I need, as it reduces the graph to the minimal number of edges necessary to reach any position, whereas I was to keep all edges connecting nearest diagonal neighbors. I'll think about it more, I'm sure there's a way to do it with the bishop graph.

Clean, 285 bytes
import StdEnv,Data.List
$_[_]=1<0
$a[x,y:l]=case[[u,v]\\u<-[0..7],v<-[0..7]|u==toInt x-97&&v==toInt y-49]of[p]= $[p:a]l;_=1<0
$a _=all(\[_,y]=y<7)(iter 64(nub o\e=e++[k\\[u,v]<-e,p<-[-1,1],q<-[-1,1],k<-[[abs(u+p),abs(v+q)]]|all((<>)k)a&&all((>)8)k])(difference[[e,0]\\e<-[0..7]]a))

$[]

Try it online!
$[] is $ :: [[Int]] [Char] -> Bool composed with the first argument, giving \ [Char] -> Bool.
The function works by consuming the string two characters at a time, immediately returning false if the string is in an invalid format as soon as it sees the invalid part. Once the string has been processed, it places a bishop on every empty square on one side of the board and moves them in every way possible 64 times and checks if any of the end positions is in the target row.

Seems to incorrectly return True for a1b1c1d1e1f1g1? Not that I understand anything about how it works. :)

@Quuxplusone I had a brain-fart and thought white bishops only used white squares. I've also added an explanation.

Python 3.8 (pre-release), 192 bytes
import re
s=p=input()
t={0,1}
while s!=t:s=t;t=t|{i for x in s for i in[x-9,x-7,x+7,x+9]if-9<i<72and-2<x%8-i%8<2and"%c%d"%(97+i%8,i/8)not in p}
print(max(s)<64and""==re.sub("[a-h][1-8]","",p))

Try it online!


text:
Meta-bowling Golf
Your task is to create the shortest program (A) that outputs another program (B) with the most unique bytes, which in turn outputs the original program (A). Essentially, you are golfing one half of a pair of ouroboros programs (a.k.a. periodic iterating quine) and bowling the other half. A and B may be in different languages.
Rules and Scoring
Your final score is <number of unique bytes in B> / <number of bytes in A>. Highest score wins. It should be noted that the theoretical maximum score is 256.

Program A must be at least one byte long
Program B cannot consist entirely of no-ops, i.e. at least one character must affect the output in some way.
Standard rules of quines apply to both programs. Notably, error quines are not allowed in either case.

For the sake of answer format consistency, begin your answer with something like this:
# <Language for A> & <Language for B>, Score: <B score> / <A score> = <combined score>

In order for this to be clear I think you are going to have to clarify the second bullet point a little bit.  What does it mean for a character to be a no-op exactly?

By unique bytes, do you mean shared bytes, or similarity between the two?

@KrystosTheOverlord, it would be simply within program B, with no relation to program A. For example, aaaaa has one unique byte and abcde has 5 unique bytes.

@Beefster So, if I have a program abcde, would edcba count as original? I feel like I'm just being dumb, but I want to ask just in case

@KrystosTheOverlord I think you're missing something. If Program A is abcde, then edcba is not also Program A. If Program B is abcde or edcba then either one would have 5 unique bytes.

@KrystosTheOverlord both of those have 5 unique bytes. There is no requirement for originality. Both programs can technically be the same, but you'll have a maximum score of 1 that way.

Am I right that you seem to be implying that multi-byte characters are not allowed in programme B?

@Shaggy. No. Multibyte characters are fair game, but you'd count it by individual bytes within the encoding. You could use a 16-bit encoding, UTF-8, or whatever floats your boat.

Are both programs required to be in the same language?

@EmbodimentofIgnorance The question states "A and B may be in different languages."

I'm just waiting for the programs where program A is in unary or lenguage

@EmbodimentofIgnorance Program A is scored in terms of number of bytes, not unique bytes. Lenguage/Unary would score horribly

Oh, I read it wrong, I thought both programs were scored by unique bytes

This is definitely the most interesting challenge I've seen so far that has a bowling component.

Japt & Japt, Score: 255 / 38 = 6.71
Program A:
"iQ ²¯24
G²õ@i'#+Xd"iQ ²¯24
G²õ@i'#+Xd
Program B is over 8kB long, so long that the link breaks, so I won't paste the whole thing. Here's a sample:
#þ"iQ ²¯24
G²õ@i'#+Xd"iQ ²,#ÿ"iQ ²¯24
G²õ@i'#+Xd"iQ ²,#Ā"iQ ²¯24
G²õ@i'#+Xd"iQ ²
I couldn't find a way to get a NUL byte to work, which is why program B only has 255 unique characters. Program B essentially consists of 255 copies of a single program, where a single irrelevant byte is changed each time, and the first 254 executions are ignored.
For the explanation, I'll start with this simplified version of A so that the resulting B is easier to discuss.
"iQ ²¯23
3õ@i'#+Xd"iQ ²¯23
3õ@i'#+Xd
This program is based on the basic payload-capable Japt quine. The string at the start contains a duplicate of the rest of the program, iQ ² inserts a quote and duplicates to create a string representation of the entire program, and then ¯23 trims off itself and everything after it. The resulting string is a program that outputs Program A:
"iQ ²¯23
3õ@i'#+Xd"iQ ²
I will refer to this string as U.
The last line of A duplicates U a bunch of times with a small change each time. Specifically, for each number X in the range [1...3] it outputs "#c" + U where c is the character with charcode X. The default behavior of Japt is to output those strings with no quotation marks and separated by commas, so this is the output of our Simplified A (note that there's an unprintable byte between each # and "iQ:
#"iQ ²¯23
3õ@i'#+Xd"iQ ²,#"iQ ²¯23
3õ@i'#+Xd"iQ ²,#"iQ ²¯23
3õ@i'#+Xd"iQ ²
We'll call this Simplified B.
Simplified B has a simple structure, alternating between #c and U. Fortunately for this answer, each #c and U is treated as separated by a comma, and in this situation the behavior of that is everything except the very last U has no effect on the output. The only portion of Simplified B which affects the output is this:
"iQ ²¯23
3õ@i'#+Xd"iQ ²
Which is identical to U that we already know outputs Simplified A.
The only difference between Simplified A and Program A is that instead of generating copies for the range [1...3] the real program generates copies for the range [1...256]. That results in 256 versions of #c each of which has a different character, though the last version "Ā" is a multi-byte character so it doesn't add any unique bytes, but everything except the last U is still ignored.

Very nice :) Would this work for 38 bytes?

@Shaggy The 27 needs to be tweaked whenever bytes are saved, but other than that it seems like it works.

@Shaggy The scoring is based on number of unique bytes in B, and there are only 256 possible bytes. As far as I'm aware, even the new version of B does not contain the Null byte.

Tried a few things to get it working with the null byte, by the way, but all failed.

Program A, Gol><>, 256/20 bytes = 12.8
"44XFL|r2ssl3%Q4s]|H

Try it online!
Program B, Gol><>
"44XFL|r2ssl3%Q4s]|H

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ

Try it online!
The program alternates between outputting itself followed by every byte and just outputting itself.
Explanation:
"            Wrapping string literal pushes the first line to the stack backwards
 44X         Push 256
    FL|      Push the range from 0 to 255
       r                  Reverse the stack
        2ss               Push a quote
           l3%            If the stack length is divisible by 3
              Q4s]|       Only take the top 20 characters
                   H      And output the stack

Program A: 05AB1E, score: 256/41 256/31 bytes = 8.258...
0"D34çý₅Ýç'q†22ǝ"D34çý₅Ýç'q†22ǝ

Try it online.
Program B: 05AB1E
0"D34çý₅Ýç'q†22ǝ"D34çýq

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoprstuvwxyz{|}~ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿÝç'q†22ǝ

Try it online.
Explanation:
The shortest quine for 05AB1E is this one: 0"D34çý"D34çý (14 bytes) provided by @OliverNi. My answer uses a modified version of that quine by adding ₅Ýç'q†vy27ǝD}J.
0            # Push a 0 to the stack
             #  STACK: [0]
 "D34çý₅Ýç'q†vDy27ǝ}J"
             # Push the string "D34çý₅Ýç'q†vDy27ǝ}J" to the stack
             #  STACK: [0,"D34çý₅Ýç'q†vDy27ǝ}J"]
  D          # Duplicate the string
             #  STACK: [0,"D34çý₅Ýç'q†vDy27ǝ}J","D34çý₅Ýç'q†vDy27ǝ}J"]
   34çý      # Join the stack by '"'
             #  STACK: ['0"D34çý₅Ýç'q†vDy27ǝ}J"D34çý₅Ýç'q†vy27ǝD}J']
₅Ý           # Push a list in the range [0,255]
  ç          # Convert each integer to an ASCII character
   'q†      '# Filter the "q" to the front
      22ǝ    # Insert it at index 22 in the string (replacing the second '₅')
             # (and output the result implicitly)

Program B will terminate as soon as it reaches the q, so the actual program B is:
0"D34çý₅Ýç'q†22ǝ"D34çýq

Everything after that is ignored, and the top of the stack (0"D34çý₅Ýç'q†22ǝ"D34çý₅Ýç'q†22ǝ) is output implicitly.