[HN Gopher] Making any integer with four 2s
___________________________________________________________________
Making any integer with four 2s
Author : LorenDB
Score : 31 points
Date : 2025-02-23 02:25 UTC (20 hours ago)
(HTM) web link (eli.thegreenplace.net)
(TXT) w3m dump (eli.thegreenplace.net)
| horsawlarway wrote:
| I feel like the second you allow functions you've thrown the
| spirit of the game.
|
| Ex, the gamma function is (n-1)! So now you're making 7 with four
| twos and a one. You've broken the spirit.
|
| If I can hide numbers in a function call... It's trivially easy
| to always succeed.
| lblume wrote:
| I would argue that the Gamma function is more fundamental than
| the factorial operation. But you are still correct that if
| arbitrary functions were allowed, the game would degenerate to
| triviality.
| TOGoS wrote:
| Inorite. If we're allowing any old function, then I can just
| define 12345 as Onetwothreefourfive()-2+2-2+2
| Someone wrote:
| > I feel like the second you allow functions you've thrown the
| spirit of the game.
|
| +, - (both binary and unary), x, / are functions, as is raising
| to a power. Why would you allow them?
|
| As always in this kind of things, one can disagree about what
| constitutes an elementary function, but I don't think taking
| square roots should be disqualified in this puzzle.
|
| > Ex, the gamma function is (n-1)!
|
| And 2 is just _S(S(0))_
| (https://en.wikipedia.org/wiki/Peano_axioms)
|
| > If I can hide numbers in a function call... It's trivially
| easy to always succeed.
|
| I wouldn't call the construction given by Paul Dirac trivial.
| Do you think it is, or do you know of a simpler one?
| dooglius wrote:
| It sounds like you've just found one for >=2: 2, S(2),
| S(S(2)), ...
| Someone wrote:
| That, somewhat ironically, typically isn't included in the
| set of elementary functions. 'plus' is, but 'plus one'
| isn't.
| tikhonj wrote:
| That gets at what makes using additional functions like
| in the blog post a bit arbitrary: we don't have special
| notation for "+ 1" or "* 2", but we do for "^(1/2)" and
| "log_2". It's not hard to imagine a different world where
| "+ 1" or "^2" had special notation, and suddenly we'd be
| able to solve the question in even simpler ways.
|
| It's still a fun puzzle, it's just based more on our
| shared notational conventions as much as the underlying
| math.
| madcaptenor wrote:
| For example it would not be weird to have ++ instead of
| +1.
| StilesCrisis wrote:
| That's just S(n)
| thaumasiotes wrote:
| > I wouldn't call the construction given by Paul Dirac
| trivial. Do you think it is
|
| Yes? It's doing exactly the thing that your parent comment
| complains about in the gamma function, introducing additional
| constants (in this case, mostly 2s) that, for no particular
| reason, don't count.
|
| Why would you interpret squaring as consuming a 2, but square
| rooting as _not_ consuming a 2?
| zeroonetwothree wrote:
| Because of our standard notation for those
| the__alchemist wrote:
| You are inferring that as a rule of the game by making
| assumptions. There are other conclusions different people
| could reach.
| omoikane wrote:
| Maybe they meant symbolic operators feel alright but named
| functions feel like cheating, so 2+2+2+[?][?]2[?] is fine but
| 2+2+2+floor(sqrt(2)) is not.
| timerol wrote:
| > And 2 is just S(S(0))
|
| This is a good example of why you need rules on which
| functions are allowed. Repeated application of the successor
| function makes the entire exercise trivial
| Karellen wrote:
| But also, if the criteria for allowed functions is that
| they are "reasonable, elemental" (as per the fine article),
| then I think it would be quite hard to come up with a set
| of rules to encode that in a way that includes _log()_ and
| _sqrt()_ , but not _S()_. It 's hard to imagine a function
| that is less elemental than _S()_ (except maybe the
| identity function), or why its inclusion would be
| unreasonable when the other two aren 't.
| the__alchemist wrote:
| That's exactly the point. What exactly, is the set of
| allowable functions used for the problem? I think you, and
| the post you reply to, are stating the same thing.
|
| Where do you draw a line between "Functions available on a
| 4-function calculator" and "Functions I can make up
| specifically to generate a target integer"? I think you have
| to rigidly define this, or the game loses meaning.
| jrockway wrote:
| Right, I invented the jrockway function which is defined as
| f(2, 2, 2, 2) = 7 so I made 7. Maybe the rule is "someone
| else has to invent the function", but I invented that so
| you can use it. (Please make me a the__alchemist function.)
|
| Maybe the rule should be that the function has to be
| invented before the inventor has knowledge of this game.
| But now I'm just going through /usr/bin looking for
| binaries where the 2222th byte is 0x7.
| jonahx wrote:
| This is a great point. I think what you're really responding
| to is that it's a game without clear rules, and so part of
| the "game" is thinking about creative interpretations of the
| rules themselves and pushing the boundary of what others
| originally _assumed_ the rules to be.
|
| Granted there _is_ creativity in this sort of game -- indeed,
| most "games" in life are like this -- but it's quite a
| different thing from winning a game with clearly defined
| rules like chess, or this game with the set of allowed
| operations specified up front.
| ajkjk wrote:
| you shouldn't be able to use letters. You're supposed to use
| four 2s and symbols, not four 2s plus the letters "l", "o",
| "g".
| quietbritishjim wrote:
| I think a key distinction is that those are functions of two
| parameters. You can't just use them as many times as you like
| "for free" like the square root trick at the end of the
| article, because you need to "spend" at least one extra 2 on
| the second parameter each time.
|
| That's not the whole story of course, you still need to agree
| on the set of allowed operations, but I think it makes a big
| difference even though it seems incidental at first.
| nwallin wrote:
| Surely we accept unary minus as one of our functions? Once
| we accept one unary function we're just quibbling over
| details.
|
| I agree that you need to define and agree upon a finite set
| of allowed operations before playing the game. IMHO, square
| root, logarithm/exp, floor/round/ceiling, sin/cos/tan ought
| to be included in the list. But that's just like, my
| opinion, man.
| billyjmc wrote:
| But repeated application of the unary minus basically
| results in a no-op. So it's somewhat exceptional in that
| regard.
| Boldened15 wrote:
| It's just about having fun at the end of the day, the gamma
| function and square root are considered fundamental enough. But
| if one wants they could try to limit to different subsets of
| functions and prove which numbers are possible or impossible to
| achieve just with those.
|
| They also say "mathematical tools" not arbitrary functions.
| vlovich123 wrote:
| The Dirac solution doesn't involve gamma, just N square roots
| and 2 logarithms.
| Biganon wrote:
| But the square root has a hidden operand, 2. We don't write
| it because by convention the default root is 2, but that
| still feel like cheating to me.
| codegladiator wrote:
| > If I can hide numbers in a function call
|
| Yeah this feels like those "Implemented XYZ in 1 line"
| import XYZ
| thfuran wrote:
| That's just what it evaluates to on integers. The standard
| definition of it also includes e and an integral from 0 to [?].
| vesinisa wrote:
| I think you have a point, but as others have commented
| "allowing functions" is not the problem, as fundamental math
| operations _are_ functions. But if we limit ourselves to only
| functions that map (tuples of) integers to integers ((Z, Z,
| ...) - > Z), the spirit of the original game is retained. This
| disallows sqrt and log, but retains addition, subtraction and
| multiplication (but not division). Factorial (n!) is allowed,
| as is exponentiation to a non-negative power.
|
| Wonder if someone could come up with general solution within
| these constraints.
| the__alchemist wrote:
| This was my initial thought once we got to the Gamma function.
|
| My reasoning is (I'm pretty sure it's the same as yours), why
| is the gamma function allowed, but not others? I could insert
| arbitrary functions to make the game arbitrarily solvable.
|
| While this hit me at the Gamma introduction, I think it leads
| back to the beginning: It's a poorly defined problem from the
| rules at the start of the article. It should instead define the
| set of allowable functions (or operations) explicitly. I think
| you could modify this to retain the intent of showing how the
| problem scales with knowledge level.
| shmerl wrote:
| Since in essence you can define your own functions f that give
| you any number you want from 2 (and for example not defined
| anywhere else). I.e. rules never said you can't use any
| function. They are vaguely saying "any mathematical operation".
| lblume wrote:
| So, the formula is really about making any integer with three 2s,
| but historical precedent calls the game with four 2s more
| interesting, so the (stronger) result is monkey-patched by
| replacing a 2 with sqrt(2+2).
| hinkley wrote:
| Why not use 3 2's to make n + 2 or n - 2? That's a lot easier
| than making a subscript so complicated.
|
| This is the Curse of Knowledge. OP stared too long into the
| abyss.
| hansonkd wrote:
| Related numberphile video which goes into a different variation
| of using all digits in ascending and descending order:
| https://www.youtube.com/watch?v=-ruC5A9EzzE
|
| but in this case there is a unsolved gap!
| tasn wrote:
| Maybe it's just me, but writing sqrt(2+2) instead of sqrt(2*2) or
| sqrt(2^2) was such an odd choice. It obfuscates the reason why
| 2=sqrt(2+2), and unnecessarily so.
| mmooss wrote:
| Good point and feedback, but an odd choice by the author?
|
| It could be the phenomenon of the author's cognitive bandwidth
| being consumed by everything in the article, including each
| argument, the overall argument, the writing, the formatting,
| etc. etc., and with time pressures. The critic can focus at
| their leisure on one point, with bandwidth to spare - and so
| it's obvious! :)
| tasn wrote:
| I agree it potentially wasn't a conscious choice, but it's
| still interesting nonetheless.
|
| I wasn't criticizing him for this, but rather fascinated that
| this is the variant that was chosen.
| hinkley wrote:
| Speaking of odd choices:
|
| 12 = 2 * (2+2+2)
|
| Is a hell or a lot simpler than using complex numbers. Might
| be a different example for that would have been better.
| axus wrote:
| Maybe there's a "golf score" somewhere that rewards less
| expensive operations. The "Dirac hack" would run up a lot of
| points.
| volemo wrote:
| I kinda feel that's cheating and each square root requires a two
| to use it.
| grayfaced wrote:
| The problem is allowing arbitrary numbers of unary operators.
| If you allowed ++ increment it would be trivialized even
| easier. Could even do all complex numbers with only 2 twos.
| pinoy420 wrote:
| 2/2+2/2...
|
| Then you just add it multiple times
|
| And if 0 is an integer.
|
| 2/2-2/2
| Boldened15 wrote:
| Doesn't seem like the author is recursively building solutions,
| so this doesn't work.
| madflame991 wrote:
| Here are some values that are (understandably) not listed on the
| blog. They happen only due to the limited precision of floating
| point formats. 128 = [?](2 /
| [?][?]([?]2 - (2 / [?]2))) 8192 = [?][?](2 /
| (([?]2 * [?]2) - 2)) 16384 = (2 / [?][?]([?]2 -
| (2 / [?]2))) 67108864 = [?](2 / (([?]2 * [?]2) -
| 2)) 134217728 = (2 / [?]([?]2 - (2 / [?]2)))
| 4503599627370496 = (2 / (([?]2 * [?]2) - 2))
| 9007199254740992 = (2 / ([?]2 - (2 / [?]2)))
| 6369051672525773 = ([?]2 / ([?]2 - (2 / [?]2)))
|
| I found these by accident a long time ago but kept them because
| they do "work". Try to input one expression in the lil box in
| https://www.wolframalpha.com/?source=nav and they will quickly
| evaluate to these values; the charade goes away after you press
| Enter and get the (mathematically) correct answer.
|
| My old solvers from what feels like a previous life:
| https://madflame991.blogspot.com/2013/02/four-fours.html
| https://madflame991.blogspot.com/2013/02/return-of-four-four...
|
| That was fun
| lifthrasiir wrote:
| When everything is an IEEE 754 floating point number, a
| mathematically "linear" function can indeed be coerced into
| anything: http://tom7.org/grad/
| ziofill wrote:
| This is amazing, but there are a lot of 2's hiding in those sqrt
| symbols
| xandrius wrote:
| Am I missing something or 7 is simply 2 + 2 + 2 + 2/2?
|
| All those are allowed, so what's the problem?
| cezart wrote:
| Your first example uses 2 five times. Your second results in 3
| Sophira wrote:
| Wouldn't that be five 2s, not 4?
| xandrius wrote:
| Thanks! That explains it!
| ashenke wrote:
| You now have five 2s!
| xandrius wrote:
| Ooohhh! With only 4x 2s. I get it now! I feel dummy
| omoikane wrote:
| I like these games, and I would say more fun when using a larger
| number that has more factors, for example 120. 120 is among the
| superior highly composite numbers:
|
| https://en.wikipedia.org/wiki/Superior_highly_composite_numb...
| kazinator wrote:
| > There's just one small wrinkle: it uses three instances of the
| digit 2, not four.
|
| One small wrinkle, if you ignore the fact that the root notation
| conceals exponentiation by 1/2, by making that common value a
| default.
|
| That's a lot of hidden 2's!
| svat wrote:
| See also: "Representing numbers using only one 4" written by a
| 26-year-old Donald Knuth in 1964
| (https://www.jstor.org/stable/2689238 reprinted as Chapter 10 of
| his _Selected Papers on Fun and Games_ ) -- it uses the single
| digit 4, and the three operations [?]x (square root), [?]x[?]
| (floor, i.e. greater integer not greater than), and x!
| (factorial), and ends with a (still unsolved) conjecture about
| whether every integer can be represented in this way.
|
| The appendix (written for the book in 2011) points out an earlier
| (1962) 1.5-page paper _p in Four 4 's_ by J. H. Conway and M. J.
| T. Guy, written when they were students at Cambridge, that has a
| similar idea:
| https://archive.org/details/eureka-25/page/18/mode/1up?view=...
|
| For example, 5 = [?][?][?][?][?][?](4!)![?]
|
| because 24! lies between 5^{32} and 6^{32}.
| jansan wrote:
| Is using a primorial permitted? 7 = (2+2)#+2/2
|
| https://en.wikipedia.org/wiki/Primorial
| everfree wrote:
| You don't need the gamma function to get to 7. You can stay at an
| Algebra 1 level.
|
| I solved the puzzle for 1-10 before looking at the answers, and
| this was my solution for 7:
|
| [?][?]222[?]/2
|
| or more readably:
|
| floor(sqrt(222)) / 2
| pinoy420 wrote:
| If floor a legitimate mathematical function?
| gcbirzan wrote:
| Yes.
| https://en.wikipedia.org/wiki/Floor_and_ceiling_functions
| everfree wrote:
| Legitimate? What do you mean?
| tantalor wrote:
| > use any mathematical operations
|
| Okay, then this is easy, just use the successor function.
| S(n) = n+1 6 = 2*2*2-2 7 = S(2*2*2-2) 8 =
| S(S(2*2*2-2))
|
| Etc.
| miningape wrote:
| lambda calculus has entered the chat
| Buttons840 wrote:
| https://wiki.haskell.org/Peano_numbers
| virgulino wrote:
| There's the classic "four fours", which I learned as a child in
| the book "The Man Who Counted".
|
| https://en.wikipedia.org/wiki/Four_fours
|
| https://en.wikipedia.org/wiki/The_Man_Who_Counted
| TZubiri wrote:
| That's the one!
|
| That's how I learned about false induction. I also liked the
| one about the men who were lined up and had something on their
| backs and they had to guess what it was.
| mbfg wrote:
| i thought the famous puzzle was 4, 4s
| Lerc wrote:
| I think my preference is more towards conciseness.
|
| I made a stack machine with single character instructions and
| needed to solve a variation of this problem. I had just the
| digits 0 through 9. The characters '23' would be push 2 followed
| by push 3. To actually represent the number 23 you would use
| 45*3+ or something similar.
|
| That left me with the problem of how to encode each integer in
| the fewest characters.
|
| Tools at hand. The digits 0 through 9
| 'P': Pi '*': (a * b), '/': (a / b),
| '-': (a - b), '+': (a + b), 's':
| sin(a), 'c': cos(a), 'q': sqrt(a),
| 'l': log(a), '~': abs(a), '#':
| round(a), '$': Math.floor(a), 'C':
| clamp(a), '<': min(a, b), '>':
| max(a, b), '^': pow(a, b), 'a': atan2(a,
| b), '%': positiveMod(a, b), '!': (1 - a),
| '?': (a <= 0 ? 0 : 1) 'o': a xor b scaled by c;
| ((a*c) xor (b*c))/c 'd': duplicate the top
| stack entry ':': swap the top two stack entries
| ';': swap the top and third stack entries
|
| I have wondered about revisiting the stack machine with a complex
| number stack to see what I can come up with.
|
| (Next time I post something like this I am not going to use my
| phone)
| Y_Y wrote:
| The answer in general may be uncomputable.
|
| https://en.wikipedia.org/wiki/Kolmogorov_complexity
| Lerc wrote:
| AHH but in practice you are limited to 50 characters.
|
| https://c50.fingswotidun.com/
|
| Which gives you a finite problem. The VM cannot loop or
| define functions (yet, anyway) so it doesn't go all busy
| beaver on you.
| nwallin wrote:
| Kolmogorov complexity is uncomputable because it admits
| Turing complete languages, and reduces to the halting
| problem. If the language you admit isn't Turing complete,
| then the Kolmogorov complexity of the thing is computable.
|
| It looks like OP's language is not Turing complete. It always
| terminates. You can just do a breadth first search on the
| program space. The first program you get that outputs the
| number you want is the shortest program.
|
| If it _were_ Turing complete, you can 't do this, because
| eventually you'll find a program that just keeps running for
| like a really long time. Is it running because the program
| never halts? Or is will it halt eventually and output the
| number you want? You can't know for sure.
| Nuzzerino wrote:
| Reminds me of https://www.hacker.org/hvm/ (2008)
| westurner wrote:
| > _I 've read about this story in Graham Farmelo's book The
| Strangest Man: The Hidden Life of Paul Dirac, Quantum Genius._
|
| "The Strangest Man":
| https://en.wikipedia.org/wiki/The_Strangest_Man
|
| Four Fours: https://en.wikipedia.org/wiki/Four_fours :
|
| > _Four fours is a mathematical puzzle, the goal of which is to
| find the simplest mathematical expression for every whole number
| from 0 to some maximum, using only common mathematical symbols
| and the digit four. No other digit is allowed. Most versions of
| the puzzle require that each expression have exactly four fours,
| but some variations require that each expression have some
| minimum number of fours._
| westurner wrote:
| "Golden ratio base is a non-integer positional numeral system"
| (2023) https://news.ycombinator.com/item?id=37969716 :
|
| > _What about radix e_ pi*i, or just e?"
| gabrielsroka wrote:
| https://news.ycombinator.com/item?id=43149883
| dang wrote:
| Thanks--I think we'll merge the comments hither because this
| submission was the first, and because the other submitter
| currently has a second article on the frontpage right now.
| SilasX wrote:
| Related: there as a reverse engineering/CTF challenge (which
| shall remain nameless to prevent you from cheating) where my
| solution involved injecting shellcode that adds specific number
| to the stack pointer. But your shellcode -- including the
| number(s) you add -- can only involve bytes from the ascii
| alphanumeric set.
|
| So I used a SAT solver to find a combination of numbers, not
| using prohibited bytes, that _add up_ to the number I really
| want.
|
| https://docs.google.com/presentation/d/19K7SK1L49reoFgjEPKCF...
| unification_fan wrote:
| This is just Peano arithmetic with extra steps
| pil0u wrote:
| This reminds me of this mobile game Tchisla[0] where you have to
| build all numbers up to 1000 (10000?) using only a given digit
| and a couple of operators (including sqrt and !)
|
| It was a lot of fun, you tend to develop strategies and the game
| has a simple, efficient UX. Fair warning, it is very time
| consuming.
|
| [0] https://apps.apple.com/fr/app/tchisla-number-
| puzzle/id110062...
| TZubiri wrote:
| I think I saw this one on an ancient arab math problems book. But
| it may be apocryphal, not sure how many tools they would have
| had, factorial symbols?
|
| At any rate they invented algebra so maybe there's something to
| it
|
| Edit: It was the man who counted, definitely apocryphal, as it
| was written in the 20th century
___________________________________________________________________
(page generated 2025-02-23 23:00 UTC)