@RadvylfPrograms With my CMC, I mainly added the tag to make it clear that there are many different ways of fitting the criterion "allocate memory indefinitely".
"Many different ways of fitting the criterion" applies to basically any challenge involving slightly nonstandard I/O or randomness or anything like that
@pxeger Not really
Any behavior which does can be summed up as "using up infinite memory"
Just different approaches to doing that
Whereas with something like "write a function that gives you an even number based on the input", as silly of an example as it is, you can clearly see different behavior in different answers
They can perform entirely different tasks, one might be "nth prime number times two" while another could just be "return 2" and another could be "double the input". You have a very observable, very clear difference not just in how a task is being done, but in what the tasks are.
A better example might be, given an integer, return a unique positive integer
There are a zillion ways you can do that, which map them differently
@RadvylfPrograms You can clearly see differing memory usage patterns by looking at a graph of it or whatever. For my question, the output arguably is the memory usage, since that's what matters to solve the challenge, and the memory usage is what is being validated to be allowed to answer the challenge.
But you have to completely grasp at straws to find something "open ended" in the challenge, or anything close to a "function". The tag just doesn't apply unless you do some olympic level mental gymnastics.
@RadvylfPrograms Please do. I think this is my best argument: the open-endedness concerns not exactly an output value, but a resulting observable behaviour, which can still be modelled as a function if you try hard enough.
So therefore I think the "function" part of "open-ended-function" is not what's relevant. The open-endedness is.
Yeah, it's just a linearly growing function. Like, the only difference would be how fast it grows, which depends way more on your computer and what else it's doing than the actual program you write.
@WheatWizard "the observable behaviour is still the same" in the same sense that, if you look at the "observable behaviour" of a Hello World answer as "produce a write syscall", then a Hello World answer and a Fizz Buzz answer have the "same" observable effect
We don't need a tag that's for challenges you can do with varying approaches, since you can sort of do that with pretty much any challenge, and that would be a bad tag. I like the open ended function tag because it fits a specific, and IMO, interesting class of challenges, and to me it feels like you're just taking advantage of some necessarily vague wording to overload onto it whatever you feel like.
If timing information is what makes it open ended, then every challenge that doesn't require specific timing is open ended.
Like I can choose to print hello world as slow as I want, but that's not being observed as part of the challenge, so the freedom to do that is irrelevant.
And the same for this, timing isn't a part of the question statement, so the freedom to choose a speed is irrelevant.
@RadvylfPrograms It must be only at least linear; you can have a program of exponentially increasing memory use. It doesn't matter if it repeatedly allocates 1 more byte of memory, or repeatedly doubles the amount of memory it uses; but those are both different behaviours
(Apart from the fact that memory allocation probably isn't O(1), which I didn't think about when adding the tag, but that won't make a huge difference)
@RadvylfPrograms If you think I'm "taking advantage", I have no further interest in arguing with you. At worst, I'm mistaken.
@RadvylfPrograms Well what's the difference? Instead of reading STDOUT to check it's a sequence with that property, I read the memory graph on Task Manager.
Because it's not an interesting challenge without the memory part. The task isn't the function that grows faster than linearly, it's the allocating memory part.
I mean part of the issue, is that you aren't going to be allocating memory faster than linear, that would be somewhere between impossible and extremely inconvenient.
@pxeger Exactly. The part about making it linear/more than linear is just a natural consequence of infinitely consuming memory, not a part of the challenge itself.
If the challenge were "allocate memory at a rate that's not O(n)" I'd be tempted to say that's open ended. Since the rate you allocate is actually a meaningful choice.
I guess my argument is this: The main point of the challenge is infinitely allocating memory. There's a few rules about how quickly you have to do it, but that's the main point. That in itself is not an open ended function, and while you can really stretch to find part of it that fits the tag, it just isn't useful to tag it in that way. You could make an argument for all sorts of tags going on any given challenge, but it just annoys people who expect a different type of challenge under that tag.
@WheatWizard I'm not completely sure how that's equivalent to "lowest number wins", but I understand what you're saying - chat.stackexchange.com/transcript/message/61414852#61414852. But I think it's not so different to O(1), therefore it's still possible to consume memory exponentially, which will run out of memory in practice, before it stops being exponential in practice.
The point of tags is, after all, searching, and if a challenge isn't what I'm expecting to find under a tag, it shouldn't be under that tag unless it's expanding the genre in an interesting way which still fits the tag's original intent (which is rare, like the asymmetric KotHs).
Something like "A challenge with this tag will ask for answers to write a function which performs no task in particular, but which satisfies a certain pattern"?
That way it's emphasized that: 1. The function's specific inputs/outputs is what's open ended, not its side effects, I/O, or implementation details 2. The function can do one of any number of different things
I don't think my wording is as precise as it could be, but those two things are important to make clear I think
ah ive got an idea which might put it into impossible instead :P
ok no its definitely not impossible, but idk if its trivial either
sadly though i think its also uninteresting: write a function which takes an integer of class n and outputs a different integer of class n. there must be infinitely many integer classes and each must have infinitely many members
In this question I defined a "chain" function as a function that:
is a permutation, meaning that every value maps to and is mapped to by exactly one value.
and allows any value can be obtained from any other value by repeated applications of the function or its inverse.
There are a lot of fun...
Seems like it's just copy-pasting from the internet made more convenient
I doubt people who previously made sure to write everything themselves and/or carefully ensure stuff they copy is done right are the sort that would misuse/overly rely on copilot
@forest well in order to get anything remotely close to what you want, you really need to give it good prompts, so you'd already have specified pretty much what you want it to do
What's the point of being concerned about your own preferences? You can change your own, and then there'd be nothing to complain about! But if you complain about other people's preferences... you get to complain endlessly. It's a win-win!
Like in theory, yes, copilot could write entire functions for you. In reality, it's only useful for boilerplate and small context inferences that you would have otherwise written yourself
In this question I defined a "chain" function as a function that:
is a permutation, meaning that every value maps to and is mapped to by exactly one value.
and allows any value can be obtained from any other value by repeated applications of the function or its inverse.
There are a lot of fun...
