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.
+, - (both binary and unary), ×, ÷ 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?
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
Though I also think square root is cheating, it has an implicit 2 inside of it, where as raising to the power of 2 and log 2 are explicit.
You could also argue for only infix operators.
A good game must be somewhat challenging or else it is not really a game. Anything that makes the game trivial ought be omitted for it to be a game.
If I think of a competition, then I'd expect the rules to be determined ahead of time according to some pre-imagined criteria. If someone manages to find a clever hack within the rules that allows for trivial "breaks", then that's good for them and they just get to beat everyone else at it.
But if I think of a game, then it's much more natural for the rules to adapt over time as people realise that some types of "play" make the game less fun, or straight-up boring. They don't have to be self-consistent, or logical. They're essentially arbitrary, and just whatever they need to be to make the game "better".
So perhaps the implied rule is not about it being "reasonable, elemental", but rather about "common" functions and operands (yes, it's still a can of worms, and you'd need to be explicit about what that is).
Well, depends on how you define seldom. What if I told you that twitter would break without the use of Succ()? :-)
> it's still a can of worms
;-)
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.
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.
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.
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?
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.
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.
But you're all missing the point. A winning "solution" to this game is whatever the reader accepts as a legal solution which at the same time is as creative as possible. That's necessarily subjective, but that's fine. Anybody is free to argue that it's a stupid game if these are the rules, and those folks just don't need to play and can let everybody else have some fun!
It's still a fun puzzle, it's just based more on our shared notational conventions as much as the underlying math.
(Mostly goes to show that it's really hard to be precise and allow some mathematical language and disallow some)
Logs would also need to state the base. No implicit use of e or 10, and lg wouldn't be allowed in place of log2.
I haven't said much other than logs and roots are binary operators with one of the operands usually implicit in the notation, so if we don't have special notation for powers and exponentiation, then we shouldn't allow the same for their inverse operations.
Why is it ok to use "22" = 2 * 10^1 + 2 (when it could be a number in base 3 — 2 * 3^1 + 2 = 8 decimal — or any other base)? This implies base 10, just like root implies base 2, or ln means e.
As I said, this is a game, and trying to imply certain artificial constraints will be really hard with how abstract maths is.
Again, mention of successor function is apt: everything else is built from 1, succ() and another axiom, definition or so. So everything else can be reduced to this.
Successor is essentially s(n) = n + 1, so that shouldn't be allowed either.
Successor simply "is" (it's a relation that satisfies a number of conditions), and summation is defined in terms of successor function.
My point is that you can really define everything in terms of these primitive definitions, which means that there won't be any single use of a non-2 digit for any function, or you'll be going with a set of arbitrary allowances.
But the whole point should be: what are those arbitrary constraints that make the game fun? And once you clear that bar, it's ok to open up the next one (this does not make them non-arbitrary though).
Basically, I am saying your take at those arbitrary decisions is not a very fun one ;-)
Letters are symbols used to write down words of a natural language.
If you are unfamiliar with a language, you are more likely to call them "symbols" instead of "letters".
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.
They also say “mathematical tools” not arbitrary functions.
Wonder if someone could come up with general solution within these constraints.
This may be easier to see in a stack machine / RPN model. An expression is a list of operations, drawn from a finite set, each of is either “push the number 2” or something that decreases the stack size by at least 1. And you need exactly 4 pushes. So a valid expression has four pushes and at most 3 other operations, because otherwise the stack would underflow. This gives a finite number of possible expressions, but there are an infinite number of integers, so it can’t work.
Not with only four inputs you can't. You can only have three operations, because you have no way of getting another input parameter.
And yes I think your analysis that only allowing n-ary funcs with n>=2 would make general solution very much impossible since you can only have a limited number of inputs.
A + B = Succ(Succ(Succ(...Succ(A))))
The mathematical root probably first appeared as a square root and was later extended to support other exponents.
But is there any fun in this? As noted elsewhere, the game is in finding the rules, and a solution within those rules.
[]Since all the natural numbers other than 1 are defined using a Succ() functions, there's a trivial solution. But if we only limit ourselves to this most elementary operation, we can't get a 1 because that's an axiom in itself ("There exists 1" or "There is a set of cardinality 1").
A + 0 = A (or A + 1 = Succ(A), if you insist 0∉ℕ)
A + Succ(B) = Succ(A) + B A + 0 = A
A + Succ(B) = Succ(A + B)
Onetwothreefourfive()-2+2-2+22 + 2 + 2 + floor(sqrt(2))
Which feels at least more in the spirit of the challenge than gamma.
BUT I did not use "44", which I did see in some solutions. That seemed out of bounds to me!
It's a little "brain teaser" game, to encourage kids to practice fairly basic math. Don't take it too far out of context.
Maybe. But I doubt many people are aware of such functions, so it's still a fun challenge.
Yeah this feels like those "Implemented XYZ in 1 line"
import XYZ