> TBH Arn and Stax have never been my favourite languages. They seem to be more “how good is the language’s compression?” rather than “how inherently golfy is the language?”
this was said ages ago but I figured it give my 2 cents
Arn is competitive against the languages I measure it against already, I added compression solely so it could be mildly competitive against languages like O5AB1E or Jelly, which feature a larger 1-byte library and seem to have builtins for everything
Try uBlock if you're using Chrome or Firefox or something
xxSH4DYm1ndc0ntr0113Rxx also has a few handy mind-extensions, like a password storage app, a hypnosis app, a truth-telling app, a remote motor control app, etc.
> This post is locked to prevent inappropriate edits to its content. The post looks exactly as it is supposed to look - there are no problems with its content. Please do not flag it for our attention. Never noticed that comment before
@ZippyMagician That was me who said that. My main reasoning is that whenever I see a short Stax answer (I tend not to see a lot of Arn), it's always the same builtins as 05AB1E, Jelly, Husk, etc. but it's 2 bytes shorter because of the compression
Even if it isn't cheating, it feels kinda cheap to me to claim a "win" (same thing as flags), which some people do, when your program is only shorter because your compression engine is better (or even, you have one), rather than your golfing being better
i'm working on the beginnings of a golfing language since i haven't actually made a legit attempt at one before; do i keep my flags or should i remove them to appease caird :p
I feel the same way (but less so) when 05AB1E beats Jelly because prime factorisation or something similar is one byte in 05AB1E and 2 in Jelly. You're not winning cause your solution is more clever, you're winning because the language you chose is smaller for that specific task
And how I can consider a Python solution to "win", even if the same thing in Jelly is 10x smaller. The Python solution found the clever way of doing it
I think we're in a reasonable position. Languages can make smart use of flags to save on common operations that are required for a lot of challenges, but so long as they're not just moving all of the solution into flags instead of actual code, it's not that cheat-y :P
I agree with Redwolf; having to handle I/O in the language is kind of annoying and using flags to get the format into something your language is actually capable of working with makes sense
like for example a flag to format the output as a grid instead of having G in jelly (which I think is kinda a waste of a one-byte atom, but that's just IMHO)
for example, adding -i changed my program from 1 1{#+}-> with -al to 1 1{#,+ with -ai (cant remember which problem this was from, and the commas because the first was written in the buggy js interpreter)
yeah STDIO commands being one byte is just a waste cuz they're hardly ever used, and if you need STDIO in jelly, you're likely already going to lose to 05AB1E
I'm probably going to add a -e flag to interpret the input as a code in order to fix some issues with type coersion. So instead of "first second" it would be "[first second]" to tell Arn it is an array, not a string that should be cast to an array which can cause issues
Okay, Ash's new string compression system will be able to represent common words in around two bytes, and fairly common ones in around three. No word in the dictionary, even the most obscure, with a trailing , , will take more than four bytes.
(It's four bits of overhead for a dictionary word, plus two bits if you want a trailing , or all uppercase, then between 14 and 26 bits for the word itself)
That's not in my dictionary, so it'd be however many bytes it normally is (although some substrings might be replacable with words, and some letters are only 6 bits)
Yeah probably not in that, but if the word was something like nocturnal (which is in the dictionary anyway but bear with me) you could replace turn with the word turn, which is just over two bytes
Some context: Ash's string dictionaries have a two or four bit prefix. If it's 00, the word is lower case. If it's 01, it's lower case with a space. The 11 prefix is reserved. I can't decide if it'd be more useful for 10 to be title case, or title case followed by a space (either way, the other one would still be available as a four bit prefix)
