text:
Mirrored Digital Clock
Many digital clocks display the time using simplified digits comprised of only seven different lights that are either on or off:

When mirrored horizontally, the digits 018 don't change because they are symmetrical. Also, the digits 2 and 5 get swapped, 2 becoming 5 and vice versa. All the other digits become invalid when mirrored.
Thus, given a 24-hour digital clock, there are many clock readings such that the mirrored image of the digital display is also a valid clock reading. Your task is to output all such clock readings along with the mirrored readings.
For example, 22:21 becomes 15:55, and 00:15 becomes 21:00. On the other hand, 12:34 or 16:27 are no longer valid when mirrored (digits 34679 become invalid), and neither are 22:22 or 18:21, because, as there are only 24 hours in a day and 60 minutes in an hour, no sane clock would display 55:55 or 12:81.
Task
Write a program or a function that takes no input and outputs all valid pairs in ascending order as shown below:
00:00 - 00:00
00:01 - 10:00
00:05 - 20:00
00:10 - 01:00
00:11 - 11:00
00:15 - 21:00
00:20 - 05:00
00:21 - 15:00
00:50 - 02:00
00:51 - 12:00
00:55 - 22:00
01:00 - 00:10
01:01 - 10:10
01:05 - 20:10
01:10 - 01:10
01:11 - 11:10
01:15 - 21:10
01:20 - 05:10
01:21 - 15:10
01:50 - 02:10
01:51 - 12:10
01:55 - 22:10
02:00 - 00:50
02:01 - 10:50
02:05 - 20:50
02:10 - 01:50
02:11 - 11:50
02:15 - 21:50
02:20 - 05:50
02:21 - 15:50
02:50 - 02:50
02:51 - 12:50
02:55 - 22:50
05:00 - 00:20
05:01 - 10:20
05:05 - 20:20
05:10 - 01:20
05:11 - 11:20
05:15 - 21:20
05:20 - 05:20
05:21 - 15:20
05:50 - 02:20
05:51 - 12:20
05:55 - 22:20
10:00 - 00:01
10:01 - 10:01
10:05 - 20:01
10:10 - 01:01
10:11 - 11:01
10:15 - 21:01
10:20 - 05:01
10:21 - 15:01
10:50 - 02:01
10:51 - 12:01
10:55 - 22:01
11:00 - 00:11
11:01 - 10:11
11:05 - 20:11
11:10 - 01:11
11:11 - 11:11
11:15 - 21:11
11:20 - 05:11
11:21 - 15:11
11:50 - 02:11
11:51 - 12:11
11:55 - 22:11
12:00 - 00:51
12:01 - 10:51
12:05 - 20:51
12:10 - 01:51
12:11 - 11:51
12:15 - 21:51
12:20 - 05:51
12:21 - 15:51
12:50 - 02:51
12:51 - 12:51
12:55 - 22:51
15:00 - 00:21
15:01 - 10:21
15:05 - 20:21
15:10 - 01:21
15:11 - 11:21
15:15 - 21:21
15:20 - 05:21
15:21 - 15:21
15:50 - 02:21
15:51 - 12:21
15:55 - 22:21
20:00 - 00:05
20:01 - 10:05
20:05 - 20:05
20:10 - 01:05
20:11 - 11:05
20:15 - 21:05
20:20 - 05:05
20:21 - 15:05
20:50 - 02:05
20:51 - 12:05
20:55 - 22:05
21:00 - 00:15
21:01 - 10:15
21:05 - 20:15
21:10 - 01:15
21:11 - 11:15
21:15 - 21:15
21:20 - 05:15
21:21 - 15:15
21:50 - 02:15
21:51 - 12:15
21:55 - 22:15
22:00 - 00:55
22:01 - 10:55
22:05 - 20:55
22:10 - 01:55
22:11 - 11:55
22:15 - 21:55
22:20 - 05:55
22:21 - 15:55
22:50 - 02:55
22:51 - 12:55
22:55 - 22:55

A trailing or a leading newline is allowed. Having a few spaces directly before a linefeed is also allowed. The times must be in format hh:mm, padded with zeros when necessary.
This is code-golf, so the shortest answer in bytes wins. As usual, standard loopholes are disallowed.

In Clean, a String is an array of Char. Is it acceptable if my answer gives a list of Char? The types look identical when bare-printed.

@Ourous Yes, I think it's fine. The consensus on meta seems to be that a string is a sequence of characters, and that's what a list of characters is.

In this seven-segment display, the digit 1 is not exactly identical to its mirror image because you can tell if the right-most segments or the left-most segments are used to form the vertical "line" which makes up the digit. I understand that we consider them identical here.

@JeppeStigNielsen let's pretend OP used an image with 14seg displays instead of 7seg, so the 1 could be centered.

@Steadybox Wow, I had this exact idea recently. I plan to use it on people during programming interviews. BTW I have a microwave oven which does not have a sane clock and allows you to specify things like 83:75 :-)

@Sparr I do not know what those fourteen segments would look like, but we are being too offtopic now, I guess.

05AB1E, 34 bytes
0125DâDâεÂ5nÂ‡í)}ʒ€н25‹P}':ý… - ý»

Try it online!
Explanation
0125                                # push "0125"
    Dâ                              # cartesian product with itself
      Dâ                            # cartesian product with itself
        ε       }                   # apply to each
         Â                          # bifurcate
          5nÂ                       # push 25 bifurcated
             ‡                      # transliterate
              í                     # reverse each
               )                    # wrap in a list
                 ʒ      }           # filter each on
                  €н                # head of each
                    25‹             # less than 25
                       P            # product
                         ':ý        # merge on ":"
                            … - ý   # merge on " - "
                                 »  # join on newlines

Python 2, 187 180 178 177 bytes
R=range(11)
for t in['0000111122201250125012'[j::11]+':'+'0001112255501501501015'[i::11]for i in R for j in R]:print t+' - '+''.join(map(dict(zip('0125:','0152:')).get,t))[::-1]

Try it online!
Thanks for +1 Kevin Cruijssen.

APL (Dyalog Unicode), 84 bytesSBCS
Complete program outputting to STDOUT. Requires ⎕IO (Index Origin) to be 0 which is default on many systems.
{0::⋄∧/23 59≥⍎¨(':'≠t)⊆t←⌽'015xx2xx8x:'[⎕D⍳i←∊⍺':'⍵]:⎕←1↓⍕i'-'t}⌿1↓¨⍕¨100+0 60⊤⍳1440

Try it online!
⍳1440 that many ɩntegers
0 60⊤ convert to mixed-base ∞,60
100+ add 100 (this pads the needed 0s)
⍕¨ format (stringify) each
1↓¨ drop the first character from each (this removes the leading 1s)
{…}⌿ apply the following anonymous function column-wise (⍺ is top hour, ⍵ is minute)
 0:: if any error happens, return nothing
 ⋄ try:
  '015xx2xx8x:'[…] index this string with:
   ∊⍺':'⍵ the ϵnlisted (flattened) list of hour, colon, minute
   i← stored in i (for input)
   ⎕D⍳ ɩndices of each character in the list of Digits
  ⌽ reverse that
  t← store as t (for time)
  (…)⊆ group runs where:
   ':'≠t colon differs from t
⍎¨ execute (evaluate) each
 23 59≥ Boolean for each whether they are less than or equal to 23 and 59 respectively
 ∧/ are both true?
 : if so, then:
  ⍕i'-'t the formatted (space-separated) list of input, dash, time
  1↓ drop the first (space)
  ⎕← output to STDOUT

Python 2, 279 277 255 bytes
for h in range(1440):
 q=[[[0,(a+"52")[(a=="2")+(a=="5")*2]][a in"01825"]for a in c]for c in[("%02d"%e)[::-1]for e in[h%60,h/60]]]
 if all(q[0]+q[1]):
	z=[int(''.join(j))for j in q]
	if(z[1]<60)*(z[0]<24):print"%02d:%02d - %02d:%02d"%(h/60,h%60,z[0],z[1])

Try it online!
Credits

279 bytes reduced to 256 by dylnan.

256 bytes reduced to 255 by FlipTrack.

-1 byte

Retina, 57 bytes

 -
+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2
A`\b2?5
\b\d.
$&:
O`

Try it online! Explanation:

 -

Insert the separator.
+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2

Generate all possible sets of four mirrored digits.
A`\b2?5

Delete those with illegal hours.
\b\d.
$&:

Insert the colons.
O`

Sort into order.

Clean, 269 ... 172 170 bytes
import StdEnv
?n=toChar n+'0'
$c|c<2=c=7-c
n=[0,1,2,5]
t=flatlines[u++[' - ':v]\\[u,v]<-[[map?[a,b,10,x,y],map?[$y,$x,10,$b,$a]]\\a<-n,b<-n,x<-n,y<-n]|['23:59']>=max u v]

Try it online!
Ungolfed:
import StdEnv
numeral n = toChar (n+48)
mirror 2 = 5
mirror 5 = 2
mirror c = c
digits = [0, 1, 2, 5]
times
    = flatlines [ // flatten with interspersed newlines
        original ++ [' - ' : reflection] // insert separator
        \\ // generate all pairs of times and their mirrored copies
        [original, reflection] <- [
            [map numeral [a, b, 10, x, y], map (numeral o mirror) [y, x, 10, b, a]]
            \\ // generate every combination of display digits
            a <- digits,
            b <- digits,
            x <- digits,
            y <- digits
            ]
        | ['23:59'] >= max original reflection // make sure both times actually exist
        ]

Pyth, 48 bytes
Lj\:c2bjf!:T"5.:|25:"0mj" - ",ydyX_d`25)^"0125"4

Try it online!
Generates all possible combinations of 0125 and then manipulates them into the times. These are in the correct order because they are generated in lexicographic order. Finally, this filters out the extra invalid times by removing lines that match the regex 5.: or 25:. Sadly, it doesn't seem like compression works nicely on any of the strings that this program uses, unless I've made an error or oversight.

Perl 5, 147 bytes
map{$h=0 x($_<10).$_;map{$_="0$_"if$_<10;say"$h:$_ - $q:$i"if($i=reverse$h=~y/25/52/r)<60&&"$h$_"!~/[34679]/&&($q=reverse y/25/52/r)<24}0..59}0..23

Try it online!

Japt v2 (+ -R), 51 bytes
G²Çs4 ùT4 i':2Ã®+" - "+Zw r\d_^Z>1})r3,5Ãkf/5.|25):

Test it online!
Explanation
G²Ç   s4 ùT4 i':2Ã ®   +" - "+Zw r\d_  ^Z>1})r3,5Ã kf/5.|25):
G²oZ{Zs4 ùT4 i':2} mZ{Z+" - "+Zw r\dZ{Z^Z>1})r3,5} kf/5.|25):/   Ungolfed

G²              Calculate 16**2, or 256.
  oZ{       }   Create the range [0...256) and map each integer Z to:
Zs4               Convert Z to a base-4 string.  [0, 1, 2, 3, 10, ..., 3331, 3332, 3333]
    ùT4           Pad-left with 0's to length 4. [0000, 0001, 0002, ..., 3331, 3332, 3333]
        i':2      Insert a colon at index 2.     [00:00, 00:01, 00:02, ..., 33:31, 33:32, 33:33]

mZ{      }      Map each string Z in the resulting array to:
Zw r\dZ{     }    Reverse Z, and replace each digit Z' with
        Z^Z>1       Z' xor'd with (Z>1). This turns 2 to 3 and vice versa.
                  We now have [00:00, 10:00, 30:00, 20:00, 01:00, ..., 12:22, 32:22, 22:22]
Z+" - "+          Append this to Z with " - " in between. This gives
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 30:00, ..., 33:32 - 32:22, 33:33 - 22:22]
r3,5              Replace all 3s in the result with 5s.
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 50:00, ..., 55:52 - 52:22, 55:55 - 22:22]

k               Remove all results that
 f/5.|25):/       match the regex /(5.|25):/g. This removes times with impossible hours.

                Implicit: output result of last expression, joined with newlines (-R)

JavaScript (ES6), 142 bytes
f=(n=0)=>n<176?(s=(g=n=>d[n>>2]+d[n&3])(n%4*4|n/4&3,d='0152')+':'+g(n>>6|(n/4&12)),s<'25'?g(n>>4,d='0125')+`:${g(n&15)} - ${s}
`:'')+f(n+1):''

Try it online!

Charcoal, 59 bytes
Ｆ012Ｆ0125Ｆ0125Ｆ015¿›‹⁺ικ25⁼⁺λμ25«ικ:λμ - Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

Try it online! Link is to verbose version of code. Explanation:
Ｆ012Ｆ0125Ｆ0125Ｆ015

Create four nested loops for the unmirrored digits.
¿›‹⁺ικ25⁼⁺λμ25«

Check that neither the hours nor minutes is 25. (Mirroring the 25 minutes will result in 25 hours, so that's a no-go.)
ικ:λμ -

Print the unmirrored time.
Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

Print the mirrored time by converting the reversed digits (or 3 for the colon) from string to integer and looking them up in a translation table.
Alternatively, also for 59 bytes:
Ｆ¹¹Ｆ¹⁶¿⁻¹¹κ¿⁻²﹪κ⁴«≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θＦθ§0125:λ - Ｆ⮌θ§0152:λ⸿

Try it online! Link is to verbose version of code. Explanation:
Ｆ¹¹Ｆ¹⁶

Create loops for the hours and minutes.
¿⁻¹¹κ¿⁻²﹪κ⁴«

Exclude 25 and also any minutes ending in 2.
≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θ

Convert the hours and minutes to base 4.
Ｆθ§0125:λ

Print the digits looked up in a translation table.
 -

Print the separator.
Ｆ⮌θ§0152:λ⸿

Print the reversed digits looked up in a mirrored translation table.

C (gcc), 175 174 bytes
One off thanks to @Steadybox.
char*p,s[14],*e;f(t){for(t=0;sprintf(p=s,"%02d:%02d -",t/100,t%100),t<2400;)if(t++%10^2&&!strpbrk(s,"346789")&&t%100^26){for(e=s+12;p<e;p++)*e--=*p^7*(*p>49&*p<58);puts(s);}}

Try it online!

Befunge, 178 bytes
>0>:5g"7"`>v1\,+55<
v_^#`+87:+1_4>99p\ :99gg48 *-:55+/"0"+,55+%"0"+,":",\v
>$1+:55v v,," - "_^#-5g99,+"0"%+55,+"0"/+55:-*84gg99:<
v_@#!`+< >,\5^
 !"%*+,/4569RSTW
 *R4!+S5%/W9",T6

Try it online!

Jelly, 72 66 62 55 bytes
®ṢiÐ€Uị®
“0152:”©ṢṖp`⁺ḣ176j€“:”µ;"Ç€⁾25ẇ$ÐṂœs€2j€“ - ”Y

Try it online!
Niladic program. I got the double product of '0125' idea from the 05AB1E answer by Emigna but the rest I did without consulting that since the languages diverge after that. There are probably opportunities for golfing, possibly by a lot.
Explanation
The program works as follows:

Take all products of length four of the list of characters '0125' with “0152:”©ṢṖp`⁺. © copies the string '0152:' to the register for use later. ṢṖ sorts then pops the last element of the string → '0125'. ⁺ duplicates the product link.
ḣ176 removes any times with format 25xx or 5xxx (not valid hours).
j€“:” joins each pair of digits with a ':'. e.g. ['05'],['21']] → '05:12'.
Ç€ applies the first link to each of these times. It finds the index of each character in the string '0125:' then for each of those indices gets the character in the string '0152:' and reverses it. This is the mirror operation (reversing and swapping 2s and 5s).
µ;" concatenates the original time with the mirrored time → '05:2115:20'
⁾25ẇ$ÐṂ filters out the times with the substring '25'. This catches any time pairs with mirrored half 25:xx or 5x:xx. Note: I don't know why the $ is necessary. Perhaps someone could golf it out with the proper syntax but I'm not sure.
Split each of these times into two halves (œs€2) then join them with the string ' - ' (j€“ - ”).  '05:2115:20' → '05:21 - 15:20'.
Finally, Y joins all the strings with a newline and everything is implicitly printed.

Old versions
62 bytes
i@€®ị“:0152”
“:0125”©Ḋp`⁺ḣ176j€“:”µ,"UÇ€$F€⁾25ẇ$ÐṂœs€2j€“ - ”Y

Try it online!
66 bytes
“0125”
i@€¢ị“0152”
UṚÇ€
Ñp`⁺ḣ176µ,"Ç€j€€“:”j€“ - ”¹⁾2 ẇ$ÐṂ⁾25ẇ$ÐṂY

Try it online!
72 bytes
⁾25
i@€¢µẋ@€¢ṙ"
Ṛµ;@""Ç€Ḣ€€
“0125”p`⁺j€“:”ḣ176µ,"Ç€j€“ - ”¹⁾2 ẇ$ÐṂÑẇ$ÐṂY

Try it online!

Kotlin, 205 207 bytes
(0..1439).map{"%02d : %02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

Beautified
    (0..1439)
        .map { "%02d : %02d".format(it / 60, it % 60) }              // Make the times
        .let { it.map {i->
                i to i.reversed().map {x->                         // Pair it with the reversed times
                    "25180:X52180:".let{ it[it.indexOf(x)+7] }     // - X means bad times are removed
                }.joinToString("")                                 // - Make the string
            }.filter {(_,b)-> it.contains(b) }                     // Remove the unpaired times
                .map { (a, b) -> println("$a - $b") }              // Print out the pairs
        }

Test
fun main(args: Array<String>) {
    f()
}

fun f() =
(0..1439).map{"%02d:%02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

TIO
TryItOnline
Edits

+2 Steadybox - Fixed IO formatting

There's supposed to be a space on both sides of the -. Costs only two bytes to add: Try it online!

Fixed, I wonder if there is a way to get back to 205 bytes reducing the rest of the code

Deadfish~, 9627 bytes
{iiiii}ddcc{i}c{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}cc{dddd}iic{iiii}ddcc{i}c{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}cc{dddd}iic{iiii}ddcc{i}c{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}cc{dddd}iic{iiii}ddcc{i}c{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}cc{dddd}iic{iiii}ddcc{i}c{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}cc{dddd}iic{iiii}ddcc{i}c{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}cc{dddd}iic{iiii}ddcc{i}c{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}cc{dddd}iic{iiii}ddcc{i}c{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}cc{dddd}iic{iiii}ddcc{i}cdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}cc{dddd}iic{iiii}ddcc{i}cdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}cc{dddd}iic{iiii}ddcc{i}cdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}cc{dddd}iic{iiii}ddcic{i}dc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}icdc{dddd}iic{iiii}ddcic{i}dc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}icdc{dddd}iic{iiii}ddcic{i}dcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}icdc{dddd}iic{iiii}ddcic{i}dcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}icdc{dddd}iic{iiii}ddcic{i}dcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}icdc{dddd}iic{iiii}ddciic{i}ddc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}cdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}cdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}cdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dcdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dcdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dcdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiicdddddcdddddc{dddd}iic{iiii}ddciic{i}ddc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiicdddddcdddddc{dddd}iic{iiii}ddciic{i}ddcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddcdddddcdddddc{dddd}iic{iiii}ddciic{i}ddcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddcdddddcdddddc{dddd}iic{iiii}ddciic{i}ddcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddcdddddcdddddc{dddd}iic{iiii}ddciiiiiciiiiic{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiic{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiicdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiicdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}iicddc{dddd}iic{iiii}ddciiiiiciiiiicdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}iicddc{dddd}iic{iiii}dcdc{i}c{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}cic{dddd}ic{iiii}dcdc{i}c{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}cic{dddd}ic{iiii}dcdc{i}c{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}cic{dddd}ic{iiii}dcdc{i}c{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}cic{dddd}ic{iiii}dcdc{i}c{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}cic{dddd}ic{iiii}dcdc{i}c{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}cic{dddd}ic{iiii}dcdc{i}c{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}cic{dddd}ic{iiii}dcdc{i}c{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}cic{dddd}ic{iiii}dcdc{i}cdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}cic{dddd}ic{iiii}dcdc{i}cdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}cic{dddd}ic{iiii}dcdc{i}cdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}cic{dddd}ic{iiii}dcc{i}dc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}icc{dddd}ic{iiii}dcc{i}dc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}icc{dddd}ic{iiii}dcc{i}dc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}icc{dddd}ic{iiii}dcc{i}dc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}icc{dddd}ic{iiii}dcc{i}dc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}icc{dddd}ic{iiii}dcc{i}dc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}icc{dddd}ic{iiii}dcc{i}dc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}icc{dddd}ic{iiii}dcc{i}dc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}icc{dddd}ic{iiii}dcc{i}dcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}icc{dddd}ic{iiii}dcc{i}dcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}icc{dddd}ic{iiii}dcc{i}dcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}icc{dddd}ic{iiii}dcic{i}ddc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}cdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}cdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}cdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dcdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dcdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dcdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiicdddddcddddc{dddd}ic{iiii}dcic{i}ddc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiicdddddcddddc{dddd}ic{iiii}dcic{i}ddcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddcdddddcddddc{dddd}ic{iiii}dcic{i}ddcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddcdddddcddddc{dddd}ic{iiii}dcic{i}ddcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddcdddddcddddc{dddd}ic{iiii}dciiiiciiiiic{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}iicdc{dddd}ic{iiii}dciiiiciiiiic{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}iicdc{dddd}ic{iiii}dciiiiciiiiicdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}iicdc{dddd}ic{iiii}dciiiiciiiiicdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}iicdc{dddd}ic{iiii}dciiiiciiiiicdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}iicdc{dddd}ic{iiii}cddc{i}c{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}ciiiiic{dddd}dddc{iiii}cddc{i}c{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}ciiiiic{dddd}dddc{iiii}cddc{i}cdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}ciiiiic{dddd}dddc{iiii}cddc{i}cdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}ciiiiic{dddd}dddc{iiii}cddc{i}cdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}ciiiiic{dddd}dddc{iiii}cdc{i}dc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}c{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}c{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}c{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dc{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dc{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dc{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiic{d}iciiiic{dddd}dddc{iiii}cdc{i}dc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiic{d}iciiiic{dddd}dddc{iiii}cdc{i}dcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddc{d}iciiiic{dddd}dddc{iiii}cdc{i}dcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddc{d}iciiiic{dddd}dddc{iiii}cdc{i}dcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddc{d}iciiiic{dddd}dddc{iiii}cc{i}ddc{d}cc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicc{i}cdddddcc{dddd}dddc{iiii}cc{i}ddc{d}cic{dd}iiic{i}iiic{d}dddc{ii}dddcdc{i}cdddddcc{dddd}dddc{iiii}cc{i}ddc{d}ciiiiic{dd}dc{i}iiic{d}dddc{ii}ddcddc{i}cdddddcc{dddd}dddc{iiii}cc{i}ddc{d}icdc{d}ddddddc{i}iiic{d}dddc{i}iiiiiicic{i}dcdddddcc{dddd}dddc{iiii}cc{i}ddc{d}icc{dd}iiic{i}iiic{d}dddc{ii}dddcc{i}dcdddddcc{dddd}dddc{iiii}cc{i}ddc{d}iciiiic{dd}dc{i}iiic{d}dddc{ii}ddcdc{i}dcdddddcc{dddd}dddc{iiii}cc{i}ddc{d}iicddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciiiiiciiiiicdddddcc{dddd}dddc{iiii}cc{i}ddc{d}iicdc{dd}iiic{i}iiic{d}dddc{ii}dddciiiiciiiiicdddddcc{dddd}dddc{iiii}cc{i}ddcdddddcdddddc{d}ddddddc{i}iiic{d}dddc{i}iiiiiiciic{i}ddcdddddcc{dddd}dddc{iiii}cc{i}ddcdddddcddddc{dd}iiic{i}iiic{d}dddc{ii}dddcic{i}ddcdddddcc{dddd}dddc{iiii}cc{i}ddcdddddcc{dd}dc{i}iiic{d}dddc{ii}ddcc{i}ddcdddddcc

C, 225 bytes
h,m,l,r,d=10,L[]={0,1,5,9,9,2,9,9,8,9};M(h,m){l=L[h%d]*d+L[h/d];r=L[m%d]*d+L[m/d];return L[h%d]<9&L[h/d]<9&L[m%d]<9&L[m/d]<9;}f(){for(h=0;h<24;++h)for(m=0;m<60;++m)M(h,m)&l<60&r<24&&printf("%02d:%02d - %02d:%02d\n",h,m,r,l);}

Since there is no C answer, I post my own. Some other approach might be shorter.
Try it online!

195 bytes


text:
Easy-to-multiply numbers
Your task is to determine whether two numbers are easy to multiply. This means that their base-10 long multiplication doesn't have any carrying (regrouping) between place values, looking at both the multiplication steps and the addition step. This happens when each pair of digits being multiplied gives 9 or less and the sum of each column is 9 or less.
For example, 331 and 1021 are easy to multiply:
   331
x 1021
------
+  331
  662
   0
331
------
337951

And the same is true (as is always) if we multiply in the other order:
  1021
x  331
------
+ 1021
 3063
3063
------
337951

But, 431 and 1021 are not easy to multiply, with carries happening between the columns indicated:
   431
x 1021
------
+  431
  862
   0
431
------
440051
 ^^^

Also, 12 and 16 are not easy to multiply because a carry-over happens when multiplying 12 * 6 to get 72, even though no carries happen in the addition step.
  12
x 16
----
+ 72
 12
----
 192

Input: Two positive integers or their string representations. You may assume they will not overflow your language's integer type, nor will their product.
Output: One consistent value if they are easy to multiply, and another consistent value if not.
Test cases: The first 5 are easy to multiply, the last 5 are not.
331 1021
1021 331
101 99
333 11111
243 201

431 1021
12 16
3 4
3333 1111
310 13

[(331, 1021), (1021, 331), (101, 99), (333, 11111), (243, 201)]
[(431, 1021), (12, 16), (3, 4), (3333, 1111), (310, 13)]

Leaderboard:

var QUESTION_ID=151130,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/151130/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Can input for each number be a list of digits?

@dylnan No, though a list of characters is valid by default for the string option.

Jelly, 7 bytes
Dæc/>9Ẹ

Try it online!
Uses convolution (which I contributed to Jelly :D)
How it works
Dæc/>9Ẹ
D        converts to decimal list
 æc      convolution
    >9Ẹ  checks if any number is greater than 9

o wow convolution :D I think this is my first time seeing convolution used in a code-golf :D +1

@HyperNeutrino https://codegolf.stackexchange.com/search?q=matl

https://codegolf.stackexchange.com/questions/114495/topple-the-sandpile/114643#comment279190_114503

@LuisMendo No, that's a different convolution.

BTW You can replace the last 3 bytes with <⁵Ạ for output without a boolean NOT performed on it.

This could be made computationally faster by doing a FFT, element-wise multiplication, then a FFT afterwards.

@EriktheOutgolfer It's the same (the only?) definition of convolution, but in 2D

@Yakk Only for sufficiently large list. More complex algorithm has more overhead. / Leaky Nun : I thought there should be a U... Otherwise same algorithm as me.

Nice, æc/U = Uæc/! +1.

@user202729 Yes, in code golf, that is the primary problem with my suggestion.  ;)

JavaScript (ES6), 67 bytes
Takes input as 2 strings in currying syntax (a)(b). Returns false for easy or true for not easy.
a=>b=>[...a].some((x,i,a)=>[...b].some(y=>(a[-++i]=~~a[-i]+x*y)>9))

Test cases

let f =

a=>b=>[...a].some((x,i,a)=>[...b].some(y=>(a[-++i]=~~a[-i]+x*y)>9))

console.log('[Easy]')
console.log(f('331')('1021'))
console.log(f('1021')('331'))
console.log(f('101')('99'))
console.log(f('333')('11111'))
console.log(f('243')('201'))

console.log('[Not so easy]')
console.log(f('431')('1021'))
console.log(f('12')('16'))
console.log(f('3')('4'))
console.log(f('3333')('1111'))
console.log(f('310')('13'))

Alt. version (flawed), 64 55 52 bytes
Saved 3 bytes by taking strings, as suggested by @Shaggy
As pointed out by @LeakyNun, this method would fail on some large specific integers
Takes input as 2 strings in currying syntax (a)(b). Returns true for easy or false for not easy.
a=>b=>/^.(0.)*$/.test((g=n=>[...n].join`0`)(a)*g(b))

Test cases

let f =

a=>b=>/^.(0.)*$/.test((g=n=>[...n].join`0`)(a)*g(b))

console.log('[Easy]')
console.log(f('331')('1021'))
console.log(f('1021')('331'))
console.log(f('101')('99'))
console.log(f('333')('11111'))
console.log(f('243')('201'))

console.log('[Not so easy]')
console.log(f('431')('1021'))
console.log(f('12')('16'))
console.log(f('3')('4'))
console.log(f('3333')('1111'))
console.log(f('310')('13'))

How?
The idea here is to explicitly expose carries by inserting zeros before each digit of each factor.
Examples:

331 x 1021 becomes 30301 x 1000201, which gives 30307090501 instead of 337951. By adding a leading zero to the result and grouping all digits by 2, this can be written as 03 03 07 09 05 01. All groups are less than 10, meaning that there would not have been any carry in the standard multiplication.
431 x 1021 becomes 40301 x 1000201, which gives 40309100501 and can be written as 04 03 09 10 05 01. This time, we have a 10 which reveals a carry in the standard multiplication.

Can... Can we have a basic explanation on the algorithm?

@totallyhuman I've added an explanation. (Oops ... and also fixed a bug.)

Looks like you should be able to save 3 bytes by taking the inputs as strings.

It took me an eternity to find a (theoretical) counter-example which your algorithm will fail: https://tio.run/##y0rNyan8/9/l8LJk/f///xsbAAGYQGFgcLAK4BTEK0FQkigFRCsiSSFYsQ5pyqmqkLKAIS0y8EcwaqIwBgA (the 108 in the middle messes up your algorithm)

@LeakyNun Nice find. Yes, it can theoretically overflow.

@Arnauld are you going to edit it?

@LeakyNun Not sure if it can even be fixed. But I've added another version.

How does a[-++i]=~~a[-i]+x*y work? Wouldn't -++i be negative?

@Cowsquack Yes, we want it to be negative because we are re-using an existing array and don't want these values to collide with its original entries.

Alice, 30 bytes
/Q.\d3-&+k!*?-n/ o @
\ic/*2&w~

Try it online!
Outputs 1 for easy and 0 for hard.
The numbers are easy to multiply if and only if the digit sum of the product equals the product of the digit sums.
/i    Input both numbers as a single string
.     Duplicate this string
/*    Coerce into two integers and multiply
2&w   Push return address twice (do the following three times)
~\Q     Swap the top two stack entries, then reverse the stack
        This produces a 3-cycle, and the first iteration coerces
        the original input string into two integers
c       Convert into individual characters
\d3-&+  Add all numbers on the stack except the bottom two (i.e., add all digits)
k     Return to pushed address (end loop)
      At this point, all three numbers are replaced by their digit sums
!*?   Multiply the digit sums of the original two numbers
-     Subtract the digit sum of the product
n     Logical negate: convert to 1 or 0
/o@   Output as character and terminate

R, 135 110 109 86 bytes
function(m,n)any(convolve(m%/%10^(nchar(m):1-1)%%10,n%/%10^(1:nchar(n)-1)%%10,,"o")>9)

Try it online!
Takes input as strings.
It's ugly but it works™.
This now uses a convolution approach, as in Leaky Nun's answer, so it takes input as integers, and returns TRUE for hard to multiply numbers and FALSE for easy to multiply ones.
I have always had some trouble porting convolution approaches in the past, but today I finally read the documentation:

Note that the usual definition of convolution of two sequences x and y is given by convolve(x, rev(y), type = "o")

Which is just silly. So the digit extraction is reversed for n, and it resolves into a port of Leaky Nun's answer.

MATL, 10 bytes
,j!U]Y+9>a

Outputs 0 for easy, 1 for hard.
Try it online! Or verify all test cases.
Explanation
,       % Do twice
  j     %   Input as a string
  !     %   Transpose into a column vector of characters
  U     %   Convert each character to number. Gives a numeric column vector
]       % End
Y+      % Convolution, full size
9>      % Greatear than 1? Element-wise
a       % Any: true if there is some true entry. Implicitly display

Python 2, 88 bytes
lambda n,m:any(sum(n/10**(k-j)%10*(m/10**j%10)for j in range(k+1))>9for k in range(n+m))

Takes two integers as input and returns False (easy to multiply) or True (not).
Try it online! (too slow for one of the test cases)

Quick maffs version

len(`n+m`) would actually fail for 40, 30.

len(`n+m`)+1?

That fails for 400, 300. len(`n`+`m`) should do though.

JavaScript (Node.js), 43 41 37 36 bytes
Thanks @Dennis  for the idea of using string interpolation in this answer and save 4 bytes!
Thanks @ØrjanJohansen for -1!
a=>b=>eval(`0x${a}*0x${b}<0x${a*b}`)

Try it online!
Of course when the destination base is less than the original base (like in my Jelly answer, the base is 2) the < must be flipped.

Congrats on being the first to figure out to use base conversion, for which I give you the bounty!

Python 2, 158 135 123 113 bytes
-12 bytes thanks to Leaky Nun
-10 bytes thanks to ovs

a,b=input()
e=enumerate
l=[0,0]*len(a+b)
for i,x in e(a):
 for j,y in e(b):l[i-~j]+=int(x)*int(y)
print max(l)<10

Try it online! or Try all test cases

Doesn't all(d[k]<10for k in d) work or is it just Python 3?

@shooqie yes, it does, but now it's a list c:

129 bytes

Wolfram Language (Mathematica), 75 66 65 56 bytes
f:=#~FromDigits~x&
g:=Max@CoefficientList[f@#2f@#,x]<=9&

Try it online!
Receiving 2 string inputs
Explanation:
f:=#~FromDigits~x&                      (* Turns the number to a polynomial
                                           with the digits as coefficients      *)
g:=Max@CoefficientList[f@#2f@#,x]<=9&   (* Polynomial multiplication, and check
                                           whether all coefficients are smaller
                                           than 10                              *)

-9 for changing to use string as input
-1 for using infix operator
-9 Thanks @MartinEnder for the Max function

Julia 0.6, 30 bytes
~x=any(conv(digits.(x)...).>9)

Try it online!
Input is a tuple of numbers, output is true for hard to multiply numbers and false for easy ones.
. is element-wise function application.
... expands the tuple (of lists of integer digits) to two seperate inputs of the conv function.

SNOBOL4 (CSNOBOL4), 268 264 247 246 243 131 bytes
	DEFINE('D(A)')
	M =INPUT
	N =INPUT
	OUTPUT =EQ(D(M) * D(N),D(M * N)) 1	:(END)
D	A LEN(1) . X REM . A	:F(RETURN)
	D =D + X	:(D)
END

Try it online!
Ports the approach by Nitrodon. I think this is the first time I've ever defined a function in SNOBOL, D for digit sum.
	DEFINE('D(A)')					;* function definition
	M =INPUT					;* read input
	N =INPUT					;* read input
	OUTPUT =EQ(D(M) * D(N),D(M * N)) 1	:(END)	;* if D(M)*D(N)==D(M*N),
							;* print 1 else print nothing. Goto End
D	A LEN(1) . X REM . A	:F(RETURN)		;* function body
	D =D + X	:(D)				;* add X to D
END

old version, 243 bytes:
	M =INPUT
	N =INPUT
	P =SIZE(M)
	Q =SIZE(N)
	G =ARRAY(P + Q)
Z	OUTPUT =LE(P)	:S(E)
	M LEN(P) LEN(1) . A
	J =Q
Y	GT(J)	:F(D)
	N LEN(J) LEN(1) . B
	W =I + J
	X =G<W> + A * B
	G<W> =LE(A * B,9) LE(X,9) X	:F(E)
	J =J - 1	:(Y)
D	P =P - 1	:(Z)
E
END

Try it online!
Input on STDIN separated by newlines, output to STDOUT: a single newline for easy to multiply, and no output for not easy to multiply.
This isn't going to win any awards but it presents another approach (well, really this is the naive approach). I don't think I could write this up in cubix, but SNOBOL is tough enough to work with as it is.
Since it takes input as a string, this will work for any input with less than 512 digits each; I'm not 100% sure how big ARRAYs in SNOBOL can be.
INPUT is buffered in this version of SNOBOL to have a maximum width of 1024 characters; all other characters are then lost. It appears that an ARRAY can be quite large; well over the 2048 cells necessary.
	M =INPUT				;*read input
	N =INPUT				;*read input
	P =SIZE(M)				;*P = number of M's digits, also iteration counter for outer loop
	Q =SIZE(N)				;*Q = number of N's digits
	G =ARRAY(P + Q)				;*G is an empty array of length P + Q
Z	GE(P)	:F(T)				;*if P<0, goto T (outer loop condition)
	M LEN(P) LEN(1) . A			;*A = P'th character of M
	J =Q					;*J is the iteration counter for inner loop
Y	GT(J)	:F(D)				;*if J<=0, goto D (inner loop condition)
	N LEN(J) LEN(1) . B			;*B = J'th character of N
	W =I + J				;*W=I+J, column number in multiplication
	X =G<W> + A * B				;*X=G[W]+A*B, temp variable for golfing
	G<W> =LE(A * B,9) LE(X,9) X	:F(END)	;*if A*B<=9 and X<=9, G[W]=X otherwise terminate with no output
	J =J - 1	:(Y)			;*decrement J, goto Y
D	P =P - 1	:(Z)			;*decrement P, goto Z
T	OUTPUT =				;*set output to ''; OUTPUT automatically prints a newline.
END

Python 3, 58 3513 40 39 bytes
lambda n,m:eval(f'0x{n}*0x{m}<0x{n*m}')

Looks like I had this idea two hours too late.
Thanks to @ØrjanJohansen for golfing off 1 byte!
Try it online!

Charcoal, 38 bytes
≔Ｅ⁺θη⁰ζＦＬθＦＬη§≔ζ⁺ικ⁺§ζ⁺ικ×Ｉ§θιＩ§ηκ‹⌈ζχ

Try it online! Link is to verbose version of code. Outputs a - when the numbers are easy to multiply. Explanation:
≔Ｅ⁺θη⁰ζ

Initialise z to a large enough (sum of lengths of inputs) array of zeros.
ＦＬθＦＬη

Loop over the indices of the inputs q and h.
§≔ζ⁺ικ⁺§ζ⁺ικ×Ｉ§θιＩ§ηκ

Perform one step of the long multiplication.
‹⌈ζχ

Check for carries.

Pari/GP, 52 bytes
f(a,b)=vecmax(Vec(Pol(digits(a))*Pol(digits(b))))<10

Try it online!

Haskell, 82 81 bytes
q=map$read.pure
f a=any(>9).concat.scanr((.(0:)).zipWith(+).(<$>q a).(*))(0<$a).q

The numbers a taken as strings. Returns False if the numbers are easy to multiply and True otherwise.
Try it online!
I think it's different enough from @Laikoni's answer. How it works:
q                    -- helper function to turn a string into a list of digits

f a =                -- main function, first number is parameter 'a'
      scanr    .q    -- fold the following function from the right (and collect
                     -- the intermediate results in a list) into the list of
                     -- digits of the second number
            0<$a     --   starting with as many 0s as there are digits in 'a'
                     -- the function is, translated to non-point free:
  \n c->zipWith(+)((*n)<$>q a)$0:c
                     -- 'n': next digit of 'b'; 'c': value so far
        (*n)<$>a     --    multiplay each digit in 'a' with 'n'
        0:c          --    prepend a 0 to 'c'
        zipWith(+)   --    add both lists element wise
                     --    (this shifts out the last digit of 'c' in every step)
   concat            -- flatten the collected lists into a single list
 any(>9)             -- check if any number is >9

Nice solution! I was looking for ways to get rid of the import, but they ended up even longer.

Haskell, 45 44 bytes
Edit:

-1 byte changing == to <.

I thought of this before looking at the other answers, then discovered that the Alice one used the same basic idea. Posting anyway since it's shorter than the other Haskell answers.
? takes two integers and returns a Bool. Use as 331?1021. False means the multiplication is easy.
a?b=s(a*b)<s a*s b
s=sum.map(read.pure).show

Try it online!

s is a function that calculates the sum of the digits of an integer. (read.pure converts a single digit character to an integer.)
If a pair of numbers is easy to multiply, the digit sum of the product is equal to the product of the digit sums.
Conversely, any carry during the long multiplication will reduce the digit sum of the product from that ideal.

Ruby, 69 bytes
->a,b{(0..a+b=~/$/).all?{|r|(0..r).sum{|w|a[w].to_i*b[r-w].to_i}<10}}

Try it online!

Perl 5, 100 + 2 (-F) = 102 bytes
push@a,[reverse@F]}{map{for$j(@{$a[0]}){$b[$i++].='+'.$_*$j}$i=++$c}@{$a[1]};map$\||=9>eval,@b;say$\

Try it online!
outputs false for easy, true for not easy.

Haskell, 123 bytes
import Data.List
r=read.pure
a%b|l<-transpose[reverse$map((*r d).r)b++(0<$e)|d:e<-scanr(:)""a]=all(<10)$concat l++map sum l

Try it online! Example usage: "331" % "1021" yields True.

Jelly, 8 bytes
;PDḄµṪ⁼P

Try it online!
A port of my Javascript answer. Not shorter than the existing Jelly answer because Jelly have powerful convolution built-in.
Take input as a list of two numbers. Returns 1 for easy, 0 for not easy.

Explanation:

;PDḄµṪ⁼P     Main link. Let input = [101, 99]
;P           Concatenate with product. Get [101, 99, 9999]
  D          Convert to decimal. Get [[1,0,1], [9,9], [9,9,9,9]]
   Ḅ         Convert from binary. Get [1 * 2^2 + 0 * 2^1 + 1 * 2^0,
             9 * 2^1 + 9 * 2^0, 9 * 2^3 + 9 * 2^2 + 9 * 2^1 + 9 * 2^0]
             = [5, 27, 135]
    µ        With that value,
     Ṫ       Take the tail from that value. Get 135, have [5, 27] remain.
      ⁼      Check equality with...
       P       The product of the remaining numbers (5 and 17).

C (gcc), 104 bytes
Basically do a multiplication "by hand" into r[] and set return value if any column gets higher than 9, since that would mean a carry has occurred.
Surprisingly, this was shorter than my first attempt which took strings as arguments.
f(a,b){int*q,r[10]={0},*p=r,R=0,B;for(;a;a/=10)for(q=p++,B=b;B;B/=10)R|=(*q+++=a%10*(B%10))>9;return R;}

Try it online!

Husk, 10 bytes
§§=¤`o*oΣd

Try it online! Outputs 1 if the arguments are easy to multiply, and 0 otherwise. A port of Nitrodon's answer.

CJam, 18 bytes
{_{Ab:+}:T/*\:*T=}

Try it online!
Takes input on the stack in the form of [1021 331]. Checks that the product of the sum of the digits and the sum of the digits of the product are equal.
To take input as a space-delimited string, remove the outer curly braces and prepend with q~].
Alternate 18-byter
{{'0*i}/*`);-2%i!}

Try it online!
Takes input on the stack in the form of ["1021" "331"]. A port of Arnauld's fantastic answer.
To take input as a space-delimited string, remove the outer curly braces and prepend with qS/.

source: Stack Exchange

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

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

sort: votes


text:
Decomposing into primes
Given an integer n, return the number of ways that n can be written as a list of prime numbers. For example, 2323 can be written as (2,3,23), (23,23) or (2,3,2,3) or (23,2,3), so you would output 4. If it can not be written in this way, you should output 0.
A prime number such as 019 or 00000037 is a valid prime for this problem.
Test cases:
5 -> 1
55 -> 1
3593 -> 4 (359 and 3, or 3 and 593, or 3 and 59 and 3, or 3593)
3079 -> 2 (3 and 079, or 3079)
119 -> 0
5730000037 -> 7 (5,7,3,000003,7, 5,7,3,0000037, 5,73,000003,7, 5,73,0000037, 5,73000003,7, 5,7,30000037, 5730000037)
0-> undefined (you do not have to handle this case)

This is code-golf, so the shortest answer in bytes in each language wins!
Edit: now I know why I should use the sandbox next time

Related

Haskell, 96 89 bytes
5 bytes saved thanks to H.PWiz's primality test
p x=[1|0<-mod x<$>[2..x]]==[1]
f[]=1
f b=sum[f$drop i b|i<-[1..length b],p$read$take i b]

Try it online!
Explanation
The first thing that's done is creating a prime test function using Wilson's theorem using the definition of prime.
p x=[1|0<-mod x<$>[2..x]]==[1]

Then begin defining f.  The first thing I thought when I saw this problem was to use dynamic programming.  However dynamic programming costs bytes so this uses a "psuedo-dynamic programming" algorithm.  Whereas in dynamic programming you would store a Directed Acyclic graph in memory here we just use recursion and recalculate each node every time we need it.  It loses all of the time benefits of dynamic programming, but this is code-golf so who cares. (still better than brute force search though)
The algorithm is as follows, we construct a Directed Acyclic Graph, L, where each node represents a substring of the number.  In particular Li represents the last i digits of our input (lets call it n).
We define L0 to have a value of 1 and each other value in L to have the sum of each Lj such that j < i and the substring of n from i to j is prime.
Or in a formula:

We then return the value at the largest largest index of L. (Lk where k is the number of digits of n)

Jelly, 8 bytes
ŒṖḌÆPẠ€S

Try it online!
-1 byte thanks to Leaky Nun
-1 byte thanks to Dennis
Explanation
ŒṖḌÆPẠ€S  Main Link
ŒṖ        List Partitions (automatically converts number to decimal digits)
  Ḍ       Convert back to integers (auto-vectorization)
   ÆP     Are they primes? (auto-vectorization)
     Ạ€   For each, are they all truthy (were the numbers all primes?); 1/0 for truthy/falsy
       S  Sum; gets number of truthy elements

I've noticed that 05AB1E can't do this easily. Partitions seems like a great command.

Brachylog, 10 bytes
ṫ{~cịᵐṗᵐ}ᶜ

Try it online!
First ṫ converts the input into a string. {…}ᶜ Counts the number of possible outputs for ….
Inside {…} the output of ṫ is fed to ~c. The output of this predicate satisfies that, when concatenated, it is equal to the input. This is fed into ịᵐ, which specifies that its output is it's input with each string converted into an integer. ṗᵐ specifies that its input consists of primes

You don't need to convert to string and back, those 7 bytes are enough: {~cṗᵐ}ᶜ. This is really slow because ~c on integers works with constraint arithmetic, but in theory it works.

@Fatalize I think that fails to account for leading zeros

Pyth, 13 bytes
lf.AmP_sdT./`

Test suite.

I don't know Pyth that well but instead of filtering and then taking the length, could you do for_each instead of filter and then sum?

@HyperNeutrino does that make any difference?

I'm not sure, I haven't tested. It does for Jelly (probably because of the two-byte filter quick) but I'm not sure.

@HyperNeutrino filter is one byte here...

Python 2, 105 95 91 bytes
f=lambda n:sum(0**k|f(n%10**k)for k in range(n)if sum(n/10**k%j<1for j in range(1,n+2))==2)

This is very slow.
Try it online!

Python 2, 161 bytes
lambda n:sum(all(d>1and all(d%i>0for i in range(2,d))for d in v)for v in g(`n`))
g=lambda s:[[int(s[:i])]+t for i in range(1,len(s))for t in g(s[i:])]+[[int(s)]]

Try it online!
The function g creates the partitions recursively (it takes a string as input but outputs a list of lists of ints). Most of the remaining code is just to implement 'is d a prime?'.

Gaia, 12 bytes
₸B¦ṗ¦Π
$ḍ↑¦Σ

Try it online!

Clean, 199 141 131 bytes
import StdEnv
?n|n<2=0|and[gcd n i<2\\i<-[2..n-1]]=1=0
@n#s=toString n
#f=toInt o(%)s
= ?n+sum[@(f(0,i))\\i<-[0..n]| ?(f(i+1,n))>0]

Try it online!

J, 65 64 bytes
(1#.[:*/"1*/@>)@(#`(1,.[:#:[:i.2^#-1:)@.(1<#)(1:p:&.>".);.1])@":

Try it online!

Pyth, 12 bytes
lf*FmP_sdT./

Takes input as an integer, outputs True or False
Try it online!

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


text:
XKCD Calendar Facts
Inspiration. Posted with permission.
Print one of the possible XKCD calendar "facts":

You can get the raw text and structure from my APL reference implementation or from Explain XKCD's transcript (including the title text just under the illustration).
Rules
At every decision node, there must be an equal (pseudo-)random chance of each choice.
You may use all uppercase.
You must generate three sentences; a question, a reason, and a title text.
The three sentences should be ended by ?, ., and . respectively, and separated from each other by a single space.
The only extra white-space you may include is one trailing space and/or line break.
Examples
Did you know that the Latest Sunset drifts out of sync with the Zodiac because of time zone legislation in Indiana? Apparently it's getting worse and no one knows why. While it may seem like trivia, it has to be corrected for by GPS satellites.
Did you know that Leap Year happens later every year because of precession of the equator? Apparently scientists are really worried. While it may seem like trivia, it is taken advantage of by high-speed traders.
Did you know that Easter drifts out of sync with the atomic clock in Colorado because of a decree by the pope in the 1500s? Apparently scientists are really worried. While it may seem like trivia, it causes huge headaches for software developers.

@Rod I never said anything about the chart. I said to get the text from my reference implementation (which includes it) or from Explain XKCD (with a note to include the title text).

Are leading spaces in the output allowed?

@EriktheOutgolfer No.

Related

Did you know that shark week happens at the wrong time every year because of an arbitrary decision by Benjamin Franklin? Apparently it causes a predictable increase in car accidents. I... I mean... I... Okay.

Is there a time constraint on how long the program can take to finish running?

@Οurous Not really. Are you intending very long, like after the heat death of the universe?

@Adám No, just a few weeks worst-case. A few hours for most random seeds.

My CTO made this neat representation.

Befunge-93, 1959 1930 bytes
"#~$}%|&{'zwy#x$-#w$v%u&tTs*-#r$q%p&oTn0m1l2kpj#-#i$h%gFf(e)-#d#c$bC-'a(`)_*E+"v
v"#*_?F@%A$B#C3DYE,F+G*-TH&I%J$K#L$M#-'NCO$P#Q#RjSFT%U$V#-<W;-cX(Y'Z&[%\$]#^cF"<
>">$=%<#;$:%9F$*8+-#7$6C5/4#3$-C23-#1$0C*#/$.C$:-#,$+C*#)$(C$A'#&$%C$J#"75*-0\:v
$::"P"vv-*84:-*57$$_1-\1+::"P"%\v>+>\1-:v>-#1:#$>#\_:$#<$:#v_".",@v/"P"\%"P"::\_
>\#%4#<3g/7+g"!"-:!^!:\,g+7/"P"<<^1?<*2\_$\%1++64*g48*-^<<<>75*-0v>7+g84*-+\1-:^
#<<<*2\>#$$:0\`#$_\$55++:64*g48*-90^https://xkcd.com/1930/^<<<<<<>#\\:#< >#<>#<^

3Did you know that %the %fall'spring) equinox'winter'summer" )solstice)Olympics!
)earliest'latest(sunrise'sunset0daylight saving"s& time&leap $day%year'Easter(ha
rvest&super&blood& moon3Toyota Truck Month+Shark Week)happens (earlier&later2at
the wrong time, every year=drifts out of sync with the $sun%moon'zodiac*Gregoria
n&Mayan&lunar'iPhone* calendar9atomic clock in Colorado'might +not happen-happen
 twice+ this year- because of :time zone legislation in (Indiana(Arizona'RussiaB
a decree by the Pope in the 1500s+precession*libration)nutation)libation-eccentr
icity*obliquity) of the -earth's axis(equator/Prime Meridian3International Date,
Mason-Dixon& Line8magnetic field reversal:an arbitrary decision by 2Benjamin Fra
nklin-Isaac Newton$FDR.? Apparently Rit causes a predictable increase in car acc
idents@that's why we have leap seconds>scientists are really worriedEit was even
 more extreme during the +Bronze Age(Ice Age+Cretacious&1990sFthere's a proposal
 to fix it, but it 2will never happen;actually make things worse7is stalled in C
ongress:might be unconstitutionalHit's getting worse and no one knows whyE. Whil
e it may seem like trivia, it Ncauses huge headaches for software developersLis
taken advantage of by high-speed tradersFtriggered the 2003 Northeast BlackoutJh
as to be corrected for by GPS satellitesRis now recognized as a major cause of W
orld War I" "# "$) (6DLTV`b$ "$&% "$&2# *B& "$&(*% *,PR& "$&2>% "$&(

Try it online!
Explanation
In the first three lines, we start by building up a kind of state table on the stack, representing the graph of all possible sentences. These stack entries are grouped into pairs, so there is first a string item, and then a jump or branch. Where necessary, the graph is padded with empty strings and zero-length jumps in order to meet this requirement.
Our main loop then begins by popping a number, representing a string item, off the stack. This number is interpreted as an offset into the string table in the lower section of the source. The string table is essentially a kind of linked list, wrapped over multiple lines to fit into Befunge's constrained memory space.
After outputting a string, the next item on the stack is either a jump or branch. If the number is less than 32, it's a jump, which we interpret by dropping that many pairs of items from the stack. If the number is 32 or more, it's a branch, and we use the value (minus 32) to lookup the branch details from the table on the last line of the source.
The entries in the branch table each consist of a count, followed by a list of offsets. Once we know which branch to use, we simply generate a random number, modulo the branch count, to lookup the appropriate offset. This offset is then interpreted as a jump, dropping the required number of items from the stack.
We repeat this process, outputting a string, then performing a jump or branch, until we run out of stack entries. At that point, we simply output a "." to mark the end of the final sentence, and then exit.

What is the URL doing in there?

@Adám I had a bit of space in the middle of the line and thought it would be a neat way to credit the original comic. The byte count also kind of references the comic, but that was entirely coincidental.

This is surprisingly fast...

Javascript (ES6), 1698 1510 1506 1501 bytes
Thanks to 12Me21 for fixing a bug in the code, which added 2 bytes
f= and document.write(f()) are not part of the byte count

f=_=>eval(`"Did you know that {the {Fall;Spring} Equinox;the {Wint;Summ}er {Solstice;Olympics};the {Earli;Lat}est Sun{rise;set};Daylight Saving{;s} Time;Leap {Day;Year};Easter;the {Harvest;Super;Blood} Moon;Toyota Truck Month;Shark Week} {happens {earlier;later;at the wrong time} every year;drifts out of sync with the {Sun;Moon;Zodiac;{Gregorian;Mayan;Lunar;iPhone} Calendar;atomic clock in Colorado};might {not happen;happen twice} this year} because of {time zone legislation in {Indian;Arizon;Russi}a;a decree by the pope in the 1500s;{{precession;eccentricity;obliquity};{lib;liber;nut}ation} of the {Moon;Sun;Earth's axis;equator;prime meridian;{international date;mason-dixon} line};magnetic field reversal;an arbitrary decision by {Benjamin Franklin;Isaac Newton;FDR}}? Apparently {it causes a predictable increase in car accidents;that's why we have leap seconds;scientists are really worried;it was even more extreme during the {{Bronz;Ic}e Age;{Cretaceou;1990}s};there's a proposal to fix it, but it {will never happen;actually makes things worse;is stalled in congress;might be unconstitutional};it's getting worse and no one knows why}. While it may seem like trivia, it {causes huge headaches for software developers;is taken advantage of by high-speed traders;triggered the 2003 Northeast Blackout;has to be corrected for by GPS satellites;is now recognized as a major cause of World War I}."`.split`{`.join`"+(a=>a[Math.random()*a.length|0])(["`.split`}`.join`"])+"`.split`;`.join`","`)
document.write(f())

Python 2, 1297 bytes
-419 bytes thanks to ovs.
exec'eJxNVcGO3DYMvecriLk4m2yCSYseUqAomgYpcgkW7WHPtMSxmZElR5Jnxvv1fZQns3sybZHi4+MjfchposzR46HTnHJ988r9EXjqPb/h392Y1Mlrvns1Z421+6ye1rTQMaYz1ZErdW/d666OshkHDqG774p5D93d247kx6IxXfDx5nTGTZLNbZkmGObWDkoKpSIfjlJYp1ld6e5eBArnoFIqzgNXM55Dl5i1SLs0FqkW53kNOoyVCp8MjvmZQ4uqOpl3EJ63G+CN9xU5LFa4bBhvyUfOpy13WeZ21IeUfLtsSimab1pTZap5cUd8i3U0bwQe6SxyfEY78jxLLC+rytei7AlaLe05pzhsQBuTJ8krNYCoLeuhFkpLpXSgskZHZ60j3eCCBrhdgT0lr+y6e3wfsgwpK7dTXtszLLFdqg9jilsyx0Gi5w1NmtSRCwlVaSSXQsrsk9E0NX5bwpgqbXUhZjOonq2bje5Ry4bd3npxvBQx6Jt+UCM9ITcFGbSAB03RcrVTjUAf2aBkhZdZeSlF2SAweXFZhPq1Vf+QZrFQsz/8tt+XVvacxQlCGh1B+5YBZlzqT/PFV3FOYs3qtJooUh8UMoZt4AH6xvKV30b2DtWh44X4omWHS34soM4YxDSgPkhdfSO+1YRWx5aPA3k0vvWjpPjO6wWXWqag1g37PkTBYNBBJXjKpoTCNmgciXOvNTOkAR7UKjQmGrpPEr/zBC6+YMKPuA0RXwuzo29yrg35l8//dnfI9Sf9Nc+cUXW4Bmul1iTUQ2DPq6vcB6MWbHNpHDvOxM6pRxx43tlGAAHncYXgoYaTNRQDVsSl6I2U4hS+WqBdZEMpWBhwTjmreJNgpTMX03rEBMFDLjUL2POLrZRn5nsMx5MQD0YcVHa1gK2y07QATvfh48e9bRDgkizdVkmaE7ijmsDmhbTeU48hQt7dtptCoGgEP4uZXV0azImPYkqOQzHIbd1A1qXiVLwR8jcmNkNn3c/R6IWWiOKx1+qyddsAqdE0SK1WU7uKsIMpJrIhsO3aWNyhM+/pcVTjvSL/CiplgjAMSNaT8r0dNEau3RqXAdQLe3YjXg8pU0mHeja6PQoLmI9cNuQVBUFB/sSxgj+TNrQzAvm7MgtKgrD85o1swwAWfWvBL/v9r/QNf4vRFiV9CuyO2EVt8otxi7odmiquIsIw4N5/Hv7DKq4SgmJ5bwjsPwKvNER9gidbjyb+joDbhnhMGaJ/hNS+2lS87/4H4KM8AA=='.decode('base64').decode('zip')

Try it online!
The actual code:
from random import*
c=lambda*a:choice(a)
print'Did you know that '+c('the '+c('fall','spring')+' equinox','the '+c('winter','summer')+' '+c('solstice','olympics'),'the '+c('earliest','latest')+' '+c('sunrise','sunset'),'daylight saving'+c('','s')+' time','leap '+c('day','year'),'easter','the '+c('harvest','super','blood')+' moon','toyota truck month','shark week')+' '+c('happens '+c('earlier','later','at the wrong time')+' every year','drifts out of sync with the '+c('sun','moon','zodiac',c('gregorian','mayan','lunar','iPhone')+' calendar','atomic clock in colorado'),'might '+c('not happen','happen twice')+' this year')+' because of '+c('time zone legislation in '+c('indiana','arizona','russia'),'a decree by the Pope in the 1500s',c('precession','libation','nutation','libation','eccentricity','obliquity')+' of the '+c('moon','sun',"earth's axis",'equator','prime meridian',c('international date','mason-dixon')+' line'),'magnetic field reversal','an arbitrary decision by '+c('Benjamin Franklin','Isaac Newton','FDR'))+'? Apparently '+c('it causes a predictable increase in car accidents',"that's why we have leap seconds",'scientists are really worried','it was even more extreme during the '+c('bronze age','ice age','cretacious','1990s'),"there's a proposal to fix it, but it "+c('will never happen','actually make things worse','is stalled in Congress','might be unconstitutional'),"it's getting worse and no one knows why")+'. While it may seem like trivia, it '+c('causes huge headaches for software developers','is taken advantage of by high-speed traders','triggered the 2003 Northeast Blackout','has to be corrected for by GPS satellites','is now recognized as a major cause of World War I')+'.'

That was tiring. I haven't even done basic golfing. Somebody please write a script to golf this.

I think this fails the spec of an equal pseudo-random chance at each decision node at the Gregorian/Mayan/Lunar/iPhone calendar node. You have a choice function for those four calendar types embedded within another choice. This means that "Gregorian calendar" will be a quarter as likely as "atomic clock in Colorado".

I think those are separate decision nodes. "Drifts out of sync with" connects to "Sun" "Moon" "Zodiac" "_ Calendar" and "Atomic clock in Colorado", and the choice between "Gregorian" "Mayan" "Lunar" and "iPhone" is only done if the "Calendar" branch is chosen.
EDIT: Also, the reference implementation has the same behavior.

Yes, each node splits even, no matter how many sub-nodes it has.

It looks like you've got 'libation' twice - one of them should be 'libration'. At least in the uncompressed code - not sure if the compressed version is the same.

R, 1903 1751 1743 bytes
A simple brute-force solution. Might be some way to golf it down some more.
p=paste
P=paste0
s=function(...)sample(c(...),1)
C='calendar'
T='the'
P(p('Did you know that',s(p(T,s('Fall','Spring'),'Equinox'),p(T,s('Winter','Summer'),s('Solstice','Olympics')),p(T,s('Earliest','Latest'),s('Sunrise','Sunset')),P('Daylight Saving',s('s',''),' Time'),p('Leap',s('Day','Year')),'Easter',p(T,s('Harvest','Super','Blood'),'Moon'),'Toyota Truck Month','Shark Week'),s(p('happens',s('earlier','later','at the wrong time'),'every year'),p('drifts out of sync with the',s('Sun','Moon','Zodiac',p('Gregorian',C),p('Mayan',C),p('Lunar',C),p('iPhone'),'atomic clock in Colorado')),p('might',s('not happen','happen twice'),'this year')),'because of',s(p('time zone legislation in',s('Indiana','Arizona','Russia')),'a decree by the pope in the 1500s',p(s('precession','libration','nutation','libation','eccentricity','obliquity'),'of the',s('Moon','Sun',"Earth's axis",'equator','prime meridian','international date line','mason-dixon line')),'magnetic field reversal',p('an arbitrary decision by',s('Benjamin Franklin','Isaac Newton','FDR')))),'? Apparently ',s('it causes a predictable increase in car accidents',"that's why we have leap seconds",'scientists are really worried',p('it was even more extreme during the',s('Bronze Age','Ice Age','Cretaceous','1990s')),p("there's a proposal to fix it, but it",s('will never happen','actually makes things worse','is stalled in congress','might be unconstitutional')),"it's getting worse and no one knows why"),'. While it may seem like trivia, it ',s('causes huge headaches for software developers','is taken advantage of by high-speed traders','triggered the 2003 Northeast Blackout','has to be corrected for by GPS satellites','is now recognized as a major cause of World War I'),'.')

Try it online!

Charcoal, 806 bytes
≔”}‽÷⌊＆β¶&⁰5EＹB∕¤ⅉ‖≧Ｉ2[y·↔m⁷b∕¶⎆w‹ta≔Þ…¤eN⌕⟦1H}⁷φb$≧xζ→j5⮌↗2Σ↶C$JiψT↧⊘ν；{Ｆκⅉ⊘Ｖ⁵)}LＺ)←‴Ｆ9cＣＩj+ＦＪ➙Ｎ¶℅Ｐφ⦄≧πΦjt/;⊗…→⎇↓y⁻OD¤ＨRw2◧eE≦⊗▶⁴Ｕμ4⁶⊟Ｐ}⁼Ruf→u≧″℅9ξ→Ｗ⊗7≧↨↥ω⎚,_-,*U∕$⊖τＪb4%Ｌ'⪪*⎇⊕>Þ↨ＩQ.＆ＸVSv⧴×↑Ｎ:εγC~f≔hI¶⊖⎇Ｎ6ydy"⁸？⁷∕Ｏυ⁻～Þ⁶πv″ZOgΦ✂⊘qＶ↓Ｙ5U,fν¶⁼⟲Ｙ⁺⪪“↓‹5Hψ.>⊕LＳ⁸◨›±3¤�[<⊟D´ＹυΣOR↓↓g⟧⎈″:;9≧¿×➙ρlZσ31‴8↖HＸυ3@⁺�@δIΣ≔⁺@ⅉＣＸ⎇",Ｈ²⁻↥uνu⎚⌊ÀＷ⊘∕Ｕ ψu]q➙⟲BoF⧴Ｑψ8)Ｚk⌕⊗ü；≡N±$⊞QＵ≕⁹↘NYFY?⊗↖\≦∧₂!Ｆd⌈B"η№⁻⎈Ｏ2jηＱμfÞωσdJ↧Àκ«ⅈ∕+¤êＥ�№Ｆ´⟲τ₂Ｇξr1⦃:>Oa²Ｏ[)¬X⎚∧Ｖ⊖«⪫Ｊ⁼0✂⦄Ｂlν≦&C₂？⁹κIＷÞ⁶≕>u/EKπd4ζ¤h]≕Ｄ@;ＶＷＲ$▷ω≔ＢU″″◧⁸|%↔φ；Φ?@R:↙!,⧴¹3Ｈ%⁸⧴↨⁵＆⁼E¶Ｎ Ｖ⬤⌊←}⁸⁺aw⌈Vς2A§A⟦Ｗ3«；{aZKl⊞Lξd⌊2≦2？⎈ＯＭ↔ü？⎚_Q▶δMp>{✂Mx§+↔⎆}Ｃκ·W∧Ｓd⎇⁹_ςCüI.Ｇ↓x≕χ«]n⦄&➙{‽ι⦃⁺^⦃Ｊk⎈O+oκs◧¿#W↙ＱＲ[Ｌα±´@⁰¶◧⊗βυ⊕⁴…«✳τi"TＷι＆=l¦⦄Þ⪪Þ▷‴υγ±A↥2⭆⁴≕↖≔…Ｌ¦ê⊘↥Ｂwψ¦⊘⊕*YkxAyg-'≦sΦd4◨υÀ？⁶[)…ＷS×∧ηt\e↗⊕Ｘκ≕№q₂‽Az←ＥＲT◨⟦◨<1↧Φ…⊗Ｅ›c*«Ｒ↥M6-±⌀↑F⟲#π'F5/±κ；↗～＆ζＴUI⁺U⦃⸿?^↙i⧴t”θＦβ≔⁺⁺§⪪θι⁰‽✂⪪θι¹±¹¦¹⊟⪪θιθθ

Try it online! Link is to verbose version of code. Explanation:
 ”....”                             Compressed string
≔      θ                            Assign to `q`
         β                          Lowercase letters
        Ｆ                           Loop over each letter
              ⪪θι   ⪪θι      ⪪θι    Split `q` at that letter
             §   ⁰                  First string in split (i.e. prefix)
                   ✂   ¹±¹¦¹        Slice split excluding prefix and suffix
                  ‽                 Select random element
                            ⊟       Pop last string (i.e. suffix)
           ⁺⁺                       Concatenate
          ≔                     θ   Assign to `q`
                                 θ  Print `q`

JavaScript (ES6), 1275 bytes
f=(s=btoa`...`)=>/h/.test(s)?f(s.replace(/g([^gi]+)i/,(_,x)=>` ${(x=x.split`h`)[Math.random()*x.length|0]} `)):s.replace(/[a-f]/g,x=>" '-?,."['0x'+x-10]).replace(/ +(\W)/g,'$1')

where the ... represents the result of running atob() on this string and replacing \ with \\, ` with \`, 0x00 with \0, and 0x0D with \r:
DIDaYOUaKNOWaTHATgTHEgFALLhSPRINGiEQUINOXhTHEgWINTERhSUMMERigSOLSTICEhOLYMPICSihTHEgEARLIESThLATESTigSUNRISEhSUNSETihTHEgHARVESThSUPERhBLOODiMOONhDAYLIGHTgSAVINGhSAVINGSiTIMEhLEAPgDAYhYEARihEASTERhTOYOTAaTRUCKaMONTHhSHARKaWEEKigHAPPENSgEARLIERhLATERhATaTHEaWRONGaTIMEiEVERYaYEARhDRIFTSaOUTaOFaSYNCaWITHaTHEgSUNhMOONhZODIAChgGREGORIANhMAYANhLUNARhIPHONEiCALENDARhATOMICaCLOCKaINaCOLORADOihMIGHTgNOTaHAPPENhHAPPENaTWICEiTHISaYEARiBECAUSEaOFgTIMEaZONEaLEGISLATIONaINgINDIANAhARIZONAhRUSSIAihAaDECREEaBYaTHEaPOPEaINaTHEa1500ShgPRECESSIONhLIBRATIONhNUTATIONhLIBRATIONhECCENTRICITYhOBLIQUITYiOFaTHEgSUNhMOONhEARTHbSaAXIShEQUATORhPRIMEaMERIDIANhINTERNATIONALaDATEaLINEhMASONcDIXONaLINEihMAGNETICaFIELDaREVERSALhANaARBITRARYaDECISIONaBYgBENJAMINaFRANKLINhISSACaNEWTONhFDRiidaAPPARENTLYgITaCAUSESaAaPREDICTABLEaINCREASEaINaCARaACCIDENTShTHATbSaWHYaWEaHAVEaLEAPaSECONDShSCIENTISTSaAREaREALLYaWORRIEDhITaWASaEVENaMOREaEXTREMEaDURINGaTHEgBRONZEaAGEhICEaAGEhCRETACEOUSh1990SihTHEREbSaAaPROPOSALaTOaFIXaITeaBUTaITgWILLaNEVERaHAPPENhACTUALLYaMAKESaTHINGSaWORSEhISaSTALLEDaINaCONGRESShMIGHTaBEaUNCONSTITUTIONALihITbSaGETTINGaWORSEaANDaNOaONEaKNOWSaWHYifaWHILEaITaMAYaSEEMaLIKEaTRIVIAeaITgCAUSESaHUGEaHEADACHESaFORaSOFTWAREaDEVELOPERShISaTAKENaADVANTAGEaOFaBYaHIGHcSPEEDaTRADERShTRIGGEREDaTHEa2003aNORTHEASTaBLACKOUThHASaTOaBEaCORRECTEDaFORaBYaGPSaSATELLITEShISaNOWaRECOGNIZEDaASaAaMAJORaCAUSEaOFaWORLDaWARaIif

Try it here, minus the btoa:

f=(s="DIDaYOUaKNOWaTHATgTHEgFALLhSPRINGiEQUINOXhTHEgWINTERhSUMMERigSOLSTICEhOLYMPICSihTHEgEARLIESThLATESTigSUNRISEhSUNSETihTHEgHARVESThSUPERhBLOODiMOONhDAYLIGHTgSAVINGhSAVINGSiTIMEhLEAPgDAYhYEARihEASTERhTOYOTAaTRUCKaMONTHhSHARKaWEEKigHAPPENSgEARLIERhLATERhATaTHEaWRONGaTIMEiEVERYaYEARhDRIFTSaOUTaOFaSYNCaWITHaTHEgSUNhMOONhZODIAChgGREGORIANhMAYANhLUNARhIPHONEiCALENDARhATOMICaCLOCKaINaCOLORADOihMIGHTgNOTaHAPPENhHAPPENaTWICEiTHISaYEARiBECAUSEaOFgTIMEaZONEaLEGISLATIONaINgINDIANAhARIZONAhRUSSIAihAaDECREEaBYaTHEaPOPEaINaTHEa1500ShgPRECESSIONhLIBRATIONhNUTATIONhLIBRATIONhECCENTRICITYhOBLIQUITYiOFaTHEgSUNhMOONhEARTHbSaAXIShEQUATORhPRIMEaMERIDIANhINTERNATIONALaDATEaLINEhMASONcDIXONaLINEihMAGNETICaFIELDaREVERSALhANaARBITRARYaDECISIONaBYgBENJAMINaFRANKLINhISSACaNEWTONhFDRiidaAPPARENTLYgITaCAUSESaAaPREDICTABLEaINCREASEaINaCARaACCIDENTShTHATbSaWHYaWEaHAVEaLEAPaSECONDShSCIENTISTSaAREaREALLYaWORRIEDhITaWASaEVENaMOREaEXTREMEaDURINGaTHEgBRONZEaAGEhICEaAGEhCRETACEOUSh1990SihTHEREbSaAaPROPOSALaTOaFIXaITeaBUTaITgWILLaNEVERaHAPPENhACTUALLYaMAKESaTHINGSaWORSEhISaSTALLEDaINaCONGRESShMIGHTaBEaUNCONSTITUTIONALihITbSaGETTINGaWORSEaANDaNOaONEaKNOWSaWHYifaWHILEaITaMAYaSEEMaLIKEaTRIVIAeaITgCAUSESaHUGEaHEADACHESaFORaSOFTWAREaDEVELOPERShISaTAKENaADVANTAGEaOFaBYaHIGHcSPEEDaTRADERShTRIGGEREDaTHEa2003aNORTHEASTaBLACKOUThHASaTOaBEaCORRECTEDaFORaBYaGPSaSATELLITEShISaNOWaRECOGNIZEDaASaAaMAJORaCAUSEaOFaWORLDaWARaIif")=>/h/.test(s)?f(s.replace(/g([^gi]+)i/,(_,x)=>` ${(x=x.split`h`)[Math.random()*x.length|0]} `)):s.replace(/[a-f]/g,x=>" '-?,."['0x'+x-10]).replace(/ +(\W)/g,'$1')
document.write(f())

Haskell, 1949 1938 bytes
import System.Random
data T a=N a[T a](T a)|P Char(T a)|E
l s=N s[]E
t=N"the"
w=map l.words
k=map l.lines
d=N""
g!a|(i,h)<-randomR(0,length a-1)g=(a!!i,h)
g#E=("",g)
g#(P c n)|(e,v)<-g#n=(c:e,v)
g#(N s[]n)|(e,v)<-g#n=([' '|s>""]++s++e,v)
g#(N s c n)|(p,q)<-g!c,(m,h)<-q#p,(e,v)<-h#n=([' '|s>""]++s++m++e,v)
tail.fst.(#N"Did you know that"[t(w"fall spring")$l"equinox",t(w"winter summer")$d(w"solstice olympics")E,t(w"earliest latest")$d(w"sunrise sunset")E,N"daylight"(w"saving savings")$l"time",N"leap"(w"day year")E,l"easter",t(w"harvest super blood")$l"moon",l"Toyota truck month",l"shark week"](d[N"happens"(k"earlier\nlater\nat the wrong time")$l"every year",N"drifts out of sync with the"[l"sun",l"moon",l"zodiac",d(w"gregorian mayan lunar iPhone")$l"calendar",l"atomic clock in Colorado"]E,N"might"(k"not happen\nhappen twice")$l"this year"]$N"because of"[N"time zone legislation in"(w"Indiana Arizona Russia")E,l"a decree by the Pope in the 1500s",d(w"precession libration nutation libation eccentricity obliquity")$N"of the"(k"moon\nsun\nEarth's axis\nequator\nprime meridian\ninternational date line\nMason-Dixon line")E,l"magnetic field reversal",N"an arbitrary decision by"(k"Benjamin Franklin\nIsaac Newton\nFDR")E]$P '?'$N"Apparently"[l"it causes a predictable increase in car accidents",l"that's why we have leap seconds",l"scientists are really worried",N"it was even more extreme during the"[l"bronze age",l"ice age",l"cretaceous",l"1990's"]E,N"there's a proposal to fix it, but it"(k"will never happen\nactually makes things worse\nis stalled in congress\nmight be unconstitutional")E,l"it's getting worse and no one knows why"]$P '.'$N"While it may seem like trivia, it"(k"causes huge headaches for software developers\nis taken advantage of by high-speed traders\ntriggered the 2003 Northeast Blackout\nhas to be corrected for by GPS satellites\nis now recognized as a major cause of World War I")$P '.'E))<$>newStdGen

Try it online! (Has an extra 2 bytes for f=)
Mostly wrote this just so I could create the data structure. This could definitely be improved but I'm tired and I have to leave soon anyway. I think capitalization is mostly right but I'll convert it all to caps if it's wrong. That won't change the byte count or anything since I haven't done anything weird with the string data.
Basic idea is a linked list of trees where each node is either empty (E), a punctuation mark (P) or a string label with children. All nodes except E nodes have a "follower" node that comes after them.
EDIT: just noticed a spelling mistake (I wrote "no one know why" instead of "no one knows why") so I had to add a byte to fix it but I also found some code that could be cut out

APL (Dyalog), 1302 bytes
'[a-z]'⎕R' \u&'⊢'⍠[^⍠⌸]*⌸'⎕R{(?∘≢⊃⊢)⍵.Match(∊⊆⊣)⎕AV}⍣≡'DIDyOUkNOWtHAT⍠tHE⍠fALL⌺sPRING⌸eQUINOX⌺tHE⍠wINTE⌺sUMME⌸R⍠sOLSTICE⌺oLYMPICS⌸⌺tHE⍠eARLI⌺lAT⌸ESTsUN⍠RISE⌺SET⌸⌺dAYLIGHTsAVING⍠ ⌺S ⌸TIME⌺lEAP⍠dAY⌺yEAR⌸⌺eASTER⌺tHE⍠hARVEST⌺sUPER⌺bLOOD⌸mOON⌺tOYOTAtRUCKmONTH⌺sHARKwEEK⌸⍠hAPPENS⍠eARLIER⌺lATER⌺aTtHEwRONGtIME⌸eVERYyEAR⌺dRIFTSoUToFsYNCwITHtHE⍠sUN⌺mOON⌺zODIAC⌺⍠gREGORIAN⌺mAYAN⌺lUNAR⌺iPHONE⌸cALENDAR⌺aTOMICcLOCKiNcOLORADO⌸⌺mIGHT⍠nOThAPPEN⌺hAPPENtWICE⌸tHISyEAR⌸bECAUSEoF⍠tIMEzONElEGISLATIONiN⍠iNDIAN⌺aRIZON⌺rUSSI⌸A⌺adECREEbYtHEpOPEiNtHE 1500S⌺⍠pRECESSION⌺lIBRATION⌺nUTATION⌺lIBATION⌺eCCENTRICITY⌺oBLIQUITY⌸oFtHE⍠mOON⌺sUN⌺eARTH''SaXIS⌺eQUATOR⌺pRIMEmERIDIAN⌺⍠iNTERNATIONALdATE⌺mASON-DIXON⌸lINE⌸⌺mAGNETICfIELDrEVERSAL⌺aNaRBITRARYdECISIONbY⍠bENJAMINfRANKLIN⌺iSAACnEWTON⌺fDR⌸⌸?aPPARENTLY⍠iTcAUSESapREDICTABLEiNCREASEiNcARaCCIDENTS⌺tHAT''SwHYwEhAVElEAPsECONDS⌺sCIENTISTSaRErEALLYwORRIED⌺iTwASmOREeXTREMEdURINGtHE ⍠BRONZEaGE⌺ICEaGE⌺CRETACEOUS⌺1990S⌸⌺tHERE''SapROPOSALtOfIXiT,bUTiT⍠wILLnEVERhAPPEN⌺aCTUALLYmAKEStHINGSwORSE⌺iSsTALLEDiNcONGRESS⌺mIGHTbEuNCONSTITUTIONAL⌸⌺iT''SgETTINGwORSEaNDnOoNEkNOWSwHY⌸.wHILEiTmAYsEEMlIKEtRIVIA,iT⍠cAUSEShUGEhEADACHESfORsOFTWAREdEVELOPERS⌺iStAKENaDVANTAGEoFbYhIGH-SPEEDtRADERS⌺tRIGGEREDtHE 2003nORTHEASTbLACKOUT⌺hAStObEcORRECTEDfORbYgPSsATELLITES⌺iSnOWrECOGNIZEDaSamAJORcAUSEoFwORLDwARi⌸.'

Try it online!
Adám helped with this one...then challenged me to finish it. :P
-11 thanks to Adám (using his new SBCS tool I can abuse the encoding without extra cost).

1289 using QuadR.

@Adám yeah I remember...

APL (Dyalog Unicode), 1593 bytes
C←?∘≢⊃⊢
S←C'|'∘≠⊆⊢
∊'Did you know that '(C('the '(S'Fall|Spring')' Equinox ')('the '(S'Winter |Summer ')(S'Solstice |Olympics '))('the '(S'Earliest |Latest ')(S'Sunrise |Sunset '))('Leap ',S'Day |Year ')'Easter '('the '(S'Harvest|Super|Blood')' Moon ')'Toyota Truck Month '('Daylight Savings Time '~C's∘')'Shark Week ')(C('happens '(S'earlier|later|at the wrong time')' every year ')('drifts out of sync with the '(S'Sun |Moon |Zodiac |atomic clock in Colorado|',' Calendar ',⍨S'Gregorian|Mayan|Lunar|iPhone'))('might '(S'not happen|happen twice')' this year '))'because of '(C('time zone legislation in ',S'Indiana|Arizona|Russia')'a decree by the pope in the 1500s'((S'precession|libration|nutation|libation|eccentricity|obliquity')' of the '(S'Moon|Sun|Earth''s axis|equator|prime meridian|',' line',⍨S'international date|mason-dixon'))'magnetic field reversal'('an arbitrary decision by ',S'Benjamin Franklin|Isaac Newton|FDR'))'? Apparently '(C'it causes a predictable increase in car accidents'('it was even more extreme during the ',S'Bronze Age|Ice Age|Cretaceous|1990s')'that''s why we have leap seconds'('there''s a proposal to fix it, but it ',S'will never happen|actually makes things worse|is stalled in congress|might be unconstitutional')'scientists are really worried' 'it''s getting worse and no one knows why')'. While it may seem like trivia, it '(S'causes huge headaches for software developers|is taken advantage of by high-speed traders|triggered the 2003 Northeast Blackout|has to be corrected for by GPS satellites|is now recognized as a major cause of World War I')'.'
Try it online!
Defines two helper functions and then uses them in one giant expression:
C← C (for Choose) is
?∘≢ a random number up to the number of elements in the argument
⊃ picks
⊢ from the arguments
S← S (for Split and Select) is
C choose among
'|'∘≠ the where-not-pipe
⊆ partitioned
⊢ argument
∊ ϵnlist (flatten)
C chooses from a list of strings and S chooses from the substrings of a | delimited string, and these are just used in combination to construct a "fact".


text:
Determine Superabundance
A superabundant number is an integer n that sets a new upper bound for its ratio with the divisor sum function σ. In other words, n is superabundant if and only if, for all positive integers x that are less than n:
$$\frac{\sigma(n)}n>\frac{\sigma(x)}x$$
For a few of the values:
n   σ(n)   σ(n)/n   superabundant
1   1      1.0000   yes
2   3      1.5000   yes
3   4      1.3333   no
4   7      1.7500   yes
5   6      1.2000   no
6   12     2.0000   yes
7   8      1.1429   no
8   15     1.8750   no
9   13     1.4444   no

A longer list of these (for test cases) can be found at OEIS A004394.
One highly recommended negative test case (if your interpreter can handle it) is 360360, because it ties with the last superabundant number.
Challenge
Your program should take in a single positive integer, and output a truthy or falsey value representing whether that integer is superabundant.
As this is code-golf, the shortest answer in bytes wins.

Jelly, 7 bytes
Æs÷$ÞṪ=

Try it online!
Jelly, 8 bytes
Æs÷$ÐṀ⁼W

Try it online!
Test Suite!
Explanation

Æs÷$ÐṀ⁼W ~ Full program (monadic).

    ÐṀ   ~ Keep the elements with maximal link value (auto-rangifies).
Æs       ~ Divisor sum.
  ÷$     ~ Divide by the current element.
      ⁼W ~ Check equality with the input wrapped into a singleton.
         ~ (for integers like 360360)

I think you can do Æs÷$ÐṀ= for 7 bytes. I didn't realize ÐṀ rangified, that is useful to know.

@dylnan No I can't. Although it cannot be tested online, it fails for 360360. In fact, this was my initial version

Why would it fail for 360360?

@dylnan 360360 is the first number it would fail for (I think), because it is the first number to tie a result which occurred before. (and our result would be [0, 1])

@Mr.Xcoder I see, thanks

Does jelly have a builtin for stable sorting?

@StephenLeppik Not sure what you are talking about. Example? >_>

@Mr.Xcoder you could sort the numbers from 1 to x by divisor sum ratio and check if x is the first element.

@StephenLeppik There's Þ, but that would definitely end up being longer AFAIK.

Stephen is close, but it turns out to still be 8 bytes: RÆs÷$ÞṪ= due to Þ not casting to range.

Haskell, 73 bytes
-1 byte thanks to Mr. Xcoder. -7 bytes thanks to Laikoni.
r=read.show
s n=sum[r i|i<-[1..n],n`mod`i<1]/r n
f n=all((s n>=).s)[1..n]

Try it online!
Haskell's type system isn't very golfy...

Haskell, 64 63 61 bytes
-1 byte thanks to Mr. Xcoder.
-2 bytes thanks to Lynn.
a!x=a*sum[y|y<-[1..x],mod x y<1]
f n=and[x!n>n!x|x<-[1..n-1]]

Try it online!

Octave, 41 bytes
@(n)([~,p]=max((x=1:n)*~mod(x,x')./x))==n

Try it online!
Explanation
@(n)                                       % Define anonymous function of n
                x=1:n                      % Range from 1 to n. Call that x
                        mod(x,x')          % n×n matrix of all pair-wise moduli
                       ~                   % Logical negate. True means it's a divisor
               (     )*                    % Matrix-multiply x times the above matrix
                                           % (gives the dot product of vector x times
                                           % each column of the matrix)
                                 ./x       % Divide each column by each entry in x
     [~,p]=max(                     )      % Index of first occurrence of maximum
    (                                )==n  % Does it equal n?

05AB1E, 10 bytes
LÑOā/ZQ¨_P

Try it online!
or as a Test suite
Explanation
L            # push range [1 ... input]
 Ñ           # divisors of each
  O          # sum of each
   ā/        # divide each by its 1-based index
     Z       # get max
      Q      # compare to each
       ¨     # remove the last element
        _    # logical negation
         P   # product

I think (though I ain't sure) this fails for 360360 (see the challenge for more details: One highly recommended negative test case is 360360, because it ties with the last superabundant number.).

@Mr.Xcoder: True. Fixed it, but there may be a better way to do this now.

Pyth, 14 bytes
(FryAmTheEggman saved 1 byte)
qh.Mcs*M{yPZZS

Try it here! or see more test cases.
Just my mandatory Pyth submission which is most likely golfable.
How?

qh.Mcs*M{yPZZS ~ Full program. Q = input.

             S ~ The integers in the range [1, Q].
  .M           ~ Get the elements with maximal function value.
    cs*M{yPZZ  ~ Key function: uses a variable Z.
         yPZ      ~ The powerset of the prime factors of Z.
        {         ~ Deduplicated.
      *M          ~ Product of each.
     s            ~ And summed.
    c       Z     ~ Divided by Z.
 h             ~ First element.
q              ~ Check equality with the input. Outputs either True or False.

Python 3, 77 bytes
-1 byte thanks to Rod. -3 bytes thanks to Dennis.
lambda n:max(range(1,n+1),key=lambda k:sum((k%i<1)/i for i in range(1,k)))==n

Try it online!

J, 35 bytes
Thanks to Mr.Xcoder for finding the problem and to cole for fixing it!
[:([:*/{:>}:)@(%~>:@#.~/.~&.q:)1+i.

Try it online!

This fails for 360360 (see the challenge for more details: One highly recommended negative test case is 360360, because it ties with the last superabundant number.).

Fixed for +3 bytes. Try it online. Working on golfing. I like the use of #.~ a lot (honestly the whole divisor sum function is really nice). What was wrong btw is that, though the thought of doing {:=>./ is clever, it doesn't satisfy the "greater than" part of the question.

Here's what I came up with to replace the sigma function, which is at the same length currently: (1#.{:(]*0=|~)])\ . Something's wrong with it though, maybe you have some thoughts?

@cole The credits for the sum of divisors function go to Roger Hui, in this essay .
I also started writing another sigma function but stopped after I reached 9 bytes and decided it won't be shorter than the one with the prime factorization.
Thanks for fixing the problem!

@cole The shortest other verb for sum of divisors I came up with is this: (1#.]*0=|~)1+i.
It's a hook and don't fit as easily into place though :)

Julia 0.6, 52 bytes
n->indmax(sum(x for x=1:m if m%x<1)//m for m=1:n)==n

Try it online!
This solution uses rational numbers to ensure correctness in case of equality.
(Testing 360360 took almost 10 minutes.)
Using floating point, 2 bytes can be saved with the left divide:
n->indmax(m\sum(x for x=1:m if m%x<1)for m=1:n)==n

Mathematica, 53 50 bytes
a=Tr@Divisors@#/#&;AllTrue[a@#-Array[a,#-1],#>0&]&

Pure function. Takes an integer as input and returns True or False as output.

Would something like Tr@Divisors@# works?

R using numbers, 59 bytes
f=function(n)which.max(sapply(1:n,numbers::Sigma)/(1:n))==n

Japt v2.0a0, 12 16 bytes
Sleep deprived brain can't seem to improve on this any further!
Returns 1 for truthy or 0 for falsey.
Æâ x÷U >Xâ x÷XÃ×

Try it
Sacrificed 4 bytes to handle 360360.

Explanation

Implicit input of integer U.
Æ Ã creates an array of integers from 0 to U-1 and passes each through the following function as X.
â gets the divisors of U.
÷U divides each of those by U.
x sums the results.
Xâ gets the divisors of X.
÷X divides each of those by X.
x sums the results.
> checks if the first result is greater than the second.
× reduces the resulting array of booleans by multiplcation.

If your current approach matches your explanation, it fails for 360360 or other such integers: One highly recommended negative test case (if your interpreter can handle it) is 360360, because it ties with the last superabundant number

@Mr.XCoder: Nuts, you're right! That's probably gonna cost me some bytes when I get a moment to fix it.

@Mr.Xcoder: Fixed for now, will have to come back later to see if I can improve on it.

APL (Dyalog), 33 bytes
{⍵=⊃⌽+⌿∘.≤⍨((+/⍳(/⍨)0=⍳|⊢)÷⊢)¨⍳⍵}

Try it online!

Husk, 9 bytes
εü<m§ṁ/Ḋṫ

Try it online!
Too slow for the 360360 test case.
Explanation
εü<m§ṁ/Ḋṫ  Implicit input, say n=6.
        ṫ  Decreasing range: [6,5,4,3,2,1]
   m       Map this function (example argument k=4):
       Ḋ    Divisors of k: [1,2,4]
    §ṁ      Map and sum
      /     division by k: 7/4
           Result: [2,6/5,7/4,4/3,3/2,1]
 ü         Remove duplicates by
  <        strict comparison. This greedily extracts a non-decreasing subsequence: [2]
ε          Is it a singleton list? Yes.

I got £ü¤<§ṁ/ḊN. Creating the entire list of superabundant numbers

APL+WIN, 37 bytes
 ↑1=⍒⌽(+/¨((0=(⍳¨n)|¨n)×⍳¨n)~¨⊂0)÷n←⍳⎕

Prompts for screen input.

C (gcc), 99 bytes
s(n,j,k){for(j=k=0;j++<n;)k+=n%j?0:j;n=k;}f(n,i,r){for(i=r=0;++i<n;)r=1.*s(n)/n<1.*s(i)/i?:r;r=!r;}

Try it online!
C, 108 bytes
float s(n,j,k){for(j=k=0;j++<n;)k+=n%j?0:j;return k;}f(n,i,r){for(i=r=0;++i<n;)s(n)/n<s(i)/i&&++r;return!r;}

Try it online!

So, why does s need to return a float?

@StephenLeppik To use float division instead of integer division when comparing s(n)/n to s(i)/i.

Perl 5, 84 bytes
say!grep$a[-1]<=$a[$_],0..(@a=map{$i=$_;my$j;map{$i%$_ or$j+=$_/$i}1..$i;$j}1..<>)-2

requires -E (free)
a straightforward implementation of the specification, golfed

Swift, 120 118 bytes
let s={n in Float((1...n).reduce(0){n%$1>0 ?$0:$0+$1})}
{n in(1..<n).reduce(0){max($0,s($1)/Float($1))}<s(n)/Float(n)}

Takes some time (around 6 seconds on TIO) to compile because of the implicit type declarations in Swift.
Try it online!

Jelly, 12 bytes
RÆs©Ṫ×R>®×$Ạ

Try it online! or Find all superabundant numbers below 1000.
because I hate floating points.

Funky, 79 bytes
d=n=>fors=i=0i<=n i++s+=i*!n%i
f=n=>{forc=1c<n c++if(d(n)/n)<=d(c)/c return0 1}

Explained

This first defines the function d which is the σ function, and this is the golfed version of
function d(n){
    var s = 0;
    for(var i=0; i<n; i++){
        if(n%i == 0){
            s += i;
        }
    }
    return s;
}

We can set i to 0, because i*n%0 will always equal 0*..., thus 0.
The next half of this defines the function f, which is the Superabandunce function, and it is just the golfed form of
function f(n){
    for(var c=1; c<n; c++){
        if( (d(n)/n) <= (d(c)/c) ){
            return 0;
        }
    }
    return 1;
}

And this just checks, as the challenge spec suggests, that all integers from 1 to n-1 have a d(n)/n of less than the input.
Try it online!

APL(NARS), 61 chars, 122 bytes
r←f w;m;k
r←m←0
r+←1⋄k←r÷⍨11πr⋄→3×⍳r≥w⋄→2×⍳∼m<k⋄m←k⋄→2
r←k>m

11π is the function sum of factors
  (⍳9),¨ f¨1..9
1 1  2 1  3 0  4 1  5 0  6 1  7 0  8 0  9 0
  f 360360
0

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