text:
Start from ones
Given a strictly positive integer n, follow these steps:

Create an array A with n 1s.
If A only has one element, terminate. Otherwise, starting from the first element, replace each pair of A with its sum, leaving the last element as is if A's length is odd, and repeat this step.

The output should contain A's state after each step in order from the first step to the last. Usage of standard loopholes is forbidden. This is a code-golf challenge, so the solution with the fewest bytes in each language wins.
Test cases
Each line in the output of these examples is a state. You can output via any reasonable format.
Input: 1
[1]

Input: 4
[1, 1, 1, 1]
[2, 2]
[4]

Input: 13
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 1]
[8, 5]
[13]

Input: 15
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 3]
[8, 7]
[15]

Can I copy this questions idea for the reverse order? Given number n, output stepwise A, and so on until you reach n 1s?

@pixma140 That would be essentially the same challenge, just with the output reversed afterwards. The modification is trivial.

05AB1E, 7 bytes
Å1Δ=2ôO

Try it online!

MATL, 10 bytes
:g`t2estnq

Try it online!
How it works
:     % Input n (implicit). Range [1 2 ... n]
g     % Convert to logical. Gives [1 1 ... 1]
`     % Do...while
  t   %   Duplicate
  2   %   Push 2
  e   %   Reshape as 2-column matrix, in column-major order, padding with 0 if needed
  s   %   Sum of each column
  t   %   Duplicate
  n   %   Number of elements
  q   %   Subtract 1. This will be used as loop condition
      % End (implicit). If top of the stack is not zero run new iteration
      % Display stack, bottom to top (implicit)

Python 3, 57 bytes
def f(i,j=1):print(i//j*[j]+[i%j][:i%j]);i>j and f(i,j*2)

Try it online!
Python 2, 51 bytes
def f(i,j=1):print i/j*[j]+[i%j][:i%j];i>j>f(i,j*2)

Try it online!
-6 bytes total thanks to tsh
Recursive function. For each step, it constructs a list of powers of 2, such that the sum is smaller than or equal to the given integer. It then appends the remainder, if it is larger than 0.

Python 3 61 bytes: def f(i,j=1):l=i//j*[j]+[i%j][:i%j];print(l);i>j and f(i,j*2); Python 2 55 bytes: def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)

@tsh Of course, thanks! i>j didn't work in my previous solution and I forgot to try it afterwards.

K (oK), 15 17 bytes
{{+/'0N 2#x}\x#1}

Try it online!

JavaScript (V8), 109 bytes
f=n=>g(Array(n).fill(1));g=(a,i=1)=>{console.log(a);if(a[i]){for(;a[i];)a.splice(i-1,2,a[i-1]+a[i++]);g(a);}}

Try it online!

Jelly, 6 bytes
L€+2/Ƭ

Try it online!

Wolfram Language (Mathematica), 55 54 bytes
Last@Reap[1~Table~#//.a_:>Tr/@Sow@a~Partition~UpTo@2]&

Try it online!
Finally, Sow/Reap beats an alternative!
Returns a singleton list containing a list of the steps.

JavaScript, 55 bytes
f=(n,t=1,r=n)=>r>t?t+[,f(n,t,r-t)]:n>t?r+`
`+f(n,t+t):r

Try it online!
This is basically the golfed version of following codes:
function f(n) {
  var output = '';
  t = 1;
  for (t = 1; ; t *= 2) {
    for (r = n; r > t; r -= t) {
      output += t + ',';
    }
    output += r;
    if (n <= t) break;
    output += '\n';
  }
  return output;
}

Pyth, 10 bytes
.u+McN2m1

Try it online!
.u          # Apply until a result is repeated, return all intermediate steps: lambda N,Y:
  +M        # map by + (reduce list on +):
    cN2     # chop N (current value) into chunks of 2, last one is shorter if needed
       m1Q  # map(1, range(Q)) (implicit Q = input)

-1 byte thanks to FryAmTheEggman

J, 20 17 bytes
_2+/\&.>^:a:<@#&1

Try it online!
-5 bytes thanks to Bubbler

20 bytes by eliminating [: and ().

Nice catch!  Thanks.

17 bytes.

Thanks @Bubbler.  Out of curiosity, what brought you back to this one?

I just browse through random challenges that appear on "Active" to see if I can add an answer or improve existing answer(s) further.

R, 65 bytes
-1 byte thanks to Giuseppe.
n=scan();while(T<2*n){cat(rep(+T,n%/%T),if(n%%T)n%%T,"\n");T=2*T}

Try it online!
Avoids recursion. In R, %/% is integer division and %% is the modulo. For each power of 2 k=2^i, we need to print n%/%k times the value k, and then n%%k if that value is non zero. Do this for all powers of 2 smaller than \$2n-1\$.
Here I am using T instead of k, since it is initialized as TRUE which is converted to 1. I still need to print +T instead of T to avoid a vector of TRUEs in the output.

Beat me by about 5 minutes and almost 60 bytes... But Giuseppe is right, it doesn't output the final step.

@Sumner18 Should be fixed now.

+T is shorter than T+0

@Giuseppe Thanks, I knew I was forgetting something.

Japt -R, 13 bytes
_ò mx}hUõÎü)â

Try it

Brachylog, 17 bytes
;1j₍ẹẉ₂{ġ₂+ᵐ}ⁱ.ẉȮ

Try it online!
As horribly long as this is, I still feel a bit clever for using .ẉȮ: the obvious way to print something, then check if its length is 1 would be ẉ₂l1, ẉ₂~g, or ẉ₂≡Ȯ, where the ≡ in the last one is necessary because ẉ₂ unifies its input and output before it prints them, and Ȯ is pre-constrained to be a list of length 1, so the unification fails if the input is not a list of length 1. At the end of a predicate, this feature of ẉ₂ can be circumvented, however, by using the output variable instead of subscripting ẉ: .ẉȮ first unifies its input with the output variable, then prints the output variable, and only afterwards unifies the output variable with Ȯ.

Stax, 10 bytes
Çë⌐ⁿ┤5π»Å╡

Run and debug it
Procedure:

Generate 0-based range.
Repeatedly halve each element until all items are zero.
Calculate run-lengths for each unique array.

Annotated Source:
r       main:[0 .. 5]
{{hmgu  main:[[0 .. 5], [0, 0, 1, 1, 2, 2], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0]]
m:GJ    main:"1 1 1 1 1 1"

Haskell, 75 bytes
g.pure
g x|x!!0<2=[x]|1>0=(g$(\z->filter(0/=)[-div(-z)2,div z 2])=<<x)++[x]

Try it online!
Works backwards from the list [n] until it reaches a list of just ones.
Going forwards, I could get 80 bytes using chunksof from Data.List.Split:
import Data.List.Split
f x=g$1<$[1..x]
g[n]=[[n]]
g x=x:(g$map sum$chunksOf 2 x)

Try it online!

Jelly, 6 bytes
-1 byte thanks to Erik the Outgolfer.
1x+2/Ƭ

Try it online!

Charcoal, 19 bytes
ＮθＩＥ↨⊖⊗θ²Ｅ⪪Ｅθ¹Ｘ²κＬλ

Try it online! Link is to verbose version of code. Uses Charcoal's default output format, which is one number per line, with subarrays double-spaced from each other. Explanation:
Ｎθ                  Input `n` into a variable
       θ            `n`
      ⊗             Doubled
     ⊖              Decremented
    ↨   ²           Converted to base 2 (i.e. ceil(log2(input)))
   Ｅ                Map
           Ｅθ¹      List of `1`s of length `n`
          ⪪         Split into sublists of length
               ²    Literal `2`
              Ｘ     To power
                κ   Loop index
         Ｅ          Map over each sublist
                 Ｌλ Take the length
  Ｉ                 Cast to string for implicit print

Perl 5, 46 bytes
say$_="1 "x<>;say while s/(\d+) (\d+)/$1+$2/ge

Try it online!
Output is space separated.

Perl 6, 38 bytes
{1 xx$_,*.rotor(2,:partial)>>.sum...1}

Try it online!
There's some shortcut to partial rotoring that I'm not remembering right now...
Explanation:
{                                    }  # Anonymous code block
                                 ...    # Return a sequence
 1 xx$_,            # Starting with a list of 1s with input length
        *           # Where each element is
         .rotor(2,:partial)        # The previous list split into chunks of 2 or less
                           >>.sum  # And each chunk summed
                                    1  # Until the list is length 1

Keg, 30 bytes
(|1){!1>|^(:. ,")^
,(!2/|+")}.

Try it online!
I've actually been meaning to complete this challenge for a while (I mean, I emailed myself the link to it so I would remember), but I've never gotten around to doing so until now!

GolfScript, 24 bytes
A horribly long answer... golfed out 1 byte by using a hard-to-read output format
~[1]*{..2/{{+}*}%\,(}do;

Try it online!
Explanation
~                        // Dump the contents of the input string
 [1]*                    // Create a 1-list with the length of the input string
     {              }do  // do ... while
                 \,(     // the length of the array is larger than 1
      .                  // Extra evolution step that we need to keep
       .                 // Create a copy of the input
        2/               // That splits into parts of 2 items
          {    }%        // For each over the splitted array:
           {+}*          // Reduce the item with addition
                         // e.g. [1] -> [1], [1 2] -> [3], etc.
                       ; // Discard the abundant copy

APL, 28 chars
{1≢≢⎕←⍵:∇+/(⌈.5×≢⍵)2⍴⍵,0}⍴∘1

vector of 1s
⍴∘1

output the argument and check if length is different than 1: if so, go on
1≢≢⎕←⍵:

get half of the length and round up
⌈.5×≢⍵

reshape into a nx2 matrix adding a trailing 0 if needed
(⌈.5×≢⍵)2⍴⍵,0

sum of row by row
+/

recurse
∇

https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@/2vBR5yIQ6pv6qG3Co96tVo862rX1NR71dOiZHp4Okundqmn0qHcLkNYxqAUxOmYYPupaZGj6/z8A

V (vim), 93 bytes
:s/1\n/a
D@"i1 <esc>
qqYplllA]<esc>0i[<esc>:s/\(\d\+\) \(\d\+\) /\1+\2,/g
C<c-r>=<c-r>"
<Esc><c-o>V}J0i <esc>@qq@qdd:s/ i1/1

Try it online!
Special casing 1 for <c-o> was a bit annoying, but the rest plays out smoothly.
Possible byte saves can be in the large regex, and maybe removing the 1 special case.
Outputs as space separated lists.

Vyxal, 7 bytes
1ẋ≬2ẇṠ↔

Try it Online!
1ẋ      # n 1s
      ↔ # Collect while unique:
  ≬---  # Next three as function
    ẇ   # Cut into chunks of length
   2    # 2
     Ṡ  # Sum each chunk

Gaia, 12 bytes
ċ)¦⟨:q2/Σ¦⟩ª

Try it online!
ċ)¦		| generate array of n 1's (really, generate array of n 0's and increment each)
   ⟨      ⟩ª	| do the following until you get to a fixed point:
    :q		| dup and print with a newline
      2/	| split into groups of 2, with last group possibly being smaller
	Σ¦	| take the sum

Ohm v2, 8 bytes
@Dv·Ω2σΣ

Try it online!
If output in scientific notation is allowed, otherwise:
Ohm v2, 9 bytes
@Dv·Ω2σΣì

Try it online!

If the scientific notation numbers are actually a natural number type (such as floats) in Ohm then sure, it's reasonable.


text:
Who was president of the USA?
Challenge
Write a program that takes as input a day from April 30, 1789 to August 21, 2019 and returns as output who was president of the USA that day.
Notes
For the list of US presidents, the format of their names, and the period of their presidency, see below:
April 30, 1789 - March 4, 1797          George Washington
March 4, 1797 - March 4, 1801           John Adams
March 4, 1801 - March 4, 1809           Thomas Jefferson
March 4, 1809 - March 4, 1817           James Madison
March 4, 1817 - March 4, 1825           James Monroe
March 4, 1825 - March 4, 1829           John Quincy Adams
March 4, 1829 - March 4, 1837           Andrew Jackson
March 4, 1837 - March 4, 1841           Martin Van Buren
March 4, 1841 - April 4, 1841           William Henry Harrison
April 4, 1841 - March 4, 1845           John Tyler
March 4, 1845 - March 4, 1849           James K. Polk
March 4, 1849 - July 9, 1850            Zachary Taylor
July 9, 1850 - March 4, 1853            Millard Fillmore
March 4, 1853 - March 4, 1857           Franklin Pierce
March 4, 1857 - March 4, 1861           James Buchanan
March 4, 1861 - April 15, 1865          Abraham Lincoln
April 15, 1865 - March 4, 1869          Andrew Johnson
March 4, 1869 - March 4, 1877           Ulysses S. Grant
March 4, 1877 - March 4, 1881           Rutherford B. Hayes
March 4, 1881 - September 19, 1881      James A. Garfield
September 19, 1881 - March 4, 1885      Chester A. Arthur
March 4, 1885 - March 4, 1889           Grover Cleveland
March 4, 1889 - March 4, 1893           Benjamin Harrison
March 4, 1893 - March 4, 1897           Grover Cleveland
March 4, 1897 - September 14, 1901      William McKinley
September 14, 1901 - March 4, 1909      Theodore Roosevelt
March 4, 1909 - March 4, 1913           William Howard Taft
March 4, 1913 - March 4, 1921           Woodrow Wilson
March 4, 1921 - August 2, 1923          Warren G. Harding
August 2, 1923 - March 4, 1929          Calvin Coolidge
March 4, 1929 - March 4, 1933           Herbert Hoover
March 4, 1933 - April 12, 1945          Franklin D. Roosevelt
April 12, 1945 - January 20, 1953       Harry S. Truman
January 20, 1953 - January 20, 1961     Dwight D. Eisenhower
January 20, 1961 - November 22, 1963    John F. Kennedy
November 22, 1963 - January 20, 1969    Lyndon B. Johnson
January 20, 1969 - August 9, 1974       Richard Nixon
August 9, 1974 - January 20, 1977       Gerald Ford
January 20, 1977 - January 20, 1981     Jimmy Carter
January 20, 1981 - January 20, 1989     Ronald Reagan
January 20, 1989 - January 20, 1993     George H. W. Bush
January 20, 1993 - January 20, 2001     Bill Clinton
January 20, 2001 - January 20, 2009     George W. Bush
January 20, 2009 - January 20, 2017     Barack Obama
January 20, 2017 - Incumbent            Donald Trump

A presidency is intended as first day included and last day excluded. For example, "March 4, 1861 - April 15, 1865; Abraham Lincoln" means that Lincoln was president from March 4, 1861 to April 14, 1865.
This is code-golf, the shortest program in each language wins.
Example
Input: "February 7, 1865" Output: "Abraham Lincoln"

Hi there, welcome to CGCC! This looks like a nice challenge, but all challenges should be self-contained. Instead of the Wikipedia link, please have a list here of all presidents and their periods (preferably in code-block, so a scroll-bar will appear). Also, I recommend having a flexible input-format, so people could input as a string in whatever format, three loose integers, a date object, etc. how they see fit in their language of choice.

Also, for future challenges, it's best to first post them in the Sandbox of Proposed Challenges. There you can get feedback and make the challenge better, before posting it to main. Enjoy your stay! :)

@KevinCruijssen OK

Great! I took the liberty to format the post a bit, and added some more relevant tags.  +1 from me, though. Nice first challenge.

@KevinCruijssen Is this really a [decision-problem]?

@EsolangingFruit Tbh, I'm not 100% sure. I saw [decision-problem] as a challenge where you get a certain input, and based on some checks, have a specific (hard) output. In this case it would be the checks by date, and outputting the hardcoded president-names. But maybe I'm misunderstanding the tag..

@KevinCruijssen I believe this would be a decision problem if you were also given a president and had to determine whether the pairing was correct. As it is, it isn't really about deciding anything; it's more about information compression, so I've removed the tag.

@FryAmTheEggman Sounds good, sorry for the confusion. :)

How flexible is the IO format?

"Write a program that takes as input a day from April 30, 1789 to August 21, 2019" - so taking the day as a single integer rather than a date is OK I assume? (i.e. 1 being April 30, 1789 and 84098 being August 21, 2019). Answers are already taking YYYYMMDD strings, so I also assume that is also OK?

WolframAlpha["president on "<>#]& I'm sure pure Mathematica has a builtin somewhere but until I find what it's called I'm sticking with W|A.

@Pavel in that case make it WolframAlpha["US president on "<>#]& cause for me the output is not correct

I don't think [tag:kolmogorov-complexity] applies either, since the output depends on the input. I think it would apply if the challenge were just "output a list of presidents and their terms"

@jonatjann answers are allowed to depend on the environment. In this case, geographical location. My suggestion would be to post both alternatives in the same answer.

PHP, 936 bytes
for($a=explode('-',gzinflate(base64_decode('dVTRbtswDPwV/YANKXZq+zFJ1wRts3VZtgB7Y2Mm1ipLAO0089+PtNIuHbAnAzySd+RRNkVZ6XxSJUsMdES1g66x/tgHn5iiKnSms+Q+NF7Nami7xJTajLFtE1ro1D0eDkidZJe6itnQYqfWUNsYNsV1OHgKyNHJ9G/rryfr98M7wyT2mfma8KzuYf8SG2Wx0Rqot179AK/mJ0JB8qhpZ52z0KoVehrUCoguEhjP38i2g0OS2PRK1kOqnoJ7kXAk/wn7BrjJFgYXJH2qdaHLZM0UQLW6428bSCaZZmPFHYF/cSzsySLtR+B68PmJG3oQNTdR7eyZoGG1jzx8cCMw1bnJ3wdntVH+TdT03Q1dx62+pWrJZD0jRaTYnPoG6RBY2DzlwQeUPZbmin/GRUAHi66OUGXKZNFg1yMJOKO+OcmgZdzLksIrIwuHr+jAj0VRxhz9L2h50KsFV9n/ii4n9GbNev9gvcMhMZUWDXJIGGrepNqE0EldL1j10dBwlqVv4SCgiWS7EGoKZ8VJo4hqcrkCloVeLWURVPMtC5RpPtxkAe6VhS9CcLY+ogCRaIX0jNQzkQzA8ewfU2/TD/pyccoksoFB/NjSqRVvKz4GY6rk9myPTS9Vn2yHvgnnsSs7L+h4h3epekDvsZZd3GTGTEzyOPg6ePHw3fyKzZeajZWDrNVn+3sMFzlPVPKrJXB8jmy9BIvY37btoBb8TkbWMrJugpfUDcJxlFrGxpd3v0rVLuUr7RqGqjjFnNfPZlovf4OJ1ua64C2b47HRHIifqvryDC1w1EQtfwA=')));$d=$a[+$i++];)date(Ymd,strtotime($argn))>$d?$m=$a[$i++]:die($m);echo'Donald Trump';

Try it online!

Tests:
Try it online!
The code for tests is the same logic but a little bit different to replace the die(...) with return... so I can loop over tests.

I have created a string having start date of presidency minus 1 day in format of YYYYMMDD and name of president in it, separated by -. Example: 17890429-George Washington-17970303-John Adams-18010303-Thomas Jefferson-...
This string is compressed using gzdeflate and also the compressed output is converted to base-64 so all characters are printable ASCII and I can post them here or use them in TIO.
In the script, the string is split by - and looped over. For each loop iteration:

$d is set to current iteration value (which is the president's start date -1 day) and the loop variable ($i) is increased by one.
If input date is larger than $d, then $m is set to next iteration value (which is the president name for $d) and the loop variable ($i) is increased by one again. This allows the loop to get president names but jump over them in iterations.
If input date is not larger than $d, then that means the previous iteration was the correct president, so $m is printed using die function, this will stop the whole program after printing the name.

At the end, if the loop is finished (which means no die was called), the last president's name is printed, since we know non of previous presidents have got a match (so basically anything after January 19, 2017) prints last president's name, even if it is January 1, 3999.

save 20 bytes by replacing your gz string with https://gist.github.com/007/b40b52da40b454d2196d0a807a6fcfaf

I don't know PHP, but can you remove the base64 and insert the raw unprintable characters (you can supply a hexdump).

@RyanMoore, thanks for the better compressed string, sadly I'm not in control of this answer anymore and my purpose which got many up-votes (and some down-votes too) has been removed from it (in this revision). So I'm not going to edit or golf this answer anymore even though there are still some golfing possibilities for it.

@MilkyWay90, that is completely possible. But I posted this version purposefully to have a readable code here and TIO links. Basically this wasn't meant to be a hard-core answer.

Bash, 1229 1124 bytes
-103 bytes with @GammaFunction's excellent comments, removing a couple of unproductive substitutions (Adams), and refactoring the code to use the date offset from the previous date rather than the absolute date for each presidency.
M=(. Ja F Mar Ap May Jun Jul Au S O N D)
A=40000
B=80000
s=son
a=James
c=Andrew
d=William
e=Harri$s
f=Franklin
g=George
h=Grover#Cleveland
i=Roosevelt
j=John
k=#W.#Bush
X="304:$g#Washington
$A:$j#Adams
$B:Thomas#Jeffer$s
$B:$a#Madi$s
$B:$a#Monroe
$A:$j#Quincy#Adams
$B:$c#Jack$s
$A:Martin#Van#Buren
100:$d#Henry#$e
39900:$j#Tyler
$A:$a#K.#Polk
10405:Zachary#Taylor
29595:Millard#Fillmore
$A:$f#Pierce
$A:$a#Buchanan
40111:Abraham#Lincoln
39889:$c#$j$s
$B:Ulysses#S.#Grant
$A:Rutherford#B.#Hayes
615:$a#A.#Garfield
39385:Chester#A.#Arthur
$A:$h
$A:Benjamin#$e
$A:$h
40610:$d#McKinley
79390:Theodore#$i
$A:$d#Howard#Taft
$B:Woodrow#Wilson
20598:Warren#G.#Harding
59402:Calvin#Coolidge
$A:Herbert#Hoover
120108:$f#D.#$i
79708:Harry#S.#Truman
$B:Dwight#D.#Eisenhower
21002:$j#F.#Kennedy
58998:Lyndon#B.#$j$s
50789:Richard#Nixon
29211:Gerald#Ford
$A:Jimmy#Carter
$B:Ronald#Reagan
$A:$g#H.$k
$B:Bill#Clinton
$B:$g$k
$B:Barack#Obama"
T=($1)
D=0${T[1]%,}
for((;;)){ [[ $T =~ ${M[++i]} ]]&&break;}
N=0$i
S=$[${T[2]}-1797]${N: -2}${D: -2}
for z in $X;{ O=$[O+${z%:*}];[ $S -lt $O ]&&z=${z//#/ }&&echo ${z#*:}&&exit;}
echo Donald Trump

Try it online!
A lot of manual compression :)

A few more: Get rid of X=($X), looping as for z in $X will split $X on $IFS. Use [ -lt ], and use $T instead of ${T[0]}. Last few lines, overall should be 1191 bytes

1092! I simplified the month parsing (for example, if we've passed June and it starts with a J, it must by July. I also changed the test to [ ${T#${M[++i]}*} ]. Now we can leave off December completely). I also included the leading : on a few of the names (doing this for :John meant making all delimiters : instead of #).

T-SQL, 1169 981 979 977 bytes
Holy cow, I figured out string compression in SQL (available in SQL 2016 and above):
SELECT TOP 1 STUFF(value,1,8,'')
FROM d,STRING_SPLIT(
    CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAHVT23LaMBD9FX1AxiMZg+1HIAWGhDaltMz0bYMXrEaWOmsc6r/vrpw27kOHB8ZnL+fs2VWqTa6NKe+DB1epA3XNz7tU61LABRCcXtSnZ2hAQCPgGgNdUB0Tteja+s6U5STmWufU0ll/DZ7BohzlbpJRehG77Ae+PcIFJD+PKra2aXq1BLoiCZjpQhdrJEldBaoYm8XGe3uqgSr10f6KdLOJMal57H0VvFokahtq3w6RSCffapWoB/Qeq57xaVR9f7OX+qruE/XBtujrcIvE2VRnxmyAqFdfkuhKVDmZaP6tCPwLTypl+xBafEV35WhaSnSD9Ix0VZsQXmOzdMJTmCW4Vy5ZhuBsdUHBjaQfmQS9WieK6SrrLxwxkeYYQkXhpo7WDaPo2J8/nYWG+9/EgQOchZt3w2WHGkMVCMeyijIfl+1OD9Y77CUQadYkOnl1kg+ePS6KSLRA/wMa1iw+2CihKKb/KxH+Ylljy6tT80TN6Vp3NES4ZAsNtoKvgc4WndTkUdi+u9ZIZ96uLG4DPbYcm0UJX13ftlzHO1iz6TLNTFaTzX1FeHtfczGLLPNngpqHfLT+FJzg0/ydfdHx0XiI8L+LfLJIJxRc61wXO/ZKvF3xf8N2ciCLer6DnF3PpvcuyHDZ9L39Q6KegnsR1OiMUbm5Q++QBmi8O/TcZeTrJMrc8eGzmm/AN9zxVXBguKk/4/JrHPLTgVcYPnc8bK/mFTRinBkNvAuegqgfLucNhOqNVEdNhzo00Kotns9IMZAPFxO7v7XN+SSy9O/bh7bmS+WX/hut0W9jPwQAAA=='as XML).value('.','varbinary(max)'))AS varchar(max)),',')
WHERE LEFT(value,8)<i

Doesn't save quite as much as I hoped it might, probably due to the amount of code it takes to convert/deconvert.
Here is the original version, which is equivalent to the code that runs after the encoded string is decompressed (1169 bytes):
SELECT TOP 1 SUBSTRING(value,9,99)
FROM d,STRING_SPLIT(
    '20170119Donald Trump,20090119Barack Obama,20010119George W. Bush,19930119Bill Clinton,19890119George H. W. Bush,19810119Ronald Reagan,19770119Jimmy Carter,19740808Gerald Ford,19690119Richard Nixon,19631121Lyndon B. Johnson,19610119John F. Kennedy,19530119Dwight D. Eisenhower,19450411Harry S. Truman,19330303Franklin D. Roosevelt,19290303Herbert Hoover,19230801Calvin Coolidge,19210303Warren G. Harding,19130303Woodrow Wilson,19090303William Howard Taft,19010913Theodore Roosevelt,18970303William McKinley,18930303Grover Cleveland,18890303Benjamin Harrison,18850303Grover Cleveland,18810918Chester A. Arthur,18810303James A. Garfield,18770303Rutherford B. Hayes,18690303Ulysses S. Grant,18650414Andrew Johnson,18610303Abraham Lincoln,18570303James Buchanan,18530303Franklin Pierce,18500708Millard Fillmore,18490303Zachary Taylor,18450303James K. Polk,18410403John Tyler,18410303William Henry Harrison,18370303Martin Van Buren,18290303Andrew Jackson,18250303John Quincy Adams,18170303James Monroe,18090303James Madison,18010303Thomas Jefferson,17970303John Adams,17890429George Washington',',')
WHERE LEFT(value,8)<i

Line breaks are for readability only.
Input is taken from pre-existing table \$d\$ with INT field \$i\$, per our IO rules. Input date is formatted as an 8-digit number YYYYMMDD.
A few tricks I used to save bytes:

I sorted the presidents descending so I didn't have to add an ORDER BY to the code
I subtracted 1 in the "start" date of each term, so I could use < instead of <=
String-split is much shorter than a big list of VALUES() would be, even though I have to then break the string apart with SUBSTRING and LEFT.
EDIT: Saved 2 bytes by changing SUBSTRING() to STUFF()

Using Base64-encoded compressed strings in SQL
(Added to SQL Tips thread)
So Microsoft added a COMPRESS and a DECOMPRESS function back in SQL 2016, which handles the GZIP; the problem is that it returns a VARBINARY, which although shorter in bytes (when stored in a SQL VARBINARY field), is longer when displayed in characters (raw hex), which makes it unsuitable for golfing.
Converting to Base64 is clearly the answer, but finding a short, simple implementation was a challenge. I based my version off of this old answer on SO, which gives us most of what we need, although it doesn't use the new GZIP functions. I just had to insert the new functions into the right place, and golf it down a bit.
To use this method in your own code:
--Run this to generate your compressed string:
DECLARE @s VARCHAR(MAX)='Your really long string goes right here'
SELECT CONVERT(VARCHAR(MAX),(SELECT CONVERT(VARBINARY(MAX),COMPRESS(@s))FOR XML PATH(''),BINARY BASE64))

--Use your compressed string and the following code to get back to the original:
DECLARE @e VARCHAR(MAX)='H4sIAAAAAAAEAIvMLy1SKEpNzMmpVMjJz0tXKC4pygRS6fmpxQpFmekZJQoZqUWpAGGwW5YnAAAA'
SELECT CAST(DECOMPRESS(CAST(@e as XML).value('.','varbinary(max)'))AS varchar(max))

That's 75 73 extra bytes of code to decompress an encoded string, so clearly only use this for very long strings.
EDIT: Saved 2 bytes in the decompress code with CAST instead of CONVERT.

Excel, 1243 1206 1180 bytes
-37 bytes by subtracting from all the dates
-26 bytes by by fiddling with the subtraction values
=CHOOSE(MATCH(A1-65^4,{39805,119679,159679,239679,319679,399679,439679,519679,559679,559779,599679,639679,650084,679679,719679,759679,799790,839679,919679,959679,960294,999679,1039679,1079679,1119679,1160289,1239679,1279679,1359679,1380177,1439679,1479679,1599787,1679495,1759495,1780497,1839495,1890184,1919495,1959495,2039495,2079495,2159495,2239495,2319495}),"George Washington","John Adams","Thomas Jefferson","James Madison","James Monroe","John Quincy Adams","Andrew Jackson","Martin Van Buren","William Henry Harrison","John Tyler","James K. Polk","Zachary Taylor","Millard Fillmore","Franklin Pierce","James Buchanan","Abraham Lincoln","Andrew Johnson","Ulysses S. Grant","Rutherford B. Hayes","James A. Garfield","Chester A. Arthur","Grover Cleveland","Benjamin Harrison","Grover Cleveland","William McKinley","Theodore Roosevelt","William Howard Taft","Woodrow Wilson","Warren G. Harding","Calvin Coolidge","Herbert Hoover","Franklin D. Roosevelt","Harry S. Truman","Dwight D. Eisenhower","John F. Kennedy","Lyndon B. Johnson","Richard Nixon","Gerald Ford","Jimmy Carter","Ronald Reagan","George H. W. Bush","Bill Clinton","George W. Bush","Barack Obama","Donald Trump")

Input is in cell A1 with the format YYYYMMDD since Excel doesn't like dates before 1900.
I don't know of a compression method for the dates or names that wouldn't add more bytes. The "subtract [value] from all the dates" method could apply to anybody's solution.

I found a 1102 bytes solution in Google Sheets using the same principle. Excel doesn't have the Split function so it's not translatable.
=Index(Split("George Washington,John Adams,Thomas Jefferson,James Madison,James Monroe,John Quincy Adams,Andrew Jackson,Martin Van Buren,William Henry Harrison,John Tyler,James K. Polk,Zachary Taylor,Millard Fillmore,Franklin Pierce,James Buchanan,Abraham Lincoln,Andrew Johnson,Ulysses S. Grant,Rutherford B. Hayes,James A. Garfield,Chester A. Arthur,Grover Cleveland,Benjamin Harrison,Grover Cleveland,William McKinley,Theodore Roosevelt,William Howard Taft,Woodrow Wilson,Warren G. Harding,Calvin Coolidge,Herbert Hoover,Franklin D. Roosevelt,Harry S. Truman,Dwight D. Eisenhower,John F. Kennedy,Lyndon B. Johnson,Richard Nixon,Gerald Ford,Jimmy Carter,Ronald Reagan,George H. W. Bush,Bill Clinton,George W. Bush,Barack Obama,Donald Trump",","),Match(A4-65^4,{39805,119679,159679,239679,319679,399679,439679,519679,559679,559779,599679,639679,650084,679679,719679,759679,799790,839679,919679,959679,960294,999679,1039679,1079679,1119679,1160289,1239679,1279679,1359679,1380177,1439679,1479679,1599787,1679495,1759495,1780497,1839495,1890184,1919495,1959495,2039495,2079495,2159495,2239495,2319495}))

I don't know Excel too well (and my local Excel is Dutch, so I'm unable to verify), but is this correct? Doesn't this look for an exact match instead of a lower-than match for the dates? Would this output anything for let's say 19000101?

@KevinCruijssen Nope, MATCH() has an optional 3rd argument match_type that determines whether to use exact match. Excluding that argument uses the default, which is a "less than or equal to" match, so this code is correct.

@BradC Ah, didn't knew that. Thanks for explaining! +1 from me. :)

Nice trick with subtracting a fixed value from each, I'll have to see if it helps mine too.

05AB1E, 587 584 568 bytes
.•6}©ß þz∊‘Îнúj7a>º ·,$_+šüÑßu?PδIëàá©ā.ǝ/¬j«Ížr‹þVwô¨"¶&ˆ₃ǝαh^¼ì∞öîNÊÌ.ÚáýиÇ÷©Mèé…—¾…тŒ¹/ÈÂÓŒš/«ª³PÉÇJúΓÁ¦';X·₅ï»/„q<ƶÚÙÊtÔιuš2βƒ¼ï\~ö…3ihD·¢ðΘmζ8É9Ïγ=^$¨Ä₆ËÂÊPv5+}þ¯ÑX4hÖdÀÒuàнº₁›ǝΘ³P@¥ùnðT“É)ó_“:Èx³«äƒæ¤∞Wgþ¶š}ô|ićcÁ‘.·ƒp>Z¬Aéγê‰ù‰¥Ó₃#/›pÐT¹Â¹J3—ΛΓkÙ»(áÌ›₃z@ìqW›Â"™raÒ›₂%ïx{
_Ωb≠¹₁Ä¾ÊÌ›}çºô|ôëKÝǝÚï,‚£=A©áāY∊~"KøVóΓyΛJÚΘ·ˆUΩ₂TнîëнÐQнĆ!!¶%Ý₃ó¸ß0ûиî€AvÙ∍Õ
'«₂θSè‡H¿ÏLôǝāqaмÑIƶ%ŸSdUbåÐÉιδJ¯4₆>θçàƶñwC¨OVÀàczdRæs?5ʒP8“ƒÍÜðαŸÝf,ƒη,™`ÿeиäƵθC≠ýzX‡)и∞úø+þćÎÌвĆæŒ±ðí1•™„qz„K.‡„  ¡•gpöz&»XZ1rć¾{¦¯Û¿p~Θø•Ƶaв₄R«•e½òœu#ÈĆÔFƵ•Ƶ`вŽcƵ«•9…åœòFýLÂ]FÜÔĀ=Ƶ®5¿ùK»Ωм••Rwg•в««•1L₄Æ•+I‹Oè

Input is a concatenated date in the format yyyyMMdd (i.e. 20190821 for August 21, 2019).
-16 bytes thanks to @Grimy.
Try it online or verify a few more test cases.
Explanation:
We start by creating a list of the presidents in chronological order:
.•6}©...ðí1•            # Push compressed string "george washington  john adams  thomas jefferson  james madison  james monroe  john quincy adams  andrew jackson  martin van buren  william henry harrison  john tyler  james kz polk  zachary taylor  millard fillmore  franklin pierce  james buchanan  abraham lincoln  andrew johnson  ulysses sz grant  rutherford bz hayes  james az garfield  chester az arthur  grover cleveland  benjamin harrison  grover cleveland  william mcqinley  theodore roosevelt  william howard taft  woodrow wilson  warren gz harding  calvin coolidge  herbert hoover  franklin dz roosevelt  harry sz truman  dwight dz eisenhower  john fz kennedy  lyndon bz johnson  richard nixon  gerald ford  jimmy carter  ronald reagan  george hz wz bush  bill clinton  george wz bush  barack obama  donald trump"
™                       # Titlecase each word in the string
„qz„K.‡                 # Replace all lowercase "q" with "K" (for McKinley),
                        # and all lowercase "z" with "."
                        # (only lowercase letters and spaces can be compressed as string)
„  ¡                    # Split the string on "  " (two spaces)

Then we create a list of all dates as integers in the format yyyyMMdd (order is irrelevant for this list):
•gpöz&»XZ1rć¾{¦¯Û¿p~Θø• # Push compressed integer 57036763189461803778321913240836786322696217070172
  Ƶa                    # Push compressed integer 137
    в                   # Convert the large integer to base-137 as list:
                        #  [4,12,20,28,32,40,44,48,52,56,60,64,72,80,84,88,92,96,100,112,116,124,132,136]
     ₄R                 # Push 1000, and reverse it to "0001"
       «                # And concat it to each item:
                        #  [40001,120001,200001,280001,320001,400001,440001,480001,520001,560001,600001,640001,720001,800001,840001,880001,920001,960001,1000001,1120001,1160001,1240001,1320001,1360001]
                        # (this is for all the March 4th dates)
•e½òœu#ÈĆÔFƵ•           # Push compressed integer 47362342587646909879438102
  Ƶ`                    # Push compressed integer 223
    в                   # Convert the large integer to base-223 as list:
                        #  [155,163,171,179,183,191,195,203,211,219,222]
     ŽcƵ                # Push compressed integer 9817
        «               # And concat it to each item:
                        #  [1559817,1639817,1719817,1799817,1839817,1919817,1959817,2039817,2119817,2199817,2229817]
                        # (this is for all the January 20th dates)
•1åŽ¨£ÆÊÂç-i∞YúΛÈ¾EW½Ω≠tW•
                        # Push compressed integer 42494608868313599134973321717434089414197466371857150907
  •Rwg•                 # Push compressed integer 1770507
       в                # Convert the large integer to base-1770507 as list:
                        #  [440101,530406,680112,840616,1040611,1260499,1480109,1660819,1770506]
                        # (these are the remaining dates; i.e. those who died earlier)
««                      # Merge the three lists together:
                        #  [40001,120001,200001,280001,320001,400001,440001,480001,520001,560001,600001,640001,720001,800001,840001,880001,920001,960001,1000001,1120001,1160001,1240001,1320001,1360001,1559817,1639817,1719817,1799817,1839817,1919817,1959817,2039817,2119817,2199817,2229817,440101,530406,680112,840616,1040611,1260499,1480109,1660819,1770506]
  •1L₄Æ•                # Push compressed integer 17970302
        +               # Add it to each item in the list:
                        #  [18010303,18090303,18170303,18250303,18290303,18370303,18410303,18450303,18490303,18530303,18570303,18610303,18690303,18770303,18810303,18850303,18890303,18930303,18970303,19090303,19130303,19210303,19290303,19330303,19530119,19610119,19690119,19770119,19810119,19890119,19930119,20010119,20090119,20170119,20200119,18410403,18500708,18650414,18810918,19010913,19230801,19450411,19631121,19740808]

Then we use the input to determine the output president-name based on the dates in the list:
I‹                      # Check for each value in the integer-list if the Input is smaller
                        # (1 if truthy; 0 if falsey)
  O                     # Sum these to get the amount of truthy values
   è                    # And use that to (0-based) index into the president-names list
                        # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress strings not part of the dictionary?, How to compress large integers?, and How to compress integer lists?) to understand how all the compressed string, integers, and lists work.

@Grimy I couldn't really copy it, so had to compress it myself again after I saw what you did. I checked every president name, and all letters were taken. But nice way to save bytes by first titlecasing, and then using lowercase letters which aren't present anymore to convert to the dots and uppercase letter. Thanks for -16!

Lots of those names are dictionary words, which leads to large improvements. As a start, here's -32

@Grimy Will perhaps try that approach somewhere next week. Currently about to eat, and tomorrow I'm way to busy with work due to a deadline.

464. This is still improvable, but I don't think it can beat Jelly's 426. Their string compression is just better.

Jelly,  431 428 427  426 bytes
“¡Ẹị’ḃ4ż“ƓĠƒƝƊ!ɓa(‘ḅ⁹
“FQIȥ’ḃ8Ėẋ/€<8ż¢F1,303yo119
“f×Ð<Mk7LqƇ%_¡¤cċ⁴ẏ’Do13’⁽¤.;Äż¢ḅȷ4<VSị“¡ṀÑṅyȮÇæjRṂ~ɠƥ⁺'Ḃġ"Ƈ~Ị'9ƒȮṃ$ḶPȯṅṡḊl¥JƊ€ẊḥSṣọwɦṡ5ėṂU #Fɲẓ÷iḄþ%~%ñçŒfƒƙɼ=ɓ⁼¡⁻Q`⁵¡ḍ36)żȥÑR\ḋ⁾ḶƤ0ÞṘḳ÷¦IṂ\}ƊĊÐḳŻƈɦ!zɠ⁺ƈṖṭW⁸ƥṛU|ḄØ^ẓfḂḣƈCȦ8ɱḤH⁵AKṢzȯỵƭḊ:TʠƬ/~ƝÑȥgṖ(ṁȯDƲṫỴftlBOȧ6Ụiṃıẉ_ƈvh5ṄUɓạẓDẠẸıṣƥ"bçȥ¿çOġQẹİẊẸs*⁶ż,Ḍg®ƲW×ɗ,ẏ¡Ḅ5M5)ṀạƈCṛʂẎŒƬwġ⁶NẠṆRƇsẊ<fŀȯ⁵øȤ\⁾.>ḋTṖĠUṇŻṬTṖræ_TçṡȤOʠƥðȦe]ƈ⁵cṆWƭƲ>`½n¿O¡ṭOþV¤ṡẊ²rdS€ė)ƘIÆ&ṙḞ¬5[pṁȥLṘVỴɠ»ḲṚƑ”.ẋṭƲ€KỴ¤

A full program accepting a string YYYYMMDD which prints the president's name.
Try it online! Or see (Kevin Cruijssen's) test-suite.
How?
“¡Ẹị’ḃ4ż“...‘ḅ⁹ - Link 1, getNonStandardEndMonthDays: no arguments
“¡Ẹị’           - base 250 literal       = 106467
     ḃ4         - to bijective base 4    = [1,2,1,3,3,3,1,4,3]
        “...‘   - code-page indices      = [147,196,158,150,145,33,155,97,40]
       ż        - zip together           = [[1,147],[2,196],...,[3,40]]
              ⁹ - built-in literal       = 256
             ḅ  - from base (vectorises) = [403,708,414,918,913,801,411,1121,808]

“FQIȥ’ḃ8Ėẋ/€<8ż¢F1,303yo119 - Link 2, getEndMonthDays: no arguments
“FQIȥ’                      - base 250 literal    = 1114518671
      ḃ8                    - to bijective base 8 = [8,2,3,3,4,3,2,2,1,7]
        Ė                   - enumerate           = [[1,8],[2,2],[3,3],[4,3],[5,4],[6,3],[7,2],[8,2],[9,1],[10,7]]
           €                - for each:
          /                 -   reduce with:
         ẋ                  -     repeat          = [[1,1,1,1,1,1,1,1],[2,2],[3,3,3],[4,4,4],[5,5,5,5],[6,6,6],[7,7],[8,8],9,[10,10,10,10,10,10,10]]
            <8              - less than 8?        = [[1,1,1,1,1,1,1,1],[1,1],[1,1,1],[1,1,1],[1,1,1,1],[1,1,1],[1,1],[0,0],0,[0,0,0,0,0,0,0]]
               ¢            - call last Link (1)  = [403,708,414,918,913,801,411,1121,808]
              ż             - zip together        = [[[1,1,1,1,1,1,1,1],403],[[1,1],708],[[1,1,1],414],[[1,1,1],918],[[1,1,1,1],913],[[1,1,1],801],[[1,1],411],[[0,0],1121],[0,808],[0,0,0,0,0,0,0]]
                F           - flatten             = [1,1,1,1,1,1,1,1,403,1,1,708,1,1,1,414,1,1,1,918,1,1,1,1,913,1,1,1,801,1,1,411,0,0,1121,0,808,0,0,0,0,0,0,0]
                 1,303      - pair literal        = [1,303]
                      y     - translate           = [303,303,303,303,303,303,303,303,403,303,303,708,303,303,303,414,303,303,303,918,303,303,303,303,913,303,303,303,801,303,303,411,0,0,1121,0,808,0,0,0,0,0,0,0]
                        119 - literal             = 119
                     o      - logical OR          = [303,303,303,303,303,303,303,303,403,303,303,708,303,303,303,414,303,303,303,918,303,303,303,303,913,303,303,303,801,303,303,411,119,119,1121,119,808,119,119,119,119,119,119,119]

“...’Do13’⁽¤.;Äż¢ḅȷ4<VSị“...»ḲṚƑ”.ẋṭƲ€KỴ¤ - Main Link: list of characters, X
“...’                                     - base 250 literal    = 5999595155245555951555559593750993764595999
     D                                    - to base 10          = [5,9,9,9,5,9,5,1,5,5,2,4,5,5,5,5,9,5,1,5,5,5,5,5,9,5,9,3,7,5,0,9,9,3,7,6,4,5,9,5,9,9,9]
       13                                 - literal             = 13
      o                                   - logical OR          = [5,9,9,9,5,9,5,1,5,5,2,4,5,5,5,5,9,5,1,5,5,5,5,5,9,5,9,3,7,5,13,9,9,3,7,6,4,5,9,5,9,9,9]
         ’                                - decrement           = [4,8,8,8,4,8,4,0,4,4,1,3,4,4,4,4,8,4,0,4,4,4,4,4,8,4,8,2,6,4,12,8,8,2,6,5,3,4,8,4,8,8,8]
          ⁽¤.                             - literal             = 1797
             ;                            - concatenate         = [1797,4,8,8,8,4,8,4,0,4,4,1,3,4,4,4,4,8,4,0,4,4,4,4,4,8,4,8,2,6,4,12,8,8,2,6,5,3,4,8,4,8,8,8]
              Ä                           - cumulative sums     = [1797,1801,1809,1817,1825,1829,1837,1841,1841,1845,1849,1850,1853,1857,1861,1865,1869,1877,1881,1881,1885,1889,1893,1897,1901,1909,1913,1921,1923,1929,1933,1945,1953,1961,1963,1969,1974,1977,1981,1989,1993,2001,2009,2017]
                ¢                         - call last Link (2)  = [303,303,303,303,303,303,303,303,403,303,303,708,303,303,303,414,303,303,303,918,303,303,303,303,913,303,303,303,801,303,303,411,119,119,1121,119,808,119,119,119,119,119,119,119]
               ż                          - zip together        = [[1797,303],[1801,303],[1809,303],[1817,303],[1825,303],[1829,303],[1837,303],[1841,303],[1841,403],[1845,303],[1849,303],[1850,708],[1853,303],[1857,303],[1861,303],[1865,414],[1869,303],[1877,303],[1881,303],[1881,918],[1885,303],[1889,303],[1893,303],[1897,303],[1901,913],[1909,303],[1913,303],[1921,303],[1923,801],[1929,303],[1933,303],[1945,411],[1953,119],[1961,119],[1963,1121],[1969,119],[1974,808],[1977,119],[1981,119],[1989,119],[1993,119],[2001,119],[2009,119],[2017,119]]
                  ȷ4                      - literal 10^4        = 10000
                 ḅ                        - from base           = [17970303,18010303,18090303,18170303,18250303,18290303,18370303,18410303,18410403,18450303,18490303,18500708,18530303,18570303,18610303,18650414,18690303,18770303,18810303,18810918,18850303,18890303,18930303,18970303,19010913,19090303,19130303,19210303,19230801,19290303,19330303,19450411,19530119,19610119,19631121,19690119,19740808,19770119,19810119,19890119,19930119,20010119,20090119,20170119]
                     V                    - evaluate (X)        (i.e. X -> YYYYMMDD)
                    <                     - less than? (vectorises)
                      S                   - sum                 (a number between 0 and 44 inclusive)
                                        ¤ - nilad followed by link(s) as a nilad:
                        “...»             -   compression of dictionary words and strings
                             Ḳ            -   split at spaces
                                     €    -   for each (part):
                                    Ʋ     -     last four links as a monad:
                               Ƒ          -        invariant under?:
                              Ṛ           -          reverse (true for initials only)
                                ”.        -        literal = '.'
                                  ẋ       -        repeat
                                   ṭ      -        tack (the part - e.g. [['A'],'.'])
                                      K   -   join (back up) with spaces
                                       Ỵ  -   split at newline characters
                       ị                  - index into (that list) (1-indexed & modular)
                                          - implicit (smashing) print

Plus One from me. This looks amazing

Thanks! Took quite a while to put together.

Jelly, 454 bytes
“¡#<Ḷ“¡D{“ß“®“c“ƒⱮ“¡“(Ȥ“u^“£“ɠn“ƒ⁺“¥“¢r“ƈ⁶“©“ƙm“¡B⁻“¤“Pẋ“ḣ¢“¡“¡ẓk“¡CẆ“¢“S¢“ėẋ“ṄỴ“t<“Œ“¦’ḃ2$¹<?€ȷ2F4ȷ4,8ȷ4ĖF¤yÄ<⁸TṪị“€`ɲ×ƥF7ȯẒ⁼ẈẎu⁻ɠṇẠẈƊ⁻QḲỌ ỊƭʠµḢƊCṾr⁻=ßạḌ`^ḌX§®tṭN£jx,ƈ=suĖɼ_ḍf9*ÆṙỊṪṄ Jʋ ȯṡẉ ỌẏⱮøÞ⁴xḤżḅñ£ṡṭʂMṚ¶ṇwıƲṁEnÄ`:®ƥʂ_xd⁶ŒĖṁƙƝg°ṂʠkṫhO5Ịḅḳ³'ø⁵aẏṄKḂẆZØ4JḌþḂ⁸⁸XlIVḤOḲØṢÐ!}?Ọ°ḲẆiḢAr`ġƘ⁸ḷ[¿T§ẓ⁵|ḍdɓ^ṭƲfỴĖġJw(Ȯ:⁺k=£ŀnṗ*'hẹḋŻZOLæØ²ẋ⁼ẏ&ı6ḣṗẈƥ¡:9D¢=G§⁴eỤ6wẈ6ṗw6⁺zOẉ}OṆƲdṃ'ıẠ£¤þ4¢1ȷfɓ.ṪpṀ⁴Ṡtṁ⁷ẇlŒ!ṠyaṪ66xvḍgġ¤goḍRẒ³żẎịṣ6ĿⱮ}ḲkƒiL²?Ḃ¿ḥƝ¤dėḤ½Ṗ,cRÐþɼ©ṢƈḅṬḊṬɠṅÞ»Ỵ¤

Try it online!
A monadic link taking as its argument the date in YYYYMMDD format and returning a string with the answer.
Test cases (borrowed from @KevinCruijssen’s 05AB1E answer).

05AB1E, 464 444 442 418 bytes
-15 or so bytes by stealing ideas from Kevin Cruijssen's answer
Crossed 444 is still 444 ):
.•J@λ
A∞‚XÃUδ„«›Æx…ΔΣ¸ÃEÛö›³;Î!¦ǝzŽ`²œ∊ïøÞ‰Cf4₆и)Kuм¹5®‹м£Ž}мNPõüïí
^ā-Ç¨åˆ[Ü_5δ³ÂBмzIΣŠÒÅÆè"²0¢₆'$Ćùù»õJ´õý¢ºн³õ?ëØØ†Dǝç.r˜èÌ•ć¡`“ŒÕ‡¹„Ð±·Ž²¿É‰Þ³×‰ÞÌ¯„Ðëìncy±·¢Œžˆ–ÄîèÿíÈ£ÎÈœ„ÐÕÀ‰Þ kz™éÿ¥•¹êardœãÿ²ÀâÓ‰Þÿã³«Æ¢Œš•ÿ—§Î¶ÿæ©‰Þ–Öÿ×œ–Ö·Š¶‹r¯ŽÇÕÈœ¶‹r¯ŽíÈÿíÈ©Æ»äft–œrow¦‹¼‰ gz†èingãŸîÁÿ²Àÿ„Ð fz½¸ÿš••Öÿéï™»»É»‰ÖŠÿŒÕÕ¹ wzŒ›‰ŽµÍŒÕ wzŒ›‹²ÿ¹Ñÿ“™„qz„K.‡#•¥ü„¨%¨₃Ó8•3в4α£ðý•9ÕS&µç©•3в±žD*•¾¹iìzÓ.+,âšÜĀ‘ó₆x.»δ•žHв«9._.¥•U<¶•+I32β‹Oè

Try it online!
Part 1: the names
There are two types of string compression in 05AB1E:

Base-27 strings encode each letter in ~0.6 bytes (technically: log(27) / log(255)), but they can only contain [a-z ] (lowercase letters and spaces).
Dictionary strings encode common English words (plus the preceding space) in 2 bytes, and all ASCII characters in 1 byte each (they're just passed through unmodified). They can also use the byte ÿ, to pop a value from the stack and embed it in the string.

We're going to use an optimal mix of both. Since switching from one encoding to
the other incurs some overhead, this is more complex than picking the shortest
encoding for each individual name. For example:

The ing in Harding Calvin takes ~1.8 bytes in base-27 vs 3 bytes in a dictionary string. But Hard and Calvin are both in the dictionary, so we end up leaving ing uncompressed inside a dictionary string.
The Herb in Coolidge Herbert Hoover takes ~3 bytes in base-27 vs only 2 in a dictionary string (since herb is in the dictionary). But neither Coolidge nor Hoover are in the dictionary, so we end up encoding Herb as base-27.

To get around the restriction that base-27 strings can only contain [a-z ], we assign special meanings to some letters. Between them, the 44 presidents use up all 26 letters, but we can still play tricks:

The only js are in dictionary words (James, Benjamin, ...), so j is free for base-27 strings.
The only q is in Quincy, so lowercase q is free
The only z is in Zachary, so lowercase z is free
The only x is in Nixon, so uppercase X is free (we don't actually make use of that)

With that said, let's look at the code.
.•J@λ
A∞‚XÃUδ„«›Æx…ΔΣ¸ÃEÛö›³;Î!¦ǝzŽ`²œ∊ïøÞ‰Cf4₆и)Kuм¹5®‹м£Ž}мNPõüïí
^ā-Ç¨åˆ[Ü_5δ³ÂBмzIΣŠÒÅÆè"²0¢₆'$Ćùù»õJ´õý¢ºн³õ?ëØØ†Dǝç.r˜èÌ•

# (The newlines are significant.) This is the base-27 string:
# "j trumpjack obamaj reaganj nixonj lyndon bzj dz roosevelt harry sz truman dwight dz eisenhowerjidge herbert hooverj mcqinley theodore rooseveltj garfieldjerford bzj ulysses szj buchananjmorejlk zacharyj buren"

ć    # extract the first character
 ¡   # split the rest on that character (a "j")
  `  # dump the list on the stack
# We now have " buren" at the top of the stack, and " trump" at the bottom.

“ŒÕ‡¹„Ð±·Ž²¿É‰Þ³×‰ÞÌ¯„Ðëìncy±·¢Œžˆ–ÄîèÿíÈ£ÎÈœ„ÐÕÀ‰Þ kz™éÿ¥•¹êardœãÿ²ÀâÓ‰Þÿã³«Æ¢Œš•ÿ—§Î¶ÿæ©‰Þ–Öÿ×œ–Ö·Š¶‹r¯ŽÇÕÈœ¶‹r¯ŽíÈÿíÈ©Æ»äft–œrow¦‹¼‰ gz†èingãŸîÁÿ²Àÿ„Ð fz½¸ÿš••Öÿéï™»»É»‰ÖŠÿŒÕÕ¹ wzŒ›‰ŽµÍŒÕ wzŒ›‹²ÿ¹Ñÿ“
# Dictionary string. All the values we just dumped on the stack are popped by `ÿ`s in this string. We end up with:
# "george washington john adams thomas jefferson james madison james monroe john quincy adams andrew jackson martin van buren william henry harrison john tyler james kz polk zachary taylor millard fillmore franklin pierce james buchanan abraham lincoln andrew johnson ulysses sz grant rutherford bz hayes james az garfield chester az arthur grover cleveland benjamin harrison grover cleveland william mcqinley theodore roosevelt william howard taft woodrow wilson warren gz harding calvin coolidge herbert hoover franklin dz roosevelt harry sz truman dwight dz eisenhower john fz kennedy lyndon bz johnson richard nixon gerald ford jimmy carter ronald reagan george hz wz bush bill clinton george wz bush barack obama donald trump"

™         # title case
 „qz      # literal "qz"
    „K.   # literal "K."
       ‡  # transliterate (replaces all "q" with "K" and all "z" with "."

# This takes care of two issues at once: title casing would leave McKinley with a lowercase k, and base-27 strings can't contain "."
# We now have a long string, with all the presidents' names in order. We need to split it into 45 strings (one per president).
# We could've used a special marker to delimit the presidents, but it turns out it's more efficient to count the words in each name:

#                  # split on spaces (yes i know i've been using # for comments, but there's no actual comment character in 05AB1E)
 •¥ü„¨%¨₃Ó8•3в     # compressed list 222221211212222221111222221212211111222202122
              4α   # vectorized absolute difference with 4: 222223233232222223333222223232233333222242322
                   # this is the list of the number of words in the presidents' names
                   # (note that "George H. W. Bush" is the only 4-word name, forcing us to use base-3 instead of base-2 for the compressed list, which costs 3 bytes)

£                  # split the list of words according to the list of wordcounts: [["George", "Washington"], ..., ["Donald", "Trump"]]
 ðý                # join each sub-list with spaces

We now have a list of the 45 full names in chronological order, so we're done with this part.
Part 2: the dates
To make it easier to compare dates, we convert them to integers. This is done with a conversion from base-32, which gives 1024 * year + 32 * month + day (and doesn't care that the year "digit" is greater than 32).
We start with a list of the number of consecutive reelections (elections that don't change the president), in reverse chronological order:
•9ÕS&µç©•3в   # compressed list 111010111011020000011000000101110

Those first three 1s correspond to Obama, Bush and Clinton all being reelected once. The lone 2 corresponds to McKinley and Theodore Roosevelt both being reelected once (McKinley died in office and Theodore Roosevelt was his vice-president, so there was no other election inbetween their reelections).
There should be a 4 in there for Franklin D. Roosevelt + Truman, but this is also the point where inauguration day changed from March 4 to January 20, so we handle this special case later.
±             # bitwise not (equivalently: add 1, then negate): [-2, -2, ..., -1]
 žD*          # multiply by 4096 [-8192, -8192, ..., -4096]

Remember that 1024 means a year, so 4096 means a full mandate. This is now a list of time deltas between newly elected presidents (still in reverse chronological order, which is why the numbers need to be negative).
Now, lets take care of the 9 presidents who didn't serve full mandates (4 died of natural causes, 4 assassinated, Nixon resigned):
•¾¹iìzÓ.+,âšÜĀ‘ó₆x.»δ•žHв   # compressed list [45088, 9317, 15270, 16548, 20475, 22484, 22410, 18666, 11155, 43819]

45088 is the time delta from March 4, 1797 (first introduction on a March 4) to April 4, 1841 (first death in office). The following numbers are time deltas between the 9 deaths/resignations. Finally, 43819 is the time delta
from August 9, 1974 (Nixon's resignation) to January 20, 2017 (latest introduction on a January 20).
«             # merge the two lists of time deltas
 9._          # rotate left by 9 (the number of January 20 introductions)
    .¥        # undelta
      •U<¶•   # compressed integer 1979491, meaning March 4, 1933 (the last March 4 introduction)
           +  # add to each

We now have a list of all dates where the president changed. The order is a bit funky: it starts in 1933, then follows March 4 introductions backwards in time, then deaths/resignations forwards in time, then goes back along the January 20 introductions. However, order won't actually matter.
I             # get the input date
 32β          # convert from base 32, yielding an integer
    ‹         # vectorized compare with our list, yielding a list of 0/1 booleans
     O        # sum
      è       # use the sum to index into the list of presidents' names
              # implicit output

And we're done.

Oh, you even beat the Jelly answer now! Very nice. Looking forward seeing an explanation.

@KevinCruijssen I added an explanation (:

JavaScript (Node.js),  855 851  803 bytes
d=>(g=i=>(p+=parseInt((a=(require('zlib').inflateRawSync(Buffer("ZVJtct0gDLwKB1A9dSaTtGfoKWSQDc+AXgS2S09f8T6cdPqDsc2utKuVv411jTC6FV4EzzO6eD53GG26vc0Wtp+3t9uhjkwn7+0dxnf6hPu5JHiJP8524mHcr7fPV3yDF+Z79XcL48em2ASy/yP+1dRCLAuZA4sPeamc4cI+G3SYClTPCYu50DyTlI5homISuvDli7Mw3cs+tpBte1RjdkKHuaBdOzuh1JDNjtlMm1CGI8QYMBlPWZrxKHLv2hvVFkkeAutgrhxX+INWSc1UbJEFkpajODPrM7EQzIJ5jSpxDSSWHtXTplUZM+Ak6FVOGZZjPu2pXJfdYitF+WUwizaqIFv1JDOrxDSovUbl0RKVgjIHig6sp1JJ+p3O5zeBRXjXCxtpp6giMFHWOvV1jvgf5RlFsr9CjtQ0eWKnQxlhLp1VP+Pio49dcdY7Zid8GMV6XwU0WLN0u+J0n2Ax7qpsmWNwC4FONJFUbdIdfEbmhi9K3WfrQVTZkibnjrD42jkUCmU10HfT1zQPZqWcyTWILTvOPapnohL6vpzJ4XefmQSjbkvzhEtIqRmrgWkj4dwBIVwwP/9HP5hj0N0VD5POrVGFXPmETwxF/y7DEyYEd2/UTV//Ag","base64"))+"").split`,`)[i],32))<new Date(d)/864e5?g(i+1):a[i+44].replace(/\b./g,c=>c.toUpperCase()))(p=0)

Try it online!
How?
The compressed string contains a list of 89 values.
The first 44 values are the length of the president mandates expressed in number of days and encoded in base 32 (which is the base that compresses best).
The next 45 values are the president names in lower case. Title-case is applied  afterwards (trick borrowed from @KevinCruijssen's answer).

Due to Title-case, McKinley outputs as "Mckinley".

@TheJim01 Thanks for reporting this. Now fixed.

SOGL, 475 bytes
⁵æ“DƧ▓«ļ¶↕Q∫<⅔∑+fQyΛ‼Bī:׀═&Sf',№═׀ΔΥκ\κΗδ=6oΡΠω«i℮ī K }½6YΨδ~░pTø№ŗ◄&Λθ▒“Æš“─{1α:C'⁰%+:"⅞“*c'⁰÷+dr"⅞“*b'«*e++>?al"t!■u↔R⅝Θνj╤←⁵κP׀λc⅜-Gc⁸׀!┐)└█5¦@T¬[@∫↕‛ρ℮↑δŗιf√³I2~Δ▓η¤⁴b¡νθ@36⅛Π└Ξ±Ƨ⅜⅓mwθ:∫^⌠≥-N\T‛V;r□τθ⁹;C{¾lΠƨUΒΡ║⁸Κ≤øΔ°?U┼S→iļ┐Kπzz∑Θ⅛%τ`ωΗ2D≡ψ_;OR⁴w≡1Z⅓ēυ%─ž′ιVJοUζķπd└≈³ΘΟ‚GR2┌═NΒθ↔T²νsσ□lQMæν÷¦Π±°≡═øΡTe¼ž⁰λ_►○³1≡№╚█λΜβΤ½<Π±Cļ¬└⁴┘čgr⁰⁄▲8|}⁸ē4№╤#√⅔d?÷≥}▼eī┼^ƧX‽>≥▼k ¹Wļm║⌠¦→┘C׀ψΠ¼⁽tΠ↔:φbεļ▓Β√⁷->→⅜O∑░=`ξε↕ņ⅛╚πBπσ§T׀ķīT:‽4;%≥═pP¶G→○▼φβjτ9v⁄6Υ◄⁹¤{τ/∑a⁰}┐⁵e¬č‘ūƧkiƧKiŗƧ, Θw←

Try it here!
Date logic could probably be improved a bit.

PHP, 888 bytes
$_=0;$l=explode('|',gzinflate(substr($a=base64_decode('AAALMQW0C2oLagtqBbULagW1AB8FlgW1AewDyQW1BbUF3wWLC2oFtQDHBO4FtQW1BbUGdgqoBbULagNxB/kFtRFGCxgLagQMB14H6wN/BbULagW1C2oLagtqZVLtjtpADHyVfYK8Ax8FBEd7pWmR+s9kTXbLxq68CXSlffjaheNO6q8o6/HMeOw1svTojpBDpH5kqlsO5GYehlzbwANkt8XzGSVbDQbMbg8+fvhjEsZ729cpUlce3TPygje3he5i6D3IGMn9AHLzSZDqMaYUYXAbJCluAyJ3ViNqS0J5COwa98rpUn9CF0CRLZTEUvfaDuLdSr8DC9aVAF2SSrxGlA4f3fNJuwiozk4CQeVe1CInetpTOZP9nkrOiv/WuLUSjfUwjQHlzCoxb9RewfygnCkE5Bwx+boImEcUe5vJGCapa+GrPiwSXjEB+TpH+gWD+nqO+B/kLYp9t4uUsGjyyF6HcgfmbKjxPS6+2dgtnPWN2QvfnNaM96gCSG5tdsXrPusC0lWVF8wp+h7rBuWEMiqJOXiPbNl8UDKfxYJoZRo0ueUt9mE0zKeYkQLfbDe2plXjdkiEvtSXQp7JonpL9BBtX959jn9sZhRIui3Ns27jMBS30INQogOTFQ4IPRjs3z1uGndsdHc51LnOrVFFGvlZftZA9LrclxMMUJd3IjP9+y8='),90)));foreach(str_split(substr($a,0,90),2)as$i=>$d)(strtotime($argn)+5701449600)/86400<($_+=hexdec(bin2hex($d)))&&@die($l[$i-1]);echo end($l);

TRY DEMO

Charcoal, 550 bytes
✂⊟Φ⪪”}¶⟲φε"1Ｉt↙θ｜&s1%⎚÷Ｘ2J¦T↶M↙@Ｐ≡,7gSＣ{WＴＢ¿μ;↗ＡEoU…⁹aⅉ:(↶Þ|‹Ｃρr]χＹ↨×⪪…✳μⅉⅈ²]⌈&ρτ“↖s∕↘yⅉ⊘K%QUi&Ｕρ⦃→↑^_tＺ}↙s⪪3#\UZ¶L↥ρ÷Qa.ρE⊞B↘¿⦃{RＣ⁴βLΦï←⁹″*²⌊∕~L‽∧＆;⁵⪪⪪◨sＦψ⊗=₂εωb5⎚∧¬Ii»Ｓ⟲Ｈ⧴⮌⁵↷≕≦-Ｌκ↗⦃″✂DcgSOE}PΣ℅ξ»u➙ïＡ⁼×◧⁴Gθkιbσ6�V→↓B⮌⦃]σ0↶L↷'Þ¡σ？αδ⪫4⁶M"‽Ｗ◨-n℅O≡o ⊙^fκ{~✳N⦄y⊟≦Ｋθ!«↘pB;fJ<ιU%Ｄ‴▶p|‹⌕ιＨpＩt‽7}u1~φνL▶⮌;ＮY✂Ｓ>ÞＳλ<«⦃¬k⦄Ｊ⦃◧‴}v≕﹪φＥβ<⁴↘la»�λ⁼.Xξ.th⊕jEχ>m4J'⁺▷αＺ↷|D$⸿Sz⪪←fＦωρ↓oⅉ⊙⁰vFQ0T⪫?GＥ▷｜℅±P；χ'|x>i↨E◧⁺4Ｍ↖‴№⟦Π～‹σ_▷⁵Ｎ？6ⅉ ｜x+\⁺“≡Ｃ⟦⁹⁸pC⊕Dïψ？◧⎇ςΠＨ&]▷≧β↓⧴J<(1←¦6‽GG✂¡58Ｇo…Qψ/§§c↷ZＱ\@ςr⁹}ＴＺ?«fPO)⧴\`↘℅⦄＆yθ%⪫iλ*fÀ-ⅈ↖→◨⬤Ｆ″‖↘→⁹Ｓ#″▶Φ∨¬w◧«℅ySq§mＣＩπF?sⅈＰ⍘↷≔f‽k↥ABＭX﹪”¶‹ιθχ

Try it online! Link is to verbose version of code. Takes input in ISO format. Explanation:
    ”...”       List of decremented dates and presidents
   ⪪     ¶      Split on newlines
  Φ       ‹ιθ   Keep those that precede the input
 ⊟              Take the last
✂            χ  Remove the date

Stax, 550 509 502 bytes
ª╠TkªÑTs¬¢‼É▼╠→+╕s☼∩b°┴ò0J Öª◙%µ♪)Çb○Σ²╦àôä√P┼[╫»↓♪─y·:+x/ p~┤☺kèT┤╩☺♀◄╗*DX○e╩+ë%╫↔^║;◙/Θ╛B║K>▌GΣR╥♠╞N┬6dt♥h♪T⌠╥⌠ó←`±ΘÆM:\V►╢◘≥pe½╖→Ea}╚≤╠ΓÜ╗,πUF[╢▄¥¥▒t≥òK"=☺S╟▐ü%û▼98╕→→ñ`eB▌y↨\%Ç│╝û°6R┘K√â°◘RfçMñ♪3╦┤â╞╥┼«╧j/εⁿ○ó▀CäI3┘c▄}═%[C_%jgÿÉJÑS═g(┴`╦%êk9½é╔PT¶◄<║╕à¼╬≤`dεµc╨╔?Z=╧╥RDΓl.┘uFⁿ∟Juö♥,╠╛z¡ÇM7m☺╩?ïPª$πä♂ ╝Jò'æφ▬♠w►○ôr├=é┴╪ù#?∩E↓╣J∩╒░▒○LÑ∞¥╗å▐Ü└ä∙↨l♀╠├d┴Uÿ╩(╔♦)═╦¢αe£/bΦ╜%d$Öä¢M║╖q]¢╝8╨ÖBÿ┼÷{@0╕/#└â╪~V§πp<≡k♫á∩g4üÉà↔DR[√á√ü.îºV'X♥9↔øiè²≈τoæ┴0☻ó╪!‼⌡¼'↔ δ'X⌂■OpX¬E╡░├a"√4lB<└♣A╪º╕4íbz♠ìÿ°Γ═àÅ└5äº5æ2§ΩWª

Run and debug it also featuring Kevin Cruijssen's tests
This program executes correctly, but if you use the "Uncompress Literals" tool, it will corrupt the source code.  It ends up putting two integer literals right next to each other, which makes one bigger literal.  Of course, that doesn't do the same thing as the original program.

source: Stack Exchange

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

sort: votes


text:
Irish Snap: Variant Rules
Introduction
Recently, me and a couple of my friends decided to play some cards, and one of them suggested the game 'Irish Snap', which was the inspiration for this challenge. However, I later learnt that the game has a lot of different rules that you can play with, some of which are listed  here. The rules that are in this challenge aren't currently listed on that page, hence the name, 'Variant Rules'
The Challenge
Given an array of 3 cards, output a truthy or falsey value depending on if they make a valid snap in a game of Irish snap.
Input
The input will be an array of 3 numbers, ranging from 1-13 inclusive, with 1 representing an ace, 11 representing a jack, 12 representing a queen and 13 representing a king. The input can be in any order of top, middle, bottom.
Rules
The 4 different criteria for if cards make an Irish snap are:

The top and middle cards are the same
The top and middle cards have a difference of one
The top and bottom cards are the same
The top and bottom cards have a difference of one

If any of these criteria are met, you must output a truthy value. As well as this, for the two criteria that require the cards to have a difference of one, it 'wraps around', meaning that an ace and a king are considered to have a difference of one, and vice versa.
Test Cases
Input (Bottom, Middle, Top) -> Output
1 13 7 -> False
1 4 13 -> True
9 3 6 -> False
8 9 7 -> True
2 6 5 -> True
12 5 11 -> True
10 4 8 -> False
12 13 7 -> False
9 7 10 -> True
7 3 1 -> False
4 2 3 -> True

Can we take the cards seperately? Or take input as top, [middle, bottom]?

sure, you can do both. changed the question to reflect that

Can we invert the output, i.e return False for valid snaps and vice versa? How about a test case where both middle and bottom are valid?

Yeah, you can invert the output. Also, added that test case

Must the output values be consistent or could we, for example, output 0 for false and any other integer for true or, even, any negative integer for false or any positive integer for true?

Yeah, output doesn't have to be consistent. I'm pretty sure there's a couple of answers using that already

Perl 6, 16 bytes
3>(*-(*|*)+1)%13

Try it online!
Anonymous whatever lambda that takes input as top, middle, bottom and returns a Junction that evaluates to True or False

Too bad whitespace is required before <, this was the perfect chance to have a heart smiley.

Python 3, 38 bytes
lambda x,y,z:{x-y,x-z}&{0,1,12,-1,-12}

Try it online!
Returns a non-empty set (truthy) if valid, empty set (falsey) if not. Takes input in order top-middle-bottom, but can be rearranged for same code size.

05AB1E, 7 6 bytes
α12%ß!

Try it online!
Takes inputs as [middle, bottom], top.
α        # absolute difference
 12%     # mod 12
    ß    # minimum
     !   # factorial

Only 1 is truthy in 05AB1E. 0! and 1! are both 1, while no other number has a factorial of 1.

Charcoal, 12 bytes
›²⌊﹪↔⁻Ｅ²ＮＮ¹²

Try it online! Port of @Grimy's answer. Takes input as three separate values bottom, middle, top, and outputs using Charcoal's default Boolean format of - for true, nothing for false. Explanation:
 ²              Literal 2
›               Is greater than
  ⌊             Minimum of
    ↔            Absolute value of (vectorised)
      Ｅ²Ｎ       First two numeric inputs as a list ([bottom, middle])
     ⁻          Minus (vectorised)
         Ｎ      Third input (top)
   ﹪            Modulo (vectorised)
          ¹²    Literal 12

J, 12 bytes
1 e.2>12||@-

Try it online!
Taking bottom middle as left arg, top as right arg.
original answer taking input as one list
J, 24 bytes
1 e.2>#:@3 5(12||@-/)@#]

Try it online!

#:@3 5 The numbers 3 and 5 in binary are 0 1 1 and 1 0 1 which are the masks for the middle/top and bottom/top cards respectively
(12||@-/)@# We filter the input with those masks, take the abs value of the
resulting differences, then the remainder when divided by 12 (for the ace-king case)
1 e.2> are either of the resulting numbers less than 2, ie, 0 or 1?

JavaScript (ES6), 29 bytes
Takes input as ([bottom, middle])(top).
The output is inverted.
a=>c=>a.every(n=>(n-c)/2%6|0)

Try it online!

JavaScript (ES6),  37  30 bytes
Saved 1 byte thanks to @Grimy
Takes input as ([bottom, middle])(top).
a=>c=>a.some(n=>(n-=c)*n%72<2)

Try it online!

%144 could be %72

@Grimy Thanks! FWIW, %13 would also work.

Pyth, 12 11 bytes
Takes input as [bottom, top, middle] or [middle, top, bottom] (both work).
Outputs [] (Falsy in Pyth) if there's no valid snap, a non-empty array otherwise.
f>2%.aT12.+

Try it online!
If a consistent truthy/falsy value is required, add .A in front for +2 bytes. Then output will be True or False.
Explanation
  f             # Filter on lambda T:
   >2           # 2 >
      .aT       #     abs(T)
     %   12     #            % 12
           .+   # the list of deltas (difference between consecutive elements)

.A (if required)# Any truthy values in the above list?

Edit: -1 with a different approach

Perl 5 -ap, 31 bytes
$t=<>}{$\|=abs($t-$_)%12<2for@F

Try it online!
Input:
bottom middle
top

Actually, the order of the middle and bottom doesn't matter.
Output:
0 for false; 1 for true

Jelly, 6 bytes
ạ%12ṠƑ

Try it online!

C (gcc), 47 43 bytes
f(b,m,t){return(1<<t-m|1<<t-b)&0x80101003;}

Try it online!

Japt, 7 bytes
d_aV <2

Try it

T-SQL 2008, 40 bytes
PRINT 1/-~abs((@-@2)%12/2*((@-@3)%12/2))

Try it online

Jelly, 6 bytes
I%12ỊẸ

Try it online!
A monadic link taking the list of [middle, top, bottom] as its argument and returning 1 for snap and 0 for no snap.

[R], 23 bytes
takes input as a=c(bottom,top,middle):
any(abs(diff(a))%%12<2)

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


text:
Numbers Decrease while Letters Increase
Randomly inspired by Numbers Increase While Letters Decrease
Given a list of mixed letters and integers (e.g., ['a', 2, 3, 'b']) increase the letters by one position in the alphabet (wrapping at z to a) and decrease the numbers by 1. For the above example, the output should be ['b', 1, 2, 'c'].

The input can be a mixed-type list, a delimited string, a list of strings, etc.
z wraps to a, but 1 goes to 0, and 0 goes to -1, etc.
The input will only ever be [a-z] and integers. You can choose capital letters [A-Z] as input if that's easier for you.
The input is guaranteed non-empty.
The input may contain only numbers or only letters.

Examples:
Input
Output

['a', 2, 3, 'b']
['b', 1, 2, 'c']

['a', 'b', 'z']
['b', 'c', 'a']

[-1, 0, 257, 'x']
[-2, -1, 256, 'y']

[0, 3, 1, 20382876]
[-1, 2, 0, 20382875]

Rules and Clarifications

Input and output can be given by any convenient method.
You can print the result to STDOUT or return it as a function result.
The output doesn't have to be the same format as the input (e.g., you could take input as a string and output as a list).
Either a full program or a function are acceptable.
If applicable, you can assume the input/output integers fit in your language's native int range.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

If the number is equal to Integer.MinValue or whatever the lowest value of a signed integer is in my language, should I underflow to Integer.maxValue or should I continue counting down?

@Nzall Undefined behavior. The 5th bullet point under Rules and Clarifications specifies that both input and output integers fit in your languages native int range, so you'd never get Integer.MinValue as an input.

05AB1E, 5 bytes
<AAÀ‡

Try it online!
<          # decrement the numbers
 A         # constant "abcdefghijklmnopqrstuvwxyz"
  AÀ       # same, but rotated left ("bcd...yza")
    ‡      # transliterate

Ruby, 34 bytes
For each element, attempt to return the element -1. Strings cannot do this, so they error out and are picked up by the rescue clause, which instead calls succ on it to return the next letter in the alphabet. succ "rolls over" on z and returns aa though, so we simply take the first character in the returned string.
->a{a.map{|e|e-1rescue e.succ[0]}}

Try it online!

Python 3, 59 bytes
lambda a:[i-1if''!=i*0else chr(97+(ord(i)+8)%26)for i in a]

Try it online!
-1 byte thanks to Erik the Outgolfer

57 bytes.

@EriktheOutgolfer integer vs string comparison does not seem to be working in your solution.

Oh right, you need Python 2 for that.

Ah yes, then it seems to work. Still the replacement of -96 with +8 saves a byte.

''!=i*0 is three bytes shorter than my str(i)>'9', good job

Perl 5 (-p), 17 bytes
y/a-z/b-za/or$_--

Try it online!
Bonus 19-byter:
$_>$_++?$_-=2:s/a//

TIO. This one features some cool tricks, but fails to beat the straightforward solution above.

Python 3, 182 130 118 bytes
-51 bytes thanks to @AdmBorkBork and @Black Owl Kai, -1 byte thanks to @Black Owl Kai, -12 bytes by replacing .append() with +=[] and replacing n+1 with -~n
def a(x):
 b='abcdefghijklmnopqrstuvwxyz';c=[]
 for d in x:
  try:c+=[d-1]
  except:c+=[b[(-~b.find(d)%26)]]
 return c

Try it online!
I made this while the question was in the Sandbox but didn't see it posted until just now. :P
Ungolfed
def a(x):
    b = 'abcdefghijklmnopqrstuvwxyz'
    c = []
    for d in x:
        try:
            c.append(d - 1)
        except:
            c.append(b[((b.find(d) + 1) % 26)])
    return c

Explanation
For each element in the inputted list x, it tries to subtract 1 and add it to the eventual returned list. If an error occurs (because the element is a string), the letter's index in the alphabet is added by 1 and that mod 26 is taken. The mod 26 wraps an index of 26 back to 0.

Welcome to CodeGolf SE! I'm not an expert at Python, but I think you can swap 4 spaces for tabs to save a bunch of bytes.

I got it to 131 bytes just by eliminating whitespace. One further byte can be golfed by realizing that (x+27)%26 has the same result as (x+1)%26

@AdmBorkBork BlackOwlKai Thank you for the help! I've edited the post.

You can use a ternary with str(d)==d to check if it's a string or not, instead of relying on try/except. Then, since you no longer need try/except, you can do the whole thing in a list comprehension! I'll let you think about it a little more but you can easily get under 100 bytes this way ;)

89 bytes

Oh, Jitse's solution is basically the same idea but better :( well, it's up to you whether to use something like this

JavaScript (Node.js), 55 bytes
a=>a.map(s=>1/s?s-1:B([(B(s)[0]+8)%26+97])+'',B=Buffer)

Try it online!

J, 30 bytes
<: ::((26|>:)&.(_97+a.i.]))&.>

Try it online!

Retina, 52 50 48 58 41 37 bytes
T`zl`l
\b0
-
\d+
*
-_*
-$.0
_(_*)
$.1

-4 bytes thanks to @FryAmTheEggman (and for mentioning I had a bug: 1 → -1 instead of 1 → 0).
+10 bytes to fix a bug with 1 and 0.. Such an annoying edge case which screwed me over for quite a while.. But golfed it to 41 bytes now. (Now I'm curious about the <40 bytes versions @Neil and @CowsQuack mentioned in the comments.. Thanks @Neil for the tip of converting the 0 to -, and dealing with the negative values first. Converting those right back from unary to integer helped a lot.)
Apparently I don't need the boundaries at this point, so -4 bytes.. >.>
I/O is comma-separated.
Try it online.
Explanation:
Transliterate all "zabcdefghijklmnopqrstuvwxy(z)" to "abcdefghijklmnopqrstuvwxyz":
T`zl`l

Replace all standalone 0s with a -:
\b0
-

Convert all numbers to unary, by replacing them with that amount of underscores:
\d+
*

For all negative values, with zero or more unary-lines behind it: keep the minus sign, and get the total length of this match (including the -), converted back to an integer:
-_*
-$.0

As for the positive integers: match a positive integer by matching a single unary-line, followed by zero or more unary-lines. And then replace them with the length of that capture group to remove that single unary-line and convert them back to integers simultaneously:
_(_*)
$.1

Gema, 55 characters
<N>=@sub{$1;1}
z=a
<L>=@int-char{@add{@char-int{$1};1}}

Dirty solution. Wrapping around on letter increment is painfully long, so got a separate rule.
Input can be quite anything, just use some separators. (You can even omit separators between numbers and letters. With the price of 1 character for changing to <L1> you could omit separators between letters too.)
Sample run:
bash-5.0$ gema '<N>=@sub{$1;1};z=a;<L>=@int-char{@add{@char-int{$1};1}}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Try it online!
Gema, 66 characters
<N>=@sub{$1;1}
<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}

Clean solution. Half relatively efficient, then half pure pain.
Sample run:
bash-5.0$ gema '<N>=@sub{$1;1};<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Try it online!

R, 77 85 bytes

Thanks @Giuseppe for a whooping 8 bytes
function(l)Map(function(x)"if"(i<-match(x,L<-c(letters,"a"),0),L[i+1],x-1),l)

Try it online!
Takes the input as a list.  After a big change by @Giuseppe, this makes use of Map to apply a function to the list. It makes use of match to test for a character.  During the test the extended letter list and index are saved for the return.

I suppose characters aren't finite because they are cast to numeric by is.finite and are thus NA?

@Giuseppe thought it would be something along those lines.  Even though it's the same bytes as is.double I needed to use it :)

77 bytes?

sorry to get rid of your is.finite, I thought I'd take a crack at it myself

@Giuseppe very nice,  Wouldn't have thought of Map and match.  It's good to learn something each day :)

MathGolf, 14 bytes
▄\╧¿ò'z=¿Å'a)(

Try it online!
Takes letter as lowercase.
Explanation
▄\╧              Is the element in the lowercase alphabet?
   ¿ò            If so:
     'z=           Is it equal to z?
        ¿Å         If so:
          'a         Push 'a'
            )      Else: Increment the string
             (   Else: Decrement the number

dzaima/APL, 21 20 bytes
{0::⍵-1⋄⎕l(⍳⊇1⌽⊣)⍵}¨

Try it online!
-1 thanks to ngn.

(⎕l⍳⍵)⊇1⌽⎕l -> ⎕l(⍳⊇1⌽⊣)⍵

PHP, 50 bytes
for(;''<$a=$argv[++$i];)echo$a<a?--$a:(++$a)[0],_;

Try it online!
Tests
Outputs letters/integers separated by _ with a trailing separator.
In PHP you can increment letters directly, so I took advantage of it. But the z is incremented to aa, to convert it to a, the (++$a)[0] is used which only outputs the first character of the incremented value.

Japt -m, 13 12 bytes
-1 byte thanks to Shaggy
;¤?UÉ:Cg8+Uc

Try it
Explanation:
;o ?UÉ:Cg8+Uc
-m              // Map U through the input:
 o              // Try to create a range [1...U]
   ?            //   If that creates a range (number):
    UÉ          //     Return U-1
      :         //   Else, return:
;      C        //     alphabet (a...z)
        g       //     Index:
         8+Uc   //       8 + char-code of U

Note: ; turns C into the lowercase alphabet

It doesn't look like this wraps from z to a.

@Shaggy Whoops, I missed that. I added a temporary fix for +2 bytes

Couldn't figure out a way to fix mine (yet) without a ternary, which makes it too similar to yours for my liking so I'm deleting for now. o -> ¤ will save you a byte here.

@Shaggy Ah! I tested ¤ earlier but noticed that it turned 0 into 0 which I assumed would fail the ternary-test...turns out it returns "0"! Thanks for spotting that

+2 and then -1 thanks to Shaggy would be more accurate! :D

@Shaggy The +2 was thanks to Oliver :P

SNOBOL4 (CSNOBOL4), 103 bytes
	U =&UCASE 'A'
N	X =INPUT	:F(END)
	U X @P	:F(D)
	U POS(P) LEN(1) . OUTPUT	:(N)
D	OUTPUT =X - 1	:(N)
END

Try it online!

Haskell, 52 51 bytes
map q
q"z"="a"
q x|x>"`"=succ<$>x|1<2=show$read x-1

As Haskell doesn't allow lists of mixed types, letters and numbers are taken and returned as strings.
Try it online!
Check for every list element: if the string is "z", return "a"; if the first character of the string is > '`' (i.e. a letter, not a digit), return the successor of the char(s) in the string; else it must be number, so convert to an integer, subtract 1 and turn into a string again.
Edit: -1 byte thanks to @cole.

Does this work for 51 bytes?

@cole: yes it does. Thanks!

Jelly, 13 bytes
®i‘ị®µ’e?€Øa©

Try it online!
Clever fix by Jonathan Allan.
Note: This is not a full program, the footer over TIO makes it possible to input using a command-line argument to test the function.

Wont work with negatives in the input (or over chr range). ®i‘ị®µ’e?€Øa© is a fix for zero I believe.

@JonathanAllan Hah, I forgot that Ọ doesn't exactly work in that case. Ironic, since I avoided using ~ as the condition to account for -1s in the input... Also, how am I going to shorten ®i‘ị®...

K (oK), 27 bytes
{$[9+@x;`c$97+26!8+x;x-1]}'

Try it online!
-8 thanks to ngn and dzaima :)

31 bytes {$[-9=@x;x-1;90=x;"A";\c$1+x]}'inlining the special-case & using uppercase (and the'` has to be counted as the input should be a list)

@scrawl i think dzaima is right - the ' should be counted. here's a slightly longer expression that doesn't need ' and also takes care of "z"->"a": {\c`i[t]$(-26x~'"z")+x+1-2t:x~'0+x}`

or even better - make a list of projections and apply them with @': {(\c$97+26!-96+;-1+)[x~'0+x]@'x}. here -96(which is +1 minus the ascii code of "a") can be replaced with8` as it's taken mod 26.

another -1 byte by opting for capital letters: {(\c$65+26!14+;-1+)[x=_x]@'x}`

@dzaima yours can be shortened through -9=@x -> x=_x

27 bytes, combining ideas from both and using lowercase input: {$[9+@x;\c$97+26!8+x;x-1]}'` (sorry for the spam)

been meaning to update this for the longest time. thank you to you both :)

C++17 (gcc), 120 bytes
#define O int operator()
struct V{O(char&c){c++-90?:c=65;}O(int&i){--i;}};int f(auto&l){for(auto&x:l)std::visit(V{},x);}

Here f is the required function; l is both the input and output parameter, and it is expected to be a container of objects which are compatible with std::variant<char, int> or vice versa.
Try it online!

Stax, 17 bytes
àºÇ╝'♫d▬♣ΩÜEƒ6╩╬ó

Run and debug it
This feels like it should be possible to do shorter, but I can't resist the opportunity to use a new stax feature from the last release.
Treating the entire input as a string:

Regex replace runs of digits with eval(match) - 1.  This is the new feature, as the regex block replacement is not a string, but an integer.
Regex replace runs of letters by ring-translating them around the lower-case alphabet.

Python 3, 66 bytes
lambda X:[x-1if type(x)==int else chr(97+(ord(x)+8)%26)for x in X]

Edit:
I didn't see the solution of Jitse until now. The trick of if''!=i*0 is awesome!

C (gcc), 93 86 bytes
f(int**s){for(char**p=s,*z;z=*p++;)64&*z?*z=*z-'z'?++*z:97:sprintf(z,"%d",atoi(z)-1);}

Try it online!
The input is a NULL-terminated array of '\0'-terminated strings, e.g. {"a", "b", "c", "17", NULL}.
-7 bytes thanks to @ceilingcat

C#, 148 bytes
(object[] o)=>{var l=new List<object>();foreach(var h in o){try{l.Add((int)h-1);}catch{var c=((char)h+1);if(c>122){c=97;}l.Add((char)c);}}return l;}

Repl.it link
Ungolfed:
var inputList = new object[] {'a', 2, 'z', 6};
var outputList = new List<object>();
foreach (var currentItem in inputList)
{
    try
    {
        outputList.Add((int)currentItem-1);
    }
    catch
    {
        var currentItemPlusOne = ((char)currentItem + 1);
        if (currentItemPlusOne > 122)
        {
            currentItemPlusOne = 97;
        }
        outputList.Add((char)currentItemPlusOne);
    }
}

Charcoal, 16 bytes
ＷＳ⟦⎇№βι§β⊕⌕βιＩ⊖ι

Try it online! Link is to verbose version of code. Takes input on STDIN, each line being either a single lowercase letter or an integer, and outputs on separate lines on STDOUT. Explanation:
ＷＳ

Repeatedly input from STDIN until an empty line is reached.
⟦

Make this expression output on its own line.
⎇№βι

Is this a substring of the predefined lowercase alphabet?
§β⊕⌕βι

If so then print the next letter cyclically indexed.
Ｉ⊖ι

Otherwise decrement the value and cast back to string for implicit print.

Zsh, 47 bytes
a=({a..z} a)
for i
<<<${a[$a[(i)$i]+1]:-$[--i]}

Try it online!
a=({a..z} a)                  # append extra 'a' to the end to handle 'z' case
for i                         # for i in "$@" arguments
<<<${a[$a[(i)$i]+1]:-$[--i]}
       $a[(i)$i]              # first (i)ndex of $i in list (if not found, set to after last index)
      [         +1]           # increment
   ${a[           ]        }  # value in array at index. if lookup fails, empty string
   ${              :-$[--i]}  # if empty, decrement $i and substitute instead
<<<                           # print to stdout

Perl 6, 31 bytes
*>>.&{(try $_-1)||chr ord ++$_}

Try it online!
Anonymous Whatever lambda that maps each element to the list and attempts to subtract one from it, otherwise incrementing it and taking the first character in the case that z wraps over to aa.

T-SQL 2012, 61 bytes
Capital letters needed in input.
Using table variable as input.
SELECT iif(x<'a',left(x-1,9),char((ascii(x)-64)%26+65))FROM @

Try it online

SimpleTemplate, 80 bytes
This was written on a language I've made.
Due to limitations in the compiler, I can't reduce it any more.
{@eachargv}{@if_ is matches"@\d+@"}{@incby-1_}{@echol_}{@else}{@inc_}{@echol_.0}

And now, ungolfed:
{@each argv as value}
    {@if value is matches "@\d+@"}
        {@inc by -1 value}
    {@else}
        {@inc by 1 value}
    {@/}
    {@echo value, "\n"}
{@/}

And the explanation:

{@each argv as value} - loops through all values in argv. (argv contains all the arguments passed).
If the as <var> isn't present, the default _ variable is assumed.
{@if value is matches "@\d+@"} - checks that value matches with the regular expression "@\d+@".
{@inc by -1 value} - increments the value by -1 (basically, a decrement).
{@echo value, "\n"} and {@echol_} - echol outputs the values passed and appends a line at the end.
{@else} - self-explanatory
{@inc by 1 value} - increments the value by 1. If the by <value> is missing, it is assumed to be 1.
{@echo value.0, "\n"} and {@echol_.0} - echol outputs the values passed and appends a line at the end.
This is required because of the challenge rules: z wraps to a.
When an @inc is used on a string, it increments the chars and, once it hits z, it wraps to aa.
Outputting the first character satisfies the challenge, at the cost of 7 bytes.
{@/} - closes the {@else} above (optional).
{@/} - closes the {@each} above (optional).

You can try this on: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f
Each passed argument to render() will be a new value that is considered.

Runic Enchantments, 36 bytes
\$ka'~?*3({':+1\
R';$ >i::0Sqn=?/1-$

Try it online!
General process is to read input, prepend with a 0 (coercion to string), convert back to a number (single char will always return -1), compare with input. If same, it must be a numerical value, subtract 1 and print. If not same, it must be a char, subtract 1, compare with {. If less than, print, otherwise replace it with a and print.
Repeat until program performs a stack underflow.
Output is separated by ; in order to save 1 byte (and has a trailing one). Input is space-separated.

Perl, 64 bytes
foreach (@ARGV){$_=~m/[a-zA-Z]/?++$_:--$_;print substr $_,0,1;}