Stepping Through Time
JavaScript (ES7), 136 132 bytes
Takes a single integer as input and returns a string.
s=>(V=g=(d,t=s,k=0)=>k>V?R:[...S=([1e3]+t).slice(-4)].some(p=c=>(p-(p=c))**2-1)?g(d,t=(t-~d)%2400,k+=t%100<60):(V=k,R=S))()&&g(2398)
Try it online!
How?
The only valid hour prefixes are 01, 10, 12, 21 and 23. It means that any invalid minute count starting with a digit greater than 5 will be rejected by the test on the absolute difference between two consecutive digits.
So there's no need to explicitly handle the wrapping of minutes modulo 60. Instead, we can just make sure that the distance k is not incremented on invalid minutes:
k += t % 100 < 60
JavaScript (Node.js), 148 146 bytes
Takes a single integer as input and returns a string.
This version picks the answer from a hardcoded table.
t=>0x60553BCD48A3CE4F56D818FDC473FC726398E907D3A9n.toString(6).substr([22,85,9,423,462,x=98,x,9,9,413,461,9,x,x,9,9].findIndex(d=>(t-=d+2)<0)*4,4)
Try it online!
How?
Once converted to base-6, the integer 0x60553BCD48A3CE4F56D818FDC473FC726398E907D3A9n is turned into the following string, which holds all possible valid answers:
"23450101012101231010101212101212123212342101212121232321232323432345"
The correct answer is selected according to the interval in which the input time falls:
answer | input interval
--------+----------------
"2345" | 00:00 - 00:23
"0101" | 00:24 - 01:10
"0121" | 01:11 - 01:21
"0123" | 01:22 - 05:46
"1010" | 05:47 - 10:10
"1012" | 10:11 - 11:10
"1210" | 11:11 - 12:10
"1212" | 12:11 - 12:21
"1232" | 12:22 - 12:32
"1234" | 12:33 - 16:47
"2101" | 16:48 - 21:10
"2121" | 21:11 - 21:21
"2123" | 21:22 - 22:21
"2321" | 22:22 - 23:21
"2323" | 23:22 - 23:32
"2343" | 23:33 - 23:43
"2345" | 23:44 - 23:59
The lengths of the intervals in minutes (minus 2) are stored in an array.
Python 2, 136 138 133 126 125 122 151 124 108 106 103 101 bytes
f=lambda h,m,i=0:(h,m)*all(j%11%9==1for j in(h,m/10-h%10,m))or f((h+(m+i)/60)%24,(m+i)%60,~i+2*(i<1))
Try it online!
Input is hour,minute parameters result is (hour,minute) tuple
Using recursion
i moves through [0,-1,+2,-3,+4,...] the sum of the initial terms therefore moves through [0,-1,1,-2,2,...]
(h,m) are offset by i minutes moving alternately through nearest above and below time not yet checked.
Check for result by considering h, m and h%10*10+m/10, which is low hour digit and top minute digit.
To check two digit number n in form d (d+1) or (d+1) d, observe n%11 is either 1 or 10 in exactly these cases, and checking for 1 or 10 using %9==1. i.e. n%11%9==1
As this two digit test reduces modulo 11, h%10*10+m/10 is equivalently m/10-h%10.
Previous approach:
def f(h,m,i=0):t=m+i;s='%02d'*2%((h+t/60)%24,t%60);return s*all(a+b in'4321012345'for a,b in zip(s,s[1:]))or f(h,m,-i+(i<1))
Try it online!
Input in integer output is 4 character string.
Formats number as string, taking pairs checks against string table, otherwise recurse with alternating offsets (i=0,1,-1,2,-2,...)
Originally:
Offsets n by [0,1,-1,2,-2,...], formats as four digit string, then taking pairs of characters checks they differ by one by looking up as substring in compressed string table.
+2 bytes Fixed by adding '43' to table.
-5 bytes Removed unnecessary +2400, which was to avoid mod of negative number -- Python's % works properly in that case.
-7 bytes string table improved, and by using / instead of // due to Surculose Sputum.
-1 byte reduce range of search.
-3 bytes Surculose Sputum: remove unecessary [] in all() and compress expression i%2*2-1 to i%-2|1.
+29 bytes code was broken, added correction term for wrapping minutes (n%100+i)/60*40
-27 bytes Surculose Sputum: rewritten using recursion
-16 bytes reworked using new approach
-2 bytes remove introduced variable which was false saving.
-3 bytes simplification for middle digits test.
-2 bytes Surculose Sputum: using lambda instead of def
Python 2, 142 bytes
lambda*t:'%02d'*2%max(g(-720,*t))[1:]
g=lambda w,h,m,t=10:w/720*[0]or[(w*w,h,m)]*({h/t-h%t,h%t-m/t,m/t-m%t}<={1,-1})+g(w+1,(h+m/59)%24,-~m%60)
Try it online!
without the strict output:
Python 2, 160 148 144 138 133 bytes
-6 11 bytes thanks to Surculose Sputum!
Input and output is hours, minutes.
lambda*t:max(g(-720,*t))[1:]
g=lambda w,h,m,t=10:w/720*[0]or[(w*w,h,m)]*({h/t-h%t,h%t-m/t,m/t-m%t}<={1,-1})+g(w+1,(h+m/59)%24,-~m%60)
Try it online!