[Question]
  [
A time in the format hhMMss is represented by six numbers in the range 0..9 (e.g.`100203` for 3 seconds after 2 minutes after 10am (10:02.03), or `155603` for three seconds after 56 minutes after 3pm (15:56.03).
Treating these times as integers, these numbers are therefore in the range `000000` to `235959`; but not all numbers in that range are valid times.
Normally, though, integers aren't represented with leading 0s, right?
So, this challenge is to take a numeric input (without leading 0s), and say whether it represents a proper time or not when the leading 0s are put back.
### Input
Any integer, as a string or an integer type, in the range `0..235959` inclusive. all numbers as strings will be input with no leading 0s (e.g. `2400`, not `002400`). The time `000000` maps to `0`; or [exceptionally as](https://codegolf.meta.stackexchange.com/questions/8395/is-the-empty-string-an-acceptable-decimal-representation-of-0) . Inputs outside of this range should return Falsy, but there is no requirement that they are supported.
### Output
Truthy/Falsy value - by which I mean there must be a consistent distinction in the output between True and False - e.g. True could be output as `1` and False could be any other output (or even a variable output) - as long as it can be documented how to tell what is True and what is not.
### More Challenge Details
Given the input integer, figure out if the number represents a time (Truthy) or not (Falsy).
A number represents a time if a time (hhMMss) with leading 0s removed is the same as the number.
e.g. 00:00.24 is represented by 24  
e.g. 00:06.51 is represented by 651  
e.g. 00:16.06 is represented by 1606  
e.g. 05:24.00 is represented by 52400  
e.g. 17:25.33 is represented by 172533
There are therefore some numbers that can't represent times:
e.g. 7520 - this can't represent hhMMss because 00:75:20 isn't a time
As a general rule, the valid numbers fall into the pattern:
`trimLeadingZeros([00..23][00..59][00..59]);`
*The following numbers are the entire set of inputs and the required answers for this challenge*
**Seconds only (e.g. 00:00.ss, with punctuation and leading 0s removed, -> ss)**  
`0 to 59` - Truthy  
`60 to 99` - Falsy
**Minutes and seconds (e.g. 00:MM.ss, with punctuation and leading zeros removed, -> MMss)**  
`100 to 159` - Truthy  
`160 to 199` - Falsy  
etc, up to:  
`2300 to 2359` - Truthy  
`2360 to 2399` - Falsy  
`2400 to 2459` - Truthy  
`2460 to 2499` - Falsy  
etc, up to:  
`5900 to 5959` - Truthy  
`5960 to 9999` - Falsy
**Hours 0..9, minutes and seconds (e.g. 0h:MM.ss with punctuation and leading zeros removed -> hMMss)**
`10000 to 10059` - Truthy  
`10060 to 10099` - Falsy  
etc, up to:  
`15800 to 15859` - Truthy  
`15860 to 15899` - Falsy  
`15900 to 15959` - Truthy  
`15960 to 19999` - Falsy
`20000 to 20059` - Truthy  
`20060 to 20099` - Falsy  
`20100 to 20159` - Truthy  
`20160 to 20199` - Falsy  
etc, up to:  
`25800 to 25859` - Truthy  
`25860 to 25899` - Falsy  
`25900 to 25959` - Truthy  
`25960 to 25999` - Falsy  
etc, up to:  
`95800 to 95859` - Truthy  
`95860 to 95899` - Falsy  
`95900 to 95959` - Truthy  
`95960 to 99999` - Falsy
**Hours 10..23, minutes and seconds (e.g. hh:MM.ss with punctuation and leading zeros removed -> hhMMss)**
`100000 to 100059` - Truthy  
`100060 to 100099` - Falsy  
`100100 to 100159` - Truthy  
`100160 to 100199` - Falsy  
etc, up to:  
`105800 to 105859` - Truthy  
`105860 to 105899` - Falsy  
`105900 to 105959` - Truthy  
`105960 to 109999` - Falsy
This pattern is then repeated up to:
`235900 to 235959` - Truthy  
(`236000 onwards` - Falsy, if supported by program)
Leading 0s must be truncated in the input, if strings are used.
Code golf, so least bytes wins - usual rules apply.
[code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")
  
[Answer]
# Python, ~~45~~ ~~43~~ ~~38~~ 27 bytes
For inputs up until 239999:
```
lambda n:n/100%100<60>n%100
```
You can [try it online](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPKk/f0MBAFYhtzAzs8kCM/wVFmXklGmkaRsaGBmaWmpr/AQ)! Thanks @Jitse and @Scurpulose for saving me several bytes ;)
For inputs above 239999 go with 36 bytes:
```
lambda n:n/100%100<60>n%100<60>n/4e3
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~33~~ 25 bytes
*-7 bytes thanks to Kevin Cruijssen*
```
60>*.polymod(100,100).max
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPvfzMBOS68gP6cyNz9Fw9DAQAeINfVyEyv@W3MVFGXmlaQpKKmapSjY2imoFsfkKekoqMTrKNTpATWn5RcpGOgomFrqKJgBaUsgDTIAKAARMgALQoVBHCNjkNR/AA "Perl 6 ‚Äì Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~1~~9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
-10 bytes thanks to Kevin Cruijssen.
Anonymous tacit prefix function. Takes argument as integer.
```
‚ç±59<100‚àò‚ä§
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HvRlNLG0MDg0cdMx51Lfmf9qhtwqPevkddzY961zzq3XJovfGjtomP@qYGBzkDyRAPz@D/hgq2CmkKBlwQ2tSAywDMMIMxLC25dHV1odJAo2EsU0uoAkO4UkOgWoiskTFcoZExXKWRMVypkTG6uQiTDQwQZhsYIEw3MEDRY2RqgbDE1AJhi6kFwhpTC7ibLJHUWyKpt0RSbwlWD7ID4WIDAwA "APL (Dyalog Extended) ‚Äì Try It Online")
`100‚àò‚ä§`‚ÄÉconvert **T**o base-100
`59<` are they, each, greater than 59?
`‚ç±`¬†are none of them true?
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~14~~ ~~13~~ 12 bytes, supports inputs > 235959
```
—Ç–≤R‚ÇÖ0≈°R12*‚ÄπP
```
[Try it online!](https://tio.run/##yy9OTMpM/W90eK7NuS3ap@eUVdorKTxqm6SgZF/5/2LThU1Bj5paDY4uDDI00nrUsDPgv87/aEMdMwMdQwMgBtJGxgYgAsQyAbFMgCxTSwMQAVFlACZBbFMLAzAJZluC2SA1RmA1RmA1RgaGYDbYZLB6I7B6I7B6I7B6S7C4JVjcEixuibALQkF4hhCeIZgHsdwAYrsBxHoDiP3GEMONoTwzsHNM4IaBQCwA "05AB1E ‚Äì Try It Online")
```
—Ç–≤             # convert input to base 100
  R            # reverse
   ‚ÇÖ           # 255
    0≈°         # convert to list and prepend 0: [0, 2, 5, 5]
      R        # reverse: [5, 5, 2, 0]
       12*     # times 12: [60, 60, 24, 0]
          ‚Äπ    # a < b (vectorizes
           P   # product
```
[Answer]
# [Python](https://docs.python.org/3/), 35 bytes
```
f=lambda n:n<1or(n%100<60)*f(n/100)
```
A recursive function which returns `1` or `True` (which are truthy) if valid or `0` (which is falsey) if not.
**[Try it online!](https://tio.run/##VVLBTsMwDL3zFb6gJVDASZtqmbZ9BD@AiljHpC0dXXdA0769pLGdil5q@/n5OU8@/w7fXSiX534c282xOX1@NRBWYW26XoVHg7iuUT@1KrzFWI9t10Pbd6ePAoYODgGUwgKc1wWoOkY@RbG1AENVM5UN1W05AbZ0nNUpY6xKWMVYlbCKMOcxqTjOSClrJTVEJ3lNOeNuSdssneQ15YJ73lZwzxvzXjTfynxL863Mt2gIN4IbwuXNpG9F35K@FX1L@lb0LenHH@Ge@F74nvhe@J74Xvh@tmf2hwyZHRKLMPcY7jG5x3CPkR42ErOTyFZi9hLZTMxuItuJ2c@SH1ymHr16gPhdw@HnunvfXa7H4QIbuMWL0zBdW5iurG/Cfqfmw3sGo@@JeO4PYVCLCYLbalvfJ5iCly3c7ovXOOTUDDO5@C@m9fgH "Python 3.8 ‚Äì Try It Online")** \*
### How?
`True` and `False` are equivalent to `1` and `0` respectively in Python.
The function (`f=lambda n:...`) checks that the last up-to-two digits as an integer (`n%100`) are less than sixty (`<60`), chops them off (`n/100`) and multiplies by a recursive call `*f(...)` until an input of zero is reached (`n<1or`) at which point `True` is returned. If at any stage the check fails a `False` is placed in the multiplication, which will then evaluate to `0` (a falsey value).
---
\* Only `f(0)` evaluates to `True`, but `set((True, 1, 1, ..., 1))` evaluates to `{True}` due to the equivalence of `True` and `1` in Python.
[Answer]
# Java 8, 38 bytes
```
n->n%100<60&n%1e4<6e3&n%1e6<24e4&n<1e6
```
[Try it online!](https://tio.run/##dY8xT8MwEIXn5lfcQmUPsUKbRmoTOoAYGFjIiBhMcgQHx47sSyGq@tuDSQYGxPTe3TvdfdfKk4zb@mNSXW8dQRtqMZDS4kma2nZ59Cfw5FB2opzl//zOao0VWefzKKq09B4epTJwjlb98KpVBZ4kBTlZVUMXIhZWKtOAdI1/fuFwhmi1WjDABYEbMPgJS4fxPKQLhGjQoJOEjHGIj/OwMPhFD4bYZrvb7/acC606Rew6SbioFjb2yygaZ4c@XL8d2WTio7kKg0WWrIPBtMhwO7us2KSYrk0R7BR2oiE3lkiMizfr7mX1zsrRE3bCDnQ49OEf0uYH9RJdpm8 "Java (JDK) ‚Äì Try It Online")
Basically an improvement of @Kevin Cruijssen's solution; I don't have enough reputation for a comment. üòÑ
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 7 bytes
```
b»∑2<60·∫†
```
[Try it online!](https://tio.run/##RY27DYNAEEQbIphbPvJK5PRhiQRdA6RO3IYLcG4JkSEktwGNLLezAcHNzoyebqYx59ns@f9J3@FYPrav2/t8fQczVB2qhPLKlRou7hp3TXGtwiUoUN23D1Dpld4ZISNkBImeP5MX8kJeyCt7Za/s9d6KEylFSkwxjlhHzCP2a08X "Jelly ‚Äì Try It Online")
A monadic link taking an integer and returning `1` for true and `0` for false.
Thanks to @KevinCruijsen for saving 6 bytes!
[Answer]
# [LibreOffice Calc](https://i.stack.imgur.com/QvapB.png), 43 bytes
```
=MAX(MOD(A1,100),MOD(A1/100,100),A1/4e3)<60
```
Basically a ~~blatant rip-off~~ respectful port of @RGS excellent Python answer so go and upvote them. Only posted as I have not seen a LibreOffice Calc answer on here before and I was messing about while calculating my tax return this evening (code golf is much more fun). Screenshot of some test cases below.
[![enter image description here](https://i.stack.imgur.com/QvapB.png)](https://i.stack.imgur.com/QvapB.png)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 12 bytes
```
[6-9].(..)?$
```
[Try it online!](https://tio.run/##PZGxDsJADEP3@w6QykDlpL0TmRj5CIQEAwMLA@L/j4tdsVQ@x3qJ1c/z@3o/@n663Pu1HeM2T/N8OO96R6lRGkpEMaDYeNl42nj7MgxfaqqWKr01vTW9Nb11eDWQlJqKJLGSBlTqRp1@PXHLqVI3avqh7fRDF@Q@cpwcJ8fJcRh9o2/0eTP5Tr6T7@Q7@U6@kz@@ww/mg/lgPpgP5oP5@NfaerHM1myrBs1MM9PMNDPOVBxqDlWHukPlofZQfaj/osMXXT7@A/AD "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Accepts input from `0` to `239999` and outputs `0` for times, `1` for non-times. Explanation: Simply checks whether the second or fourth last digit is greater than `5`.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~27~~ ~~22~~ 18 bytes
*Saved 4 bytes when @NahuelFouilleul pointed out that it doesn't need to be a look-ahead in the regex*
```
$_=!/[6-9].(..)*$/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lZRP9pM1zJWT0NPT1NLRf//f0MLIy4jY1NLU8t/@QUlmfl5xf91fU31DAwN/usW5AAA "Perl 5 ‚Äì Try It Online")
Since the input is guaranteed to be less than 236000, the hours can be ignored as they will always be valid. This pattern match checks if there is a 6, 7, 8, or 9 in the tens digit of the minutes or seconds. The match is then negated to get truthy for valid dates and falsy for invalid ones.
[Answer]
# [W](https://github.com/A-ee/w), 6 [bytes](https://github.com/A-ee/w/wiki/Code-Page)
Source compression ftw!
```
‚ôÄ‚ô•@p‚ñí√∂
```
Uncompressed:
```
2,a60<A
```
## Explanation
```
2,      % Split number into chunks of length 2
        % The splitting is right-to-left *instead* of left-to-right.
      A % Is all items in the list ...
  a60<  % ... less than 60?
```
[Answer]
# [J](http://jsoftware.com/), ~~32~~ ~~26~~ ~~23~~ 16 bytes
```
60*/ .>100#.inv]
```
[Try it online!](https://tio.run/##ZY@xDsIwDET3foUFQwUq4ZLIVVypLEhMTOxMiAoYYOvvh6hiiM3g4aS757tXXrl2onGgljoCDeV2jo6X8yn32O7JHTywds/3fM2b5n57fMjTSBOhFvxTWFSvlEhTWwtOSZba7HXWi9TmEHU4RJ0OUcdD/H9u3gOmAGAqAAYSOJkanEwPTqYIJ71ELEMsQyxDFoadWyj5Cw "J ‚Äì Try It Online")
*-16 bytes (!!) thanks to Adam. This new solution uses the approach from [his APL answer](https://codegolf.stackexchange.com/a/200094/43319) so be sure to upvote that.*
Convert the input to base 100, check that all digits are less than 60.
Note the most significant digit is guaranteed to be less than 24 by the allowed inputs.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
√¨L e<60
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=7EwgZTw2MA&input=MjM1OTU5)
[Answer]
# Java 8, ~~45~~ 43 bytes
```
n->n%100<60&n%1e4/100<60&n%1e6/1e4<24&n<1e6
```
Improved by [*@Joja*'s Java answer](https://codegolf.stackexchange.com/a/200131/52210) by removing the divisions, so make sure to upvote him/her as well!
[Try it online.](https://tio.run/##TVFBbsIwELzzihVSUaKEsDYBNST0B6UHjoiDCaFyCgYRQ1WhvD1dr0FwGc@sxzv2ulZXNay3P125V00Dn0qbWw9AG1udd6qsYOEkwNemrkoLZUA7YMKcim2PoLHK6hIWYGAOnRl@mDeBWExxQKRKRy9iOqJCIdOBKUh0uTt@umz2dPze5XrUWzjQFYKlPWvzvVqDCn3@7njmaA0zMNWvu@BqfRPxFGOKiAWtcowOHEsdS4lNMnTgXcjo@OQdGZlnzJ1HskeyR6Jgzp3ZL9kv2S/Zn3E943rG9eyZ5RevhFeClQ9Hn44@Hn3@2DenN@CjC7YhD@A5gno@FDnUxdxhFD22AZZ/ja0OyfFikxONz@5NoKM66s@gH5mkdCK8/1zb/QM)
**Explanation:**
```
n->              // Method with integer parameter and boolean return-type
  n%100<60       //  Check whether the seconds are smaller than 60
  &n%1e4/100<60  //  and the minutes are smaller than 60
  &n%1e6/1e4<24  //  and the hours are smaller than 24
  &n<1e6         //  and the entire number is smaller than 1,000,000
```
[Answer]
# [Turing Machine Code](https://github.com/MilkyWay90/Turing-Machine-But-Way-Worse), ~~336~~ 548 bytes
Prints 't' for true and 'f' for false.
```
0 * * r !
! * * r "
! _ _ l b
b * _ l t
" * * r ¬£
" _ _ l c
c * * l c
c _ _ r 4
¬£ * * r $
¬£ _ _ l d
d * * l d
d _ _ r 3
$ * * r ^
$ _ _ l e
e * * l e
e _ _ r 2
^ * * r &
^ _ _ l g
g * * l g
g _ _ r 1
& * * l &
& _ _ l O
O 1 1 r a
O 2 2 r 1
O * * * f
a * * r 2
1 0 0 r 2
1 1 1 r 2
1 2 2 r 2
1 3 3 r 2
1 * * * f
2 0 0 r 3
2 1 1 r 3
2 2 2 r 3
2 3 3 r 3
2 4 4 r 3
2 5 5 r 3
2 * * * f
3 * * r 4
4 0 0 r t
4 1 1 r t
4 2 2 r t
4 3 3 r t
4 4 4 r t
4 5 5 r t
4 * * * f
f * * l f
f _ _ r n
n * _ r n
n _ f * halt
t * * l t
t _ _ r y
y * _ r y
y _ t r halt
```
[Try it online!](http://morphett.info/turing/turing.html?e0baa286625720d3ac74f1152ded6589)
*Added a chunk of bytes thanks to @Laikoni for spotting my misread of the question.*
[Answer]
# x86-16, IBM PC DOS, ~~46~~ ~~¬†44¬†~~ 39 bytes
```
00000000: d1ee 8a0c ba30 4c88 5401 03f1 4ed1 e9fd  .....0L.T...N...
00000010: b303 ad86 e0d5 0a4b 7502 b628 3ac6 7d02  .......Ku..(:.}.
00000020: e2f0 d6b4 4ccd 21                        ....L.!
```
Build and test `ISTIME.COM` with `xxd -r`.
**Unassembled listing:**
```
D1 EE       SHR  SI, 1              ; SI = 80H
8A 0C       MOV  CL, BYTE PTR[SI]   ; CX = input length
BA 4C30     MOV  DX, 4C30H          ; DH = 60+16, DL = '0'
88 54 01    MOV  BYTE PTR[SI+1], DL ; 'zero' pad byte to the left of input
03 F1       ADD  SI, CX             ; SI to end of input string
4E          DEC  SI                 ; remove leading space from length
D1 E9       SHR  CX, 1              ; CX = CX / 2
FD          STD                     ; read direction downward
B3 03       MOV  BL, 3              ; counter to test if third iteration (meaning hours)
        LOD_LOOP:
AD          LODSW                   ; AX = [SI], SI = SI - 2
86 E0       XCHG AH, AL             ; endian convert
D5 0A       AAD                     ; binary convert
4B          DEC  BX                 ; decrement count
75 02       JNZ  COMP               ; if not third time through, go compare
B6 28       MOV  DH, 40             ; if third, set test to 24+16
        COMP:
3A C6       CMP  AL, DH             ; is number less than DL?
7D 02       JGE  NOT_VALID          ; if not, it's invalid
E2 F0       LOOP LOD_LOOP           ; otherwise keep looping
        NOT_VALID: 
D6          SALC                    ; Set AL on Carry
B4 4C       MOV  AH, 4CH            ; return to DOS with errorlevel in AL
CD 21       INT  21H                ; call DOS API
```
A standalone PC DOS executable. Input via command line, output DOS exit code (errorlevel) `255` if Truthy `0` if Falsy.
**I/O:**
Truthy:
[![enter image description here](https://i.stack.imgur.com/9LgzJ.png)](https://i.stack.imgur.com/9LgzJ.png)
Falsy:
[![enter image description here](https://i.stack.imgur.com/td36s.png)](https://i.stack.imgur.com/td36s.png)
Thanks to @PeterCordes for:
* -2 bytes use DOS exit code for Truthy/Falsy result
* -3 bytes eliminate ASCII conversion before `AAD`
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
‚Äπ‚åà‚çòÔºÆ‚≠Ü¬π‚Å∞‚Å∞‚ÑÖŒπ<
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMntbhYwzexIjO3NFfDKbE4NbgEKJ6u4ZlXUFriV5qblFqkoamjABH1TSzQMDQw0FFwBpqSmFwClMvUBAIdBSUbJU1N6///jYxNLU0t/@uW5QAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Accepts input from `0` to `239999` and outputs a Charcoal boolean, `-` for times, no output for non-times. Explanation:
```
     ¬π‚Å∞‚Å∞    Literal 100
    ‚≠Ü       Map over implicit range and join
         Œπ  Current index
        ‚ÑÖ   Unicode character with that ordinal
   ÔºÆ        Input as a number
  ‚çò         Convert to string using string as base
 ‚åà          Character with highest ordinal
‚Äπ           Is less than
          < Character with ordinal 60
            Implicitly print
```
`BaseString` always returns `0` for a value of `0` (bug?) but fortunately this is still less than `<`.
Alternative solution, also 11 bytes:
```
‚åà‚çòÔºÆ‚≠Ü¬π‚Å∞‚Å∞‚Ä∫Œπ‚Åµ‚Åπ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sSIztzRXwymxODW4BCiUruGZV1Ba4leam5RapKGpowAR9U0s0DA0MNBRcC9KTSwBymTqKJhaaoKA9f//RsamlqaW/3XLcgA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Accepts input from `0` to `239999` and outputs `0` for times, `1` for non-times. Explanation:
```
    ¬π‚Å∞‚Å∞     Literal 100
   ‚≠Ü        Map over implicit range and join
        Œπ   Current index
       ‚Ä∫    Greater than
         ‚Åµ‚Åπ Literal 59
  ÔºÆ         Input as a number
 ‚çò          Convert to a string using string as base
‚åà           Maximum
            Implicitly print
```
`BaseString` doesn't require the string base to have distinct characters, so this string just has 60 `0`s and 40 `1`s.
Unfortunately taking the base numerically returns an empty list for an input of zero, which takes an extra three bytes to handle, pushing the byte count above 11. But fortunately I can substitute an acceptable non-zero number in only two bytes, so another 11-byte alternative is possible:
```
‚Ä∫‚Å∂‚Å∞‚åà‚Ü®‚à®ÔºÆœá¬π‚Å∞‚Å∞
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMO9KDWxJLVIw8xAR8E3sSIztzRXwymxOFXDv0jDM6@gtMSvNDcJKK@po2BoACYMNIHA@v9/I2NTS1PL/7plOQA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Accepts input from `0` to `239999` and outputs a Charcoal boolean, `-` for times, no output for non-times. Explanation:
```
 ‚Å∂‚Å∞         Literal 60
‚Ä∫           Is greater than
      ÔºÆ     Input as a number
     ‚à®      Logical Or
       œá    Predefined variable `10`
    ‚Ü®   ¬π‚Å∞‚Å∞ Convert to base 100 as a list
   ‚åà        Maximum
            Implicitly print
```
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), ~~14~~ 9 bytes
-5 bytes thanks to ngn
```
*/60>100\
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NSkvfzMDO0MAg5n@auqWlgqEpEFsYKBgZmxooWFqCRSxAYgYgzn8A "K (ngn/k) ‚Äì Try It Online")
Based on [Ad√°m's APL solution](https://codegolf.stackexchange.com/a/200094/75681) and Kevin Cruijssen's suggestion.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), ~~18~~ 9 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
‚óÑ+‚ñë2/i‚ïô‚ïü<
```
[Try it online.](https://tio.run/##PZIxTgQxDEX7nIKeAtuZhLHEUZDQNgtIIBqOwAUoFkTF3eYig/08osko/l/@P2/39fT@9Pj2ct4fru737fvjevv6tJvn7fKzXX7v9l2aNmvD25Q2tbk3lZiJNo2hxlRjbBaC9VDiiGsfeZ15TbWnuqS6pLqkuqS6hDrWUIeHGkdcfeR15pXAiiRUMlZkMJlMZha5Tc9Y0xNnTtbBZDLBs@JxPF718TiejFKyjCwjy8gysoysOPEoHsWjeBQPMOhj9DH6GH2MPkYfo4/Rx@hj9DH6WD2dPc4eZ4@zx9nj7HH2OHucPc4eZ4//IzwYFsSieGA8OAJSeF186jfmffkpp5ZTcRZzKehS1KWwS3GXAi9FXgq9FHsp@FL0hZrxp4FJLyi9qPR0/gE)
**Explanation:**
```
‚óÑ+        # Add builtin 10,000,000 to the (implicit) input-integer
  ‚ñë       # Convert it to a string
   2/     # Split it into parts of size 2: [10,hh,mm,ss]
     i    # Convert each to an integer
      ‚ïô   # Pop and push the maximum
       ‚ïü< # And check if it's smaller than builtin 60
          # (after which the entire stack joined together is output implicitly)
```
[Answer]
# [Red](http://www.red-lang.org), 63 bytes
```
f: func[n][either n % 100 > 59[return 0][if n > 1[f n / 100]]1]
```
[Try it online!](https://tio.run/##HYsxDgIxDAS/sjqJEpEggjBFHkFruUB3ji5NQJbv/SGh2Slm1nTrL91Y0MsT5WgrN2Gtvquh4YQYAjISsakf1hCEaxkmI/LkZRYiUXr5mL7XHQ6OiXC9jedwNDc9wv0PIuGv1ebsWM55QYGL9B8 "Red ‚Äì Try It Online")
Of course the recursive function with integers is much shorter than the below version that works on strings.
# [Red](http://www.red-lang.org), ~~139~~ ~~130~~ 115 bytes
```
func[s][s: pad/left/with s 6 #"0"
not any collect[foreach n collect[loop 3[keep to 1 take/part s 2]][keep n > 60]]]
```
[Try it online!](https://tio.run/##PYxBCoMwFET3nmJI18VoqzQuPES3IYsQExRDEuIvxdPbgG1Xb5hhXrbT8bSTVJUbcLhXMHJTchuQ9FR766h@LzRjQ48L46wKkaDDDhO9t4aki9lqMyP8Gx9jwk2u1iZQRAPSq62TzlQsrVLnEjCi50qp42cgSNZ0goG1d84LGs7Fye7B@28QgimZ8hJImpj28mLXkcGBiuoD "Red ‚Äì Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~33~~ 32 bytes
```
p=%100\<60;echo $[$1$p&$1/100$p]
```
[Try it online!](https://tio.run/##S0oszvj/v8BW1dDAIMbGzMA6NTkjX0ElWsVQpUBNxVAfKKxSEPv//39DU0tTSwA "Bash ‚Äì Try It Online")
Input is passed as an argument.
Output is 0 (falsey) or 1 (truthy).
(I've deleted an earlier 45-byte version that used egrep.]
[Answer]
# [Zsh](https://www.zsh.org/), 28 bytes
```
e=%100/60;(($1$e||$1/100$e))
```
[Try it online!](https://tio.run/##fU/RCoMwDHzPVwiL2MKG7UYFN50fIj7IqHQgG0wfxtRv77oYX5eH5HrXHLnP4HwnpPC2jLVSaaYuQqBGO8@o08CgldLbm3tGWIEE6CIqxcDkKwg/V5AzYxgEgaTjiRhySkqqhD2yzSxnM7MyYYRVsO/7CLCL2n60r0c72uEMQrgyOO9Rxy7cTMc6glLCLwCH2VLwk8Q/m0VR4IST6OusqVUj9RJXVaEO5sp98V8 "Zsh ‚Äì Try It Online")
Returns via exit code.
Since `$parameters` are expanded before `((arithmetic))`, $e expands to `%100/60` before arithmetic is done.
There are 2 other 28 byte solutions I found as well, albeit not as interesting:
```
((h=100,$1%h/60||$1/h%h/60))
```
```
(($1%100/60||$1/100%100/60))
```
[Answer]
# [Turing Machine Simulator](http://morphett.info/turing/turing.html), ~~299~~ ~~272~~ 269 bytes
```
0 _ _ l 1
0 * * r 0
1 * _ l 2
* _ t * t
2 6 f * f
2 7 f * f
2 8 f * f
2 9 f * f
2 * _ l 3
3 * _ l 4
4 6 f * f
4 7 f * f
4 8 f * f
4 9 f * f
4 * _ l 5
5 0 _ l 6
5 1 _ l 6
5 2 _ l 6
5 3 _ l 6
5 * _ l 7
6 _ t * t
6 1 t * t
6 2 t * t
6 * f * f
7 _ * * t
7 1 _ * t
7 * f * f
```
[Run in Turing Machine Simulator](http://morphett.info/turing/turing.html?073d1e0b9d119d1e74708bcb2957d99d).
Halts with `t` on the tape for true inputs and a prefix of the input and `f` for false inputs.
[Answer]
# T-SQL, ~~42~~ 41 bytes
Saved 1 byte thanks to @Neil
Supports all positive integer input
Returns 1 for true, 0 for false
```
DECLARE @ INT=235959
PRINT-1/~(@/240000+@/100%100/60+@%100/60)
```
[Answer]
# VBA, 177 bytes
```
Sub a()
x=1: i=""
If Len(i)<6 Then Do Until Len(i)=6: i="0"&i: Loop
s = Right(i, 2): m = Left(Right(i,4),2): h = Left(i,2)
If s>59 Or m>59 Or h>23 Then x=0
Debug.Print s
End Sub
```
Works for values above 235959, assigns x to output 1 or 0 with input as i
[Answer]
# [JavaScript (V8)](https://v8.dev/), ~~50~~ ~~48~~ 46 bytes
*-2 bytes each thanks to @kanine and @l4m2*
```
a=>a.padStart(6,0).match(/../g).every(x=>x<60)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifk1qikGb7P9HWLlGvIDEluCSxqETDTMdAUy83sSQ5Q0NfT08/XVMvtSy1qFKjwtauwsbMQPN/QVFmXolGmoaSkbGppamlkqamtQIXkqCZgZkBSPA/AA "JavaScript (V8) ‚Äì Try It Online")
[Answer]
# [JavaScript (Node.js)], 26 bytes
```
f=>!/[6-9].(..)?$/.test(f)
```
Simple Javascript Regular Expression
JavaScript (Node.js) ‚Äì [Try It Online](https://tio.run/##y0osSyxOLsosKNFNSkxKzdHNy09J/f@/xDbN1k5RP9pM1zJWT0NPT9NeRV@vJLW4RCNN839yfl5xfk6qXk5@ukaJhoGmJheqiKWphaUlpiimkAk2MVNs6kywCWJVaYYpaGSMU9gUm7AZWPg/AA)
[Answer]
# T-SQL, 64 bytes
```
SELECT*FROM t WHERE 60>LEFT(RIGHT('000'+v,4),2)AND 60>RIGHT(v,2)
```
Input is taken from pre-existing table *t* with varchar field *v*, [per our input standards](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
Outputs 1 row (with the original value) for "true", and 0 rows for "false".
Accepts only values in the specified range (`0` to `235959`), so doesn't validate the first 2 digits.
[Answer]
# [PHP](https://php.net/), 60 bytes
```
<?=preg_match('#\d+([01]\d|2[0-3])([0-5]\d){2}#',$argn+1e6);
```
[Try it online!](https://tio.run/##K8go@P/fxt62oCg1PT43sSQ5Q0NdOSZFWyPawDA2JqXGKNpA1zhWE8jVNQXyNauNapXVdVQSi9LztA1TzTSt//83Mja1NLXkMjI2g1BcRiZQAQPDf/kFJZn5ecX/dd0A "PHP ‚Äì Try It Online")
Basically regex and not much golfable, but fun. Inputs above 235959 are indeterminate.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 76 bytes
supports ***any*** number 
```
!FreeQ[FromDigits/@Join@@@IntegerDigits/@Tuples[Range/@{24,6,10,6,10}-1],#]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277X9GtKDU1MNqtKD/XJTM9s6RY38ErPzPPwcHBM68kNT21CCYaUlqQk1ocHZSYl56q71BtZKJjpmNoACZqdQ1jdZRj1f4HFGXmlSg4pEcbGZtamlrG/v8PAA "Wolfram Language (Mathematica) ‚Äì Try It Online")
]