Hacker News new | past | comments | ask | show | jobs | submit login
My Favorite Math Problem (mapehe.github.io)
125 points by gridentio 13 days ago | hide | past | favorite | 80 comments





I came across one of my favorite math problems in high school and it blew my mind.

    ABC
    DEF
  + GHI
  -----
   123J
Each letter represents a distinct digit 0-9. What is J?

Of course you can write a short program that iterates through the possibilities. But there is also a very elegant solution that fits in a tweet. (If you don't want to try solving it, or have tried and have given up, here is the solution: https://twitter.com/joe_antognini/status/1436412147324502016)


A nuance here is that you are assuming the existence of a solution. It may be the case there are no values for A to J that can result in that equation.

Iterating through all possibilities shows that the solution exists, the proof in the tweet doesn't.


The proof in the tweet gives steps to getting a solution, and the solution works. In what way is that not showing that the solution exists?

The tweet only shows what J is, conditional on that there is a solution.

Isn't that exactly how any constructive proof works?

Consider the following problem:

         ABC
         DEF
       + GHI
  ----------
   12300000J
where each letter represents a unique digit. The logic in the tweet would give the same value for J as the original problem, but in this case there is no solution.

A constructive proof would exhibit a solution.

In that case, it has been shown that if a solution exists, it must be that J=6. With this additional information, you can try and find the other digit and conclude the proof (or in the case there's no solution, reach a contradiction).

I don't know how this type of proof is called in English but it's quite common. First come up with necessary conditions on your potential solution, and then you use these conditions to build an actual solution.


I suppose it depends on your definitions, but most constructive proofs construct an entire solution -- that is, leaving no variables free unless the solution applies to any value of them. This only solves for J assuming the others can be solved for.

Yes, this is a good point. I wonder whether there is a proof to show that a solution exists that doesn't involve brute force.

> there is also a very elegant solution that fits in a tweet. (If you don't want to try solving it, or have tried and have given up, here is the solution

I tried to understand the tweet a couple of times, but I couldn't follow the proof from the tweet itself, so I wrote it up again with the basic axiom from the tweet as a basis + work out each step of the process.

https://gist.github.com/t3rmin4t0r/a953450ac64b6868540bbce79...

The original proof is elegant, because it has a single item of information (the "what") to use to solve the entire thing, but was missing the "how" for me.


Modulo 9, a decimal integer is equal to the sum of its digits. More precisely, congruent, notated by ≡:

For instance 123 ≡ 1+2+3 ≡ 6 (mod 9).

We show congruences using ≡, and always have (mod N) on the far right to indicate the modulus for the congurence.

More generally, if ABC is a decimal string, then we know that ABC ≡ A + B + C (mod 9).

Moreover ABC + DEF + GHI must be congruent to A+B+C + D+E+F + G+H+I (mod 9).

And if ABC + DEF + GHI is equal to 123J, then A+B+C + D+E+F + G+H+I ≡ 123J ≡ 1+2+3+J (mod 9).

Thus:

A+B+C+D+E+F+G+H+I ≡ 1+2+3+J (mod 9)

Now suppose we add J to both sides:

A+B+C+D+E+F+G+H+I+J ≡ 1+2+3+J+J (mod 9)

OK so now we know that the left hand side A+...+J contains all elements from 0 to 9, because of the problem constraint that the letters represent unique digits. The numbers 0 to 9 add together to 45. Now 45 is congruent to 0 (mod 9).

Therefore:

A+B+C+D+E+F+G+H+I+J ≡ 45 ≡ 0 ≡ 6 + 2J (mod 9)

We no longer care about the A+..+J; it's vanished. We solve the remaining equation:

0 ≡ 6 + 2J (mod 9)

If 6 + X (mod 9) is congruent to 0, X must be one of {... -6, 3, 12, 21, 30, 39 ...}: the set of integers congruent to 3, (mod 9).

If X = 2J, where J is a one-digit decimal integer, X must be an even, non-negative integer. That rules out -6, 3 and 21. It can't be 30, because J can't be 15. X must be 12, which gives J = 6.


That was all good, except this bit was not obvious to me:

> Modulo 9, a decimal integer is equal to the sum of its digits. More precisely, congruent, notated by ≡:

> For instance 123 ≡ 1+2+3 ≡ 6 (mod 9).

This is the part where the parent comment's explanation was helpful.


There is a nice, succinct explanation for this (which relies on some intuition or knowledge of modulo arithmetic and congruences).

First, a small defnition: let dsum(X) denote "sum of the digits of the decimal representation of whole number x".

In the modulo 9 congruence, 0 and 9 are equivalent symbols. 9 ≡ 0 (mod 9). Though distinct integers outside of the congruence they are indistinguishable elements of the congruence.

Observe that since 9 is congruent to 0, the number 10 is congruent to 1: 10 ≡ 1 (mod 9). Therefore, all powers of 10 are also congruent to 1: 1 ≡ 10 ≡ 100 ≡ 1000 ... (mod 9).

Next, note that these numbers x ∈ {1, 10, 100, 1000, ...} all have the property that x ≡ dsum(X) (mod 9). The sum of decimal digits of each power of 10 is 1, and each power of 10 is congruent to 1, modulo 9.

Within a congruence, whenever we multiply by any congruence element that is indistinguishable from 1, we get the same element. So all of these numbers 1, 10, 100, ... are identity elements in the modulo 9 congruence.

Identity means that, for instance 7 ≡ 70 ≡ 700 ≡ 7000 = 7000 ... (mod 9). If we multiply the congruence element 7 by any power of 10, the result is congruent to 7, modulo 9, because 10 is the identity element: no matter how many times we multiply an integer by 10, the resulting integer is the same modulo 9 congruence element. (Moreover, also note that dsum(7) = dsum(70) = dsum(700) ...).

Next, note that every decimal integer is formed by a sum combination of multiples of power of 10.

For instance, 1234 is equal to 1 x 1000 + 2 x 100 + 3 x 10 + 4.

But suppose we do this arithmetic in the modulo 9 congruence: it must necessarily be that:

1000 + 200 + 30 + 4 ≡ 1 + 2 + 3 + 4 (mod 9).

This is because, individually, 1000 ≡ 1 (mod 9), and 200 ≡ 2 (mod 9), 30 = 3 (mod 9). The power of 10 factors do not matter, since they are really powers of the identity element 1 in the mod 9 congruence.

The succinct explanation is then: every whole number has a decimal form made up of digits, which are multiplied by powers of 10. But in the modulo 9 congruence, powers of 10 do not matter: they map to the multiplicative identity element 1. That leaves the sum of the digits indistinguishable (in the modulo 9 congruence) from the value of the number (which is also a kind of sum of the digits, with each digit being scaled by a different power of 10).


I'm trying it with this TXR Lisp, just for fun. It uses an implementation of John MacCarthy's amb operator based on delimited continuations, which are slow.

  (defmacro amb-scope (. forms)
    ^(block amb-scope ,*forms))

  (defun amb (. args)
    (suspend amb-scope cont
      (each ((a args))
        (whenlet ((res (and a (call cont a))))
          (return-from amb-scope res)))))

  (defmacro 0-9 () '(amb 0 1 2 3 4 5 6 7 8 9))

  (defmacro val (p q r) ^(+ (* 100 ,p) (* 10 ,q) ,r))

  (compile-only
    (amb-scope
      (let* ((A (0-9)) (B (0-9)) (C (0-9))
             (D (0-9)) (E (0-9)) (F (0-9))
             (G (0-9)) (H (0-9)) (I (0-9))
             (J (0-9)))
        (amb (and (eql (+ (val A B C)
                          (val D E F)
                          (val G H I))
                       (+ 1230 J))
                  (eql 1023 (mask A B C D E F G H I J))))
        (prinl (list A B C D E F G H I J)))))
Every amb expression says: "I denote my leftmost non-nil argument which makes the remaining computation successful".

The "remaining computation" is the future computation up to returning a value from the enclosing amb-scope form. The amb-scope form succeeds if it yields a non-nil value.

We use amb to ambiguously bind A, B, C, ... to all the values from 0 to 9, amb magically selects the successful value for each one.

We also use amb to express assertions. If we assert (amb (eq 'day 'night)) then that fails: night is not day.

We simply assert the desired conditions over the variables. If there is any way for the conditions to be true, then that means there exist successful values for the variables and so all the prior ambs choose those successful values.

  This is the TXR Lisp interactive listener of TXR 272.
  Quit with :quit or Ctrl-D on an empty line. Ctrl-X ? for cheatsheet.
  Upgrade to TXR Pro for a one-time fee of learning Lisp!
  1> (compile-file "abcprob")
  t
  2> (load "abcprob")
  (0 1 2 3 4 5 8 7 9 6)
  nil
Thus

     012
     345
     879
    ----
    1236

The "all letter digits unique" is efficiently met using bits to represent a set. TXR Lisp has a mask function which calculates an integer whose binary representation has a 1 in the positions indicated by the arguments. E.g (mask 0 2) yields 6, and (mask 0 1 2) yields 7.

If mask is given 10 unique digit values---the complete set---it must produce the value #b1111111111 or 1023, the complete set mask.

We thereby avoid n squared silliness like (and (neql A B) (neql A C) ...): asserting that no letter pair is equal.


Normally in these kind of cryptogram puzzles the leading digits of a number can't be 0. Your solution has A = 0.

In that case, we can easily add these constraints to look for another solution, like this --- but that is a poor way:

  (compile-only
    (amb-scope
      (let* ((A (0-9)) (B (0-9)) (C (0-9))
             (D (0-9)) (E (0-9)) (F (0-9))
             (G (0-9)) (H (0-9)) (I (0-9))
             (J (0-9)))
        (amb (and (eql (+ (val A B C)
                          (val D E F)
                          (val G H I))
                       (+ 1230 J))
                  (nzerop A) (nzerop D) (nzerop G) ;; don't do this
                  (eql 1023 (mask A B C D E F G H I J))))
        (prinl (list A B C D E F G H I J)))))

Better just exclude the value 0 from the amb expression for those digits, to reduce the search space:

  (defmacro 0-9 () ^(amb ,*(range 0 9)))

  (defmacro 1-9 () ^(amb ,*(range 1 9)))

  (defmacro val (p q r) ^(+ (* 100 ,p) (* 10 ,q) ,r))

  (compile-only
    (amb-scope
      (let* ((A (1-9)) (B (0-9)) (C (0-9))
             (D (1-9)) (E (0-9)) (F (0-9))
             (G (1-9)) (H (0-9)) (I (0-9))
             (J (0-9)))
        (amb (and (eql (+ (val A B C)
                          (val D E F)
                          (val G H I))
                       (+ 1230 J))
                  (eql 1023 (mask A B C D E F G H I J))))
        (prinl (list A B C D E F G H I J)))))


  1> (compile-file "abcprob.tl")
  t
  2> (load "abcprob")
  (1 0 2 3 4 5 7 8 9 6)
So:

    102
    345
  + 789
  -----
  =1236
:)

Since we have a math proof that J is 6 in all possible solutions, which works without discovering the other values, we might as well bind (J 6); the purpose is to get the other letters. Binding J cuts down the execution time by close to an order of magnitude.

John's amb operator has a weakness: it is satisfied with finding one successful value. What if we want all the solutions?

We must invent a related operator. Let us call it kanzen, Japanese for completion/perfection (完全). (This is not the "kan" in "kanren" which is 関連).

amb-scope and amb are defined exactly as before, but we add:

  (defun kanzen (. args)
    (suspend amb-scope cont
      (return-from amb-scope
        (append-each ((a args))
          (whenlet ((res (and a (call cont a))))
            (list res))))))
Using only amb, let's find some pair of integers x y, in the range 0 to 9, whose product is 12:

  (prinl
    (amb-scope
      (let ((x (amb 0 1 2 3 4 5 6 7 8 9))
            (y (amb 0 1 2 3 4 5 6 7 8 9)))
        (amb (eql (* x y) 12))
        (list x y))))
The output is:

  (2 6)
Now, let's change the first amb to kanzen. Just the first one:

  (prinl
    (amb-scope
      (let ((x (kanzen 0 1 2 3 4 5 6 7 8 9))
            (y (amb 0 1 2 3 4 5 6 7 8 9)))
        (amb (eql (* x y) 12))
        (list x y))))
The output now is:

  ((2 6) (3 4) (4 3) (6 2))
all the (x y) pairs are found that multiply to 12.

What does kanzen do differently? Like amb, it cares only about non-nil arguments. However, instead of just finding the first non-nil argument for which the future computation succeeds (returns non-nil), and then returning that result out of amb-scope, kanzen probes all non-nil arguments. It continues the future computation with each value, and for each computation that succeeds (returns non-nil), it collects that value into a list. Then it aborts amb-scope using that list as the result value.

So the weird thing to be understood here is that (list x y) doesn't necessarily determine the ultimate result value of the amb-scope form. The first amb or kanzen call holds the reins, so to speak. If the first operator is amb then, indeed, the result value will be one that was produced by (list x y). amb will try the different futures, and when it finds one that yields non-nil, it aborts amb-scope with that value.

What happens with kanzen is that the ((y (amb ...))) part will find successful y values, and abort amb-scope. But it's doing that aborting within the scope of a continuation created by kanzen, so kanzen intercepts that, collects the (list x y) value, and keeps trying other futures. Thus, confusingly, the result doesn't have shape expected by (list x y).

Note how this is fundamentally hostile to static typing. This code depends on exactly the same piece of syntax, the amb-scope block, having a different type in different contexts: a list of integers during the execution of the search, and a list of lists of integers in the ultimate return.

A static typing theory could be developed for this which assigns multiple types to a node in the program. The interior of amb-scope can see its return value as "pair of integers". all the continuations captured within that scope have that return type. But because of the presence of kanzen, the node can be assigned an external static type as "list of pairs of integers". Or something like that.


The "Math Misery" blog has several problems like this, for example http://mathmisery.com/wp/2017/04/02/cryptarithmetic-puzzle-8...

Does each letter lie in [0,9] or did you mean [1,9]?

There's 10 letters including J so 0 is allowed

Aha, I can't count, apparently. Thanks!

My favorite in this line is send+more=money.

Mine too, but you cannot solve that one in one tweet, so it does not fit the subject.

This problem reminds me of another problem.

There is a round table and two players, A and B. The players take turns placing a coin on the table in any location they desire, but coins may not overlap. The first person who is unable to place a coin loses. What is the winning first move?

Answer: the winning move is for player A to place the first coin in the center of the table. After that, no matter which location player B chooses, player A can always play the 180 degree rotationally symmetric location.


I solved this in a hedge fund interview with "Consider the limiting case of a coin the same size as the table... You can only place it at the centre, and you win... Now make the coin smaller. How does the strategy change?... It can't, because of symmetry."

They didn't consider it a valid solution :|


This solution doesn't hold - just because a game is symmetrical, doesn't guarantee that the optimal move in some limiting case works in all cases.

For example, consider if the game was played with N>2 players, or if the win condition was to make the first move modulo N, for some N>2. In those cases everything would still be symmetrical, and playing in the center would still be a winning move for huge coins, but not (necessarily) for smaller coins.


It is not clear to me how to play following your strategy. There are things missing. You need to describe what the second move should look like.

Well, that explanation is a total cop out, so I can see why they would think that.

I disagree. Arguments to symmetry like this are found all over the place, especially in the kind of geometry and physics I'm familiar with. In fact the solution I came up with when I read the problem was very similar.

The original comment (by tasty_freeze) was an argument to symmetry. Just saying "because of symmetry" is not a proper explanation.

You're right that it's not a proper explanation. This feels just like a case of "details are left as an exercise". This is most frustrating when you're learning a subject, and you want to be able to check the details, or you are skeptical of a claim. Inevitably though people elide things that they think the reader (who they model as similar to themselves) will immediately be able to guess based on their experience. I'm sure you can think of an equivalent situation in your field of expertise.

I can think of things where I would leave out details that a non-expert would need filled in. Except, I wouldn't do that in an interview situation where someone is specifically asking me to explain that one thing. (Yes they started with the giant coin thing, but "symmetry" is still the substantial majority of their argument.)

The sibling to my first comment says it a lot better than I did: in a similar but different situation there's symmetry but no analogous strategy, so further explanation really is needed here.

In a sense, that makes it even more damning. Eliding details that you don't realise are important, but actually are, shows a real lack of understanding of your own argument. And that's something I have definitely witnessed in my own field!


Oh man, I assumed he explained it in the interview and was just leaving out the details for the purposes of the comment. That was me being dense.

Working through this myself...

If you place a coin in the center, then due to symmetry there must be an even number of remaining places for a coin (or you didn't put it in the center).

You can work up from remaining=2 to see that player A always wins with an even remainder.


It is not fully correct to think in terms of even numbers or remainders, because there are an uncountably infinite number of places that a coin can be placed.

It is the right general idea, but don't try to express it in numbers. Just think that for each non-center point P there is a unique corresponding point P' such that the center point is exactly midway between P and P'. That gets you your pairs of places to work with without having to bring numbers into it.

For a coin placed at the center it covers any given non-center point Q if and only if at covers Q's corresponding point Q'. After the first player plays the center we then have that for every point that is not yet covered that point's corresponding point is not yet covered.

Then you have to show that once the center point has been covered by a coin any subsequent coin played that covers a point R cannot also cover R's corresponding point R'.

Then you can proceed with your pairing argument that whenever player 2 covers a set of points player 1 can cover the corresponding points on the next turn, and that after this we have restored the condition that for every point still available its corresponding point is also still available.


Even though it's uncountable and potentially infinite, it's still even, because of exactly the symmetry relation you're saying.

I just thought that the intuition for an even number of places is a lot easier (for me) to grok.



And if they don't, then what?

Then they are not guaranteed to win.

This one is my favorite, too—it really highlights what the job of a mathematician is. The board is the board, and the dominos either fit or they don’t, and it’s not clear why. But once someone adds the checkerboard shading—not changing the problem at all, but just adding a new way to look at it—suddenly the solution falls out, clear and obviously true.

I am curious. Are all boards that have equal white and black tiles counts solvable?

Yes, by induction. Suppose the total number of squares is 2n. Remove any domino that doesn't disconnect the board, and reduce to the problem for 2n - 2.

Alternative proof: no, by example. Consider the shape made up by the X's in

  XXX
  .X.
  .X.
  XXX
(All maths proofs should be presented alongside a proof of the opposite result, to allow the reader to judge which one is likely to have slipped something past you. My favourite presentation following this rule is Mental Poker [0] by the authors of RSA.)

[0] https://people.csail.mit.edu/rivest/pubs/SRA81.pdf


Slightly more interesting example which isn't disconnected is a H letter consisting of 8 blocks. 3 blocks high and 2 in the horizontal section.

Nope—consider a black and white square, disconnected. But if they don’t have equal black and white counts, then they’re definitely not solvable.

This was covered in MIT 6.042 in in a different and bit harder way by Tom Leighton as a general proof. The problem involved tiling the Stata courtyard with L-shaped tiles. You need a bit of mathematical induction to prove such results.

A slightly more involved version of this puzzle asks about covering all but one square of the chess board with 21 trominoes (each of size 3x1 or 1x3), since 64 = 21*3 + 1.

What square remains uncovered (unique up to symmetry) ?


Bunch of problems like this are in the book "Problem-Solving Strategies" by Arthur Engel [1], I believe even including this particular one. Fun book.

[1]https://www.google.com/books/edition/Problem_Solving_Strateg...


Or anything with Martin Gardner's name on it. All worth reading.

This book is a classic one for kids participating in math competitions in Romania. I once had to solve a variation of this problem at a math contest when I was in 6th grade.

Yeah, got this book and the problem was also a classical one.

It's simultaneously fascinating and frustrating when you run into a problem that suits those criteria.

In this case of course the hint is well disguised: if you had an unmarked board you might not think to checker it, but a checkered board is a common thing, so you might not think anything of it when someone presents it as part of the problem.

Reminds me of how you find the area under exp(-x^2). Stare at it for a bit and it looks like it can't be done. But if you add another dimension to it, you find the solution.

And this is what is both fascinating and frustrating. You could add a lot of things to a problem without making any progress, but there are certain things you can do that make it simple.


I thought this could be about the Monty Hall Problem, which I think is my own personal favourite. It isn't, of course, but I'll share some info here as no one else has raised it so far this thread :-)

It's an interesting probability question in its own right, as it has a hugely counter-intuitive correct answer in my opinion. But the sh*storm it caused is equally interesting. Hence I will share this article which covers both aspects:

https://priceonomics.com/the-time-everyone-corrected-the-wor...

A major takeaway - statistics and probability can be really tough sometimes and even world class practitioners can be caught out when intuition and mathematics clash. And a little humility is perhaps wise when trying to "correct" people, just in case...


Yeah I remember when I heard about it years ago I actually wrote a simple program to show to myself that the second switching actually helps (yes, it does).

That’s not totally clear, due to the way the problem is often described: As a one-off event, with no clear rules for what the host will do. If there is no clear rule about what the host will do, you are still left in the dark. For example, the host may have decided beforehand (in secret) that he will open another door only if you picked the winning door. In that case, switching will lose you the prize with certainty.

But yes, if it is clearly understood that the host always opens another door after you picked one, you should switch.


A similar argument has been used in the more-or-less famous proof of how to assemble a lamp with Tetris-shaped components into a rectangle:

https://jackmorris.xyz/2015/the-simple-proof-of-the-tetris-l...


this is also one of my favorite problems. Though the version that I heard doesn't mention a chess board but rather a general 8x8 (or 10x10) board. I find that this makes the problem even more beautiful because of the initial required insight to color the squares at all and the meaning gaines from it.

I like the infamous Von Neumann "Fly and the trains" math/physics problem - mainly because it's very easy to solve the easy way, or you can go about it the harder way. And apparently Von Neumann did it on the spot, the harder way, almost instantaneous.

It goes like this (stolen from a website - there are many variations on this):

Problem: Two trains are on the same line, 60 miles apart, heading towards each other, each traveling at 30 mph. A fly that can travel at 60 mph leaves one engine flying towards the other. Upon reaching the other engine, it instantaneously turns around, and heads back to the other engine. This is repeated until the two trains crash and the fly is annihilated at the same time.

Question: How far does the fly travel before it is "splatted"?


I think the problem here is posed in a way where there is a simple trick (because the fly flies exactly 2 times faster than one of the trains).

From the reference of a train, the other train is coming at 60 mph, which is equal to the speed of the fly.

So the problem would be equivalent to having the fly be stuck on the windshield of a 60 mph train until it collides with a train at 0 mph.

It takes 1 hour to move 60 miles at 60 mph. So the fly flies 60 miles.

If I recall in the original problem the fly flies at a different speed compared to the train (relative to the driver of the train), just to make it conceptually a little harder.


I'll try it. I hope I do not make a stupid mistake.

When the first train has travelled one third of the distance separating it from the other train, the fly will have travelled two thirds of this distance, and the other train one third of the distance, in the opposite way, which means it is exactly the moment at which the fly hits the second train and turns back.

Let d be the initial distance between both trains. Now we are solving almost the same problem (the speeds do not change, and the way the fly travels is irrelevant, the problem is symmetric), the only parameter changing is the distance, now being 2/3 * d.

We can reason the same way ad infinitum and we identify the distance D travelled by the fly is the following:

D = 2/3 d + 2/3 (2/3 d) + ... D = 2/3 d + (2/3)^2 d + (2/3)^3 d + ... D = d * {sum for n from 1 to infinity}{(2/3) ^ n} D = 3d

The fly travels 3 times the distance between the trains before dying.


Indeed, doing the infinite sum is the "hard" way.

The easier way is to notice that the trains will collide in 1h and the fly will be constantly be flying at a speed of 60mph for the entire time. So the fly will travel 60 miles in the alloted time.


It means I actually made a mistake! I understand your solution. :)

Yeah, the distance changes by a factor of 1/3 each time (which actually makes for an easier infinite sum), not 2/3.

Reminds me of the ants-on-a-stick problem.

100 ants are spaced evenly on a 1m stick. They travel at 1m/minute. When an ant bumps into another ant, they both turn around and go the other way. When an ant reaches the end of the stick it falls off.

How long before all the ants fall off?


That's not solvable as stated. I think you may have accidentally misstated the question.

> 100 ants are spaced evenly on a 1m stick

Are the ends at the end of the line of evenly spaced ants on the very ends of the stick?

> They travel at 1m/minute.

Is each ant initially traveling? What is the initial travel direction of each traveling ant?

This matters because if the ants are all traveling in initially traveling then (assuming maximal even initial spacing) it would take 1 minute for the last ant to fall off, but if each ant were initially traveling towards the nearest end it would take about 1/2 minute.

Googling, I found almost the same problem except that the question asked was what is the minimum time that guarantees all ants will have fallen off no matter what their initial directions are.


Does it matter if they are evenly spaced? I think max time needed is the same if they are randomly spaced.

You are correct. Even spacing does not matter.

There are many initial configurations that achieve the maximum time before the last ant falls off the stick, and that includes configurations where they are evenly spaced and configurations where all but one ant is randomly spaced (achieving maximum time requires that at least one ant be in a particular initial state--I'm being vague to avoid spoilers).

(This is all assuming mathematical ants...point sized and can change direction instantly)


This same proof technique is the primary method for identifying impossible configurations for the Soma Cube puzzle:

https://en.wikipedia.org/wiki/Soma_cube

"Seven pieces made out of unit cubes must be assembled into a 3×3×3 cube. The pieces can also be used to make a variety of other 3D shapes."


My favorite pet math problem so far is: how many times of day are all three hands on a clock equal parts apart?

I have a close but wrong answer that is more interesting than the right answer. I wish I knew of a STEM periodical that accepted amateur articles because I want to do a write-up on this.


> My favorite pet math problem so far is: how many times of day are all three hands on a clock equal parts apart?

Depends on the clock.

(Three hand clocks can be d/h/m or h/m/s.)


I have never seen a d/h/m clock.

The differential equations would be the same, just with different coefficients.

Typeset PDF in case you don't want to LaTeX-by-eye: https://cloudflare-ipfs.com/ipfs/QmcZf4xuHEvvqrBCv2uhnyQXk5u...

What? The mathematics shows correctly on the page for me, and that PDF is missing some chessboard images...

presumably they are running a script blocker that took out the JS that renders the maths.

Yeah, this must have been what happened. I'm happy is works for others.

As a start (and possibly as an equivalent proof?) you can mentally brute force it by cutting the board down to 4x4 and just visualising how the blocks might fit. It quickly becomes obvious that it's not possible.

With so many of these "math puzzles," you can usually solve it by cutting it down to a trivial size and scaling it up.

The 2x1 covers a1 and b1, not a1 and a2.

Math is the closest thing to magic that actually exists (and we can work on).



Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: