[Question]
  [
## Context
When I was a little kid, I watched a Disney movie where [Goofy](https://en.m.wikipedia.org/wiki/Goofy) told his son "Boy, even a broken clock is right two or three times a day." ([see this youtube clip](https://youtu.be/pMw_oy-2wZY), courtesy of [@Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)).
## Rationale
Given the previous statement, we wish to look at a clock that is *stopped* and answer the following question: *is this clock telling the correct time?*, [decision-problem](/questions/tagged/decision-problem "show questions tagged 'decision-problem'")-style. But we will also do it [*Goofy*](https://en.m.wikipedia.org/wiki/Goofy) style, assuming a stopped clock gets the correct time 3 times a day.
# Task
Pick some time of the morning with at least minute precision. Call it \$t\$.
The function/full program/etc you submit must satisfy the following requirements:
1. if executed at \$t\text{ am}\$ and at \$t\text{ pm}\$, your code produces an observable output `a` (think *Truthy* in [decision-problem](/questions/tagged/decision-problem "show questions tagged 'decision-problem'") challenges).
2. for every calendar day, there is a third time \$t\_1\$ distinct from \$t\text{ am}\$ and \$t\text{ pm}\$ such that, if your code is ran at that time, your code also deterministically produces the observable output `a`. This means \$t\_1\$ may be constant or it may be a function of the day the code is ran at.
3. if ran at any other time of the day, your code produces an observable output `b` that must be distinct from `a` (think *Falsy* in [decision-problem](/questions/tagged/decision-problem "show questions tagged 'decision-problem'") challenges).
Recall that your code should be precise at least to the minute. This means that you may decide that seconds don't matter for your answer, but you might also want to decide that your answer checks up to nanoseconds in order to decide if it is *that* time of the day.
# Input
Either your code takes no input or it takes the "current" time. For the time, acceptable formats include, but are not limited to:
* Any ISO format for date/time strings where time is given at least to the minute;
* An integer list with `[hours, minutes]` or `[hours, minutes, seconds]` or any similar list with further subdivisions of the second; (this order may be reversed but may *not* be shuffled)
* Different arguments, each representing one element from the lists above.
# Output
A single, well-defined, observable output `a` if your code is run at \$t\text{ am}\$, at \$t\text{ pm}\$, or at \$t\_1\$, as specified in your answer. If ran at any other time, your code produces the observable output `b`, distinct from `a`.
# Bonus imaginary internet points
Bonus imaginary internet points will be awarded to the shortest answer for which \$t\_1\$ isn't constant. If this question turns out to receive enough attention, this will turn into an actual rep bounty.
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it! If you dislike this challenge, please give me your feedback. Happy golfing!
  
[Answer]
# JavaScript (ES6), 13 bytes
Takes input as `(h)(m)`. Returns *true* for `01:00`, `02:00` and `13:00`, or *false* for anything else.
```
h=>m=>26%h<!m
```
[Try it online!](https://tio.run/##fcw9CoMwAIbh3VN8BQsJ2iC2OLTGS3gBg39RjJEYukjOnqZ17/QOD7yzeIu9NdNmb6vuej9wL3mleJUXV1lelB@0IRIc2QsSJfJHaJJQHBHwNXWaClb8mnDcs9OBVq@7Xnq26JE08SGZ1bU10zoSyjbR1VYYS/IUGXXP@FB/uEkxEEmJojScXeT8Bw "JavaScript (Node.js) – Try It Online")
### How?
Testing \$26\bmod h<\delta\_m\$ is equivalent to test that we have \$m=0\$ and \$26\equiv 0\pmod h\$.
For \$0<h\le23\$, we have \$26\equiv 0\pmod h\$ iff \$h\$ divides \$26\$, i.e. \$h\in\{1,2,13\}\$.
For the edge case \$h=0\$, `26%h` results in `NaN` which is neither greater nor lower than any other value, so the test returns *false* as expected, no matter the value of \$m\$.
### Other possible values
This program generates all possible values \$n<1000\$ for the expression \$n\bmod h\$.
```
for(n = 1; n < 1000; n++) {
  A = [...Array(24)].map((_, x) => x).filter(x => n % x == 0);
  if(A.length == 3 && A.some(x => A.includes(x + 12))) {
    console.log(n, A);
  }
}
```
[Try it online!](https://tio.run/##JY1NDoIwFIT3nmI2kjbgC6A7xKTnMMY0UBBTWlLQYAxnr0U2k2/m/cxTvuVYuW6YDsbWyvvGOmZQIitgcEaWpmmgOOb47gARJlciEs7JD8tP/Ea9HBi7J5g5yktQajo9Kcfm1RrsEaBEyotw3jVMkFamnR5reEQUQdBoe7WtC@pMpV@1GoOPkeWcb71AZc1otSJtW2YSiP@/Zbd4/wM "JavaScript (Node.js) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, ~~26~~ 25 bytes + Bonus imaginary Internet points!
```
egrep '(.)T(11|23|0\1)00'
```
[Try it online!](https://tio.run/##S0oszvj/PzW9KLVAQV1DTzNEw9Cwxsi4xiDGUNPAQP3/fyMDIwMDY0PLEEMDQwtdA3MDAwA "Bash – Try It Online")
*Thanks to @mypronounismonicareinstate for pointing out that the ISO 8601 allows omitting the colon in the time part, which saves a byte in the code. (ISO 8601 also allows omitting the hyphens in the date, but that doesn't affect the regex.)*
This accepts input on stdin in a format like
`20200319T1018-0700`
which is a basic ISO 8601 format with precision to the minute.
The result is in the exit code: `0` for truthy (one of the three Goofy times), `1` for falsey (everything else).
The three times it outputs `0` are at:
* 11:00 am
* 11:00 pm
* d:00 am where d is the last digit of the date.
So, today, March 19, it would output truthy (exit code 0) for 9 am (because 9 is the last digit of the date 19), 11 am, and 11 pm.
[Answer]
# [R](https://www.r-project.org/), 23 bytes
```
function(h,m)26%%h|m|!h
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jQydX08hMVTWjJrdGMeN/moahjoEmV5qGEYQyNIbQBlCujqHmfwA "R – Try It Online")
Port of [Arnauld's solution](https://codegolf.stackexchange.com/a/201380/86301), go upvote his!
Outputs `FALSE` at 1:00, 13:00 and 2:00, and `TRUE` otherwise.
---
Previous version:
# [R](https://www.r-project.org/), 26 bytes
```
function(h,m)!h|m|(h/6)%%1
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jQydXUzGjJrdGI0PfTFNV1fB/moaZjoEmV5qGoRGUtoDQBhDKTMdQ8z8A "R – Try It Online")
Outputs `FALSE` at the three times:
\$t\_{am}\$ = `6:00`  
\$t\_{pm}\$ = `18:00`  
\$t\_1\$ = `12:00`
and `TRUE` at any other time.
Indeed, for the output to be `FALSE`, we need `h≠0`, `m=0`, and `h` to be a multiple of 6.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~22~~ \$\cdots\$ ~~20~~ 19 bytes
Saved a byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!! 
```
f(h,m){h=26%~h<!m;}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0MnV7M6w9bITLUuw0Yx17r2f25iZp6GZjVXWn6RRmZeiUKGrYF1ho2RibW2doYmTDAXKJhrY2YAFMzVzEzTgBikWVAElEzTUFI1MEqxAhExeUo6IBlrrtr/AA "C (gcc) – Try It Online")
Returns `1` for noon, midnight and 1am, `0` otherwise.  
Adaptation of [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s [formula](https://codegolf.stackexchange.com/a/201380/9481).
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-!`](https://codegolf.meta.stackexchange.com/a/14339/), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Inspired by [Kevin's choice of times](https://codegolf.stackexchange.com/a/201367/58974). Input as 2 integers in the order `h, m`. Outputs `true` at `00:00`, `01:01` and `13:01` and `false` otherwise.
```
%C*VÉ©Nx
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LSE&code=JUMqVsmpTng&input=MTIKMTI)
```
%C*VÉ©Nx     :Implicit input of integers U=h and V=m
%C           :U modulo 12 (=1 if U=1 or U=13)
  *V         :Multiplied by V (=1 if above and V=1)
    É        :Subtract 1 (=0 if all above)
     ©       :Logical AND with
      N      :Array of inputs (i.e., [U,V])
       x     :Reduced by addition (=0 if U=V=0)
             :Implicit output of boolean negation of result
```
---
A port of [Arnauld's solution](https://codegolf.stackexchange.com/a/201380/58974) would be 1 byte shorter.
```
26%U<!V
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=MjYlVTwhVg&input=OAo4)
[Answer]
# [Ruby](https://www.ruby-lang.org), ~~48~~ 44 bytes
*-4 bytes thanks to [Value Ink](https://codegolf.stackexchange.com/users/52194/value-ink)!*
Differs from other answers so far in that it (i) takes no input and (ii) has a unique \$t\_1\$ for every day of the year.
```
p (t=*Time.now)[2]%12+t[1]<1||t[1,2]==t[3,2]
```
[Try it online!](https://tio.run/##KypNqvz/v0BBo8RWKyQzN1UvL79cM9ooVtXQSLsk2jDWxrCmBkjrGMXa2pZEGwPp//8B "Ruby – Try It Online") (actual code) 
[Try it online!](https://tio.run/##TY7BCsIwEETv/YqlEEg0hmSLB8X4Fd5iDrVNaaGtoikixm@PiScPM8u83YW5L5dX7PQ5bo605xODN9wW/4CSSGz32Upi0sLC0AH1enUaJidm96QoUfKKo@L5jxm0ROHaG2UPKoQ0OVqtvUknFj6RSiGwYsLVTQ/tFUIfCoBMt7s/OmUK0ImmHsdfo5Td3BZJ8Qs "Ruby – Try It Online") (demo version showing the three times that will return `true` on a given date)
Outputs `true` at 00:00, 12:00, and *month*:*day* (03:20 for today, 20 March); `false` otherwise.
`*Time.now` yields an array of the form `[sec, min, hour, day, month, year, wday, yday, isdst, zone]`, of which the first 8 elements are integers (but only *min*, *hour*, *day*, and *month* are used here). Then print `true` if *hour* (mod 12) and *min* are both 0, or if *hour* = *month* and *min* = *day*.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~16~~ ~~11~~ 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
Taking input in the format `[minutes, hours]`:
```
`12%*ΘIO_~
```
[Try it online.](https://tio.run/##yy9OTMpM/f8/wdBIVevcDE//@Lr//6MNDHUMjWMB)
Without input and using the current time builtins:
```
ža12%žb*Θžažb+_~
```
[Try it online](https://tio.run/##yy9OTMpM/f//6L5EQyPVo/uStM7NALKBDO34uv//AQ) (not very useful right now..) or [try it online with emulated hours/minutes](https://tio.run/##yy9OTMpM/a8UWpyqUJyfm6qQkV9aVKyQmJeikJuZV1qSWqxQCRJJzUlTyEgtSrVSUIrhMjRWUFDyAAmDuKFcBoZAvi9EOUgk7H@EoZFqpNa5GRGR2vF1//8DAA).
Both programs use the three times:
\$t\_{am}\$ = `1:01`  
\$t\_{pm}\$ = `13:01`  
\$t\_1\$ = `00:00`
And will output `1` on any of those three times above, and `0` on any other time.
**Explanation:**
```
`           # Push the values in the (implicit) input-pair separated to the stack
 12%        # Take modulo-12 on the hours, to make the 24-hour a 12-hour clock
    *       # Multiply it with the minutes
     Θ      # And check if it's exactly 1 (1 if truhy; 0 if falsey)
I           # Push the input-pair again
 O          # Sum them together
  _         # Check if it's exactly 0 (1 if truhy; 0 if falsey)
      ~     # And then check if either of the two checks is 1
            # (after which the result is output implicitly)
ža          # Push the current hours
  12%       # Modulo 12, to make the 24-hour a 12-hour clock
     žb     # Push the current minutes
       *    # Multiply them together
        Θ   # And check if it's exactly 1 (1 if truthy; 0 if falsey)
žažb        # Push the current hours and minutes again
    +       # Add them together
     _      # Check if it's exactly 0 (1 if truthy; 0 if falsey)
         ~  # And then check if either of the two checks is 1
            # (after which the result is output implicitly)
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
_₂I%›
```
Port of [*@Arnauld*'s JavaScript answer](https://codegolf.stackexchange.com/a/201380/52210), so make sure to upvote him!!
Takes two loose inputs, in the order `minutes`, `hours`.
Will also output `1` for any of these three times below, and `0` on any other time:
\$t\_{am}\$ = `01:00`  
\$t\_{pm}\$ = `13:00`  
[Try it online](https://tio.run/##MzBNTDJM/f8//lFTk6fqo4Zd//8bGHAZGgMA) or [verify some more test cases](https://tio.run/##MzBNTDJM/W9k4uYXemifscGjhllllSGPGjZ4RYBJpcP7rQ7vV3jUNklByb7yf/yjpqYI1UcNu/7r/AcA).
**Explanation:**
```
_     # Check if the (implicit) input-integer (minutes) is 0 (1 if truthy; 0 if falsey)
 ₂    # Push 26
  I   # Push the second input-integer (hours)
   %  # Take 26 modulo-hours (will result in 26 if the hours are 0 in the legacy version)
    › # Check if the first value is larger than the second
      # (after which it is output implicitly as result)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 21 bytes
```
lambda h,m:26%-~h<m<2
```
[Try it online!](https://tio.run/##RY7BCsIwEETv/Yo1ICQQoY3SQ2luXvwHL7EmpmCSsuQior8eN1Xwssu8nR1meWSf4r44fS53Ey5XA16GQfXb3duPYVQlg4Ynb2UnJO@@U9F6NS4heJgjoIk3y9VBDA1UGP6wbysEpAzHKViQmB3pjQa@gurNqwkWnGPm7BSnhGinzCR1Afr5HY4pWibKBw "Python 3 – Try It Online")
**Input**: hour and minute, as integers  
**Output**: `True` if the time is `00:01`,`01:01`,`12:01`, otherwise `False`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~35~~ \$\cdots\$ ~~22~~ 19 bytes
Saved a byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!  
Saved 3 bytes thanks to [Surculose Sputum](https://codegolf.stackexchange.com/users/92237/surculose-sputum)!!! 
```
lambda h,m:26%~h==m
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSFDJ9fKyEy1LsPWNvd/Wn6RQoZCZp5CUWJeeqqGkYmmFZcCSDAXIWhmABJUyExTSNMAata0KijKzCvRSFOqzrAyMKq1qs4FUUqa/wE "Python 3 – Try It Online")
Returns `True` for noon, midnight and 1am, `False` otherwise.  
Adaptation of [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s [formula](https://codegolf.stackexchange.com/a/201380/9481).
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 28 bytes
```
^.
$&$&$&$&
\G\d
$*
^1{8}:18
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wP06PS0UNArli3GNSuFS0uOIMqy1qrQwt/v83sLAyNOcCkRZg0pLL0AQkAiItwKQll5EBSAREWoBJSwA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
^.
$&$&$&$&
```
Repeat the hour tens digit four times.
```
\G\d
$*
```
Convert the hour digits to unary.
```
^1{8}:18
```
They must sum to 8 and the minutes must be 18 (arbitrarily chosen to reuse the same digits).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
⁼²№⟦↨Ｓ⁴Ｎ⟧⁹
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMO1sDQxp1jDSEfBOb8UyI92SixO1fDMKygtCS4BqkjX0NRRMAFisJBfaW5SapGGZqyOgqWmpqb1//@GpgoGlv91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Takes input as hour and minute separated by a space, on separate lines, or as a JSON list i.e. `[22, 10]`, and outputs `-` for `09 09`, `15 09` and `21 09` only. Explanation:
```
   ⟦    ⟧   List of
     Ｓ      Hours as a string
    ↨ ⁴     Interpreted as base 4
       Ｎ    Minutes
  №      ⁹  Count `9`s
⁼²          Must be 2 of them.
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 19 bytes
Returns true at 6:00, 12:00, 18:00.
```
->h,m{h>0&&m|h%6<1}
```
[Try it online!](https://tio.run/##KypNqvyfZhvzX9cuQye3OsPOQE0ttyZD1czGsPZ/tJaBnp6RcaxeQVF@SmlyiUa0gY6hqY6xgY6JaaymQkq@Qg1QUw2XgkJBaUmxgpKqgVGKFYhQsFVQrk6LBkrG1iqpgmmu1LyU/wA "Ruby – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
Turns out porting [Arnauld's answer](https://codegolf.stackexchange.com/a/201380/53748) is a byte shorter than my original answer (which I've kept below)
```
26%<¬}
```
A dyadic Link accepting the hour (an integer in `[0,23]`) on the left and the minute (an integer in `[0,59]`) on the right which yields 1 at three times (not varying by day), `2,0` (02:00), `1,0` (01:00), and `13,0` (13:00).
**[Try it online!](https://tio.run/##y0rNyan8/9/ITNXm0Jra////Gxr/NwAA "Jelly – Try It Online")**
---
**My 7**
```
æle1,98
```
A dyadic Link accepting the hour (an integer in `[0,23]`) on the left and the minute (an integer in `[0,59]`) on the right which yields 1 at three times (not varying by day), `1,1` (01:01), `2,49` (02:49), and `14,49` (14:49).
**[Try it online!](https://tio.run/##y0rNyan8///wspxUQx1Li////xua/DexBAA "Jelly – Try It Online")**
[Answer]
# perl -ple, 18 bytes
```
$_=/(2[01]|08):00/
```
Reads a time in `HH:MM` format from `STDIN` (optionally preceded by a date in `YYYY-MM-DD` format (or anything else which doesn't like a time)). 
Print `1` followed by a newline if the time is `08:00`, `20:00` or `21:00`; otherwise, it prints a single newline.
[Answer]
# [W](https://github.com/A-ee/w), 5 [bytes](https://github.com/A-ee/w/wiki/Code-Page)
... With True and False swapped around; they're distinctive anyway.
```
♥─y¥•
```
Uncompressed:
```
!26bm>
```
# Explanation
```
!      % Check whether the input is equal to 0
   b   % Push the second input
 26 m  % Push 26 % b
     > % Is input == 0 larger than the above value?
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~18~~ 17 bytes + Bonus imaginary Internet points
```
(.)T(11|23|0\1)00
```
[Try it online!](https://tio.run/##K0otycxLNPz/X0NPM0TD0LDGyLjGIMZQ08Dg/38jAyMDXQNjXUPLEANLAyDT3MrAAAA "Retina – Try It Online")
*Note that TIO is having technical issues at the moment, so the link that it gave me above may or may not work.*
---
*Thanks to @mypronounismonicareinstate for pointing out that the ISO 8601 allows omitting the colon in the time part, which saves a byte in the code. (ISO 8601 also allows omitting the hyphens in the date, but that doesn't affect the regex.)*
---
I don't really know Retina, but this port of my bash answer appears to be right :) .
The program accepts input on stdin in a format like
20200319T1018-0700
which is a basic ISO 8601 format with precision to the minute.
Like my bash answer, it outputs truthy (0) for 11:00 am, 11:00 pm, and d:00 am where d is the last digit of the current date. It outputs falsey (1) otherwise.
[Answer]
# [Perl 5](https://www.perl.org/) -lF: , 34 bytes
```
say$F[0]%12&&$F[0]!=1||$F[1]>0?0:1
```
[Try it online!](https://tio.run/##NcaxDkAwFAXQvX8hwVa5r1hegs3mC6RDB4OkQbBI@u2eklhOzjbtvhY53JX2I2xGJs@/JQ2FEEe2RQcmEYABBXol858U4o1CySgVKkZ1r9s5r8sheqgLEEQvzvf8AA "Perl 5 – Try It Online")
Reads current time input from stdin in hh:mm format. Outputs 1 at 00:00, 01:00, and 12:00; 0 at all other times.
[Answer]
# [Io](http://iolanguage.org/), 19 bytes
Port of @Arnauld's answer...
```
method(U,V,26%U>=V)
```
[Try it online!](https://tio.run/##y8z/n5yTn5ytYGWrEPM/N7UkIz9FI1QnTMfITDXUzjZMEyKtYahjoKlQUJSZV5KTxwURMsYUMtUxggv9BwA "Io – Try It Online")
]