12
\$\begingroup\$

Author's note: This is a meta post tagged with . The goal of this post it to create a community-wiki for Code-Bowling. Please post suggestions / concerns as answers and feel free to utilize the comments section on this post as well as on answers to discuss the topics at hand. (For extensive discussions consider using chat). This index is best used when sorting answers by active so you can see the current issues-at-hand being discussed.


Code Bowling

is a challenge similar to except the objective is to solve a problem in the most bytes/characters possible (or highest complexity).

Fluffing up code to contain many bytes isn't that impressive or challenging so the fun in Code Bowling challenges typically stems from the limitations, obstacles, and penalties defined in a challenge's scoring system and/or rules. (Refer to section: Common Scoring Metrics and Challenge Styles)

Most Code Bowling challenges posted to this site are [closed] for a variety of reasons, including an obvious ability of exploitation, lack of a defined scoring system, vague rules, "too broad", and many other reasons. Due to this, Code-Bowling challenges are rarely created and if they are they are usually poorly received. (Relevant: Meta/Should we kill code-bowling?)

The goal of this index is to help create a reference for Code-Bowlers that defines what is allowed and what is not allowed (standard loopholes and more), what is encouraged and discouraged, common scoring systems that can be used (along with automated scoring tools), and various other resources that will be helpful in not only creating code bowling questions, but also in properly answering them.


This post has been broken-down and organized into 5 sections:
  Common Rules • Common Scoring Metrics • Best Practices • FAQ • Useful Tools





Common Rules (Rev. 1.0.0)

These are some objective rule-criterion that can be used in your challenge to limit a scope of answers and avoid being closed for too broad. Not all of these rules will be compatible with your challenge-type / scoring-system. Select a few you wish you include by copy pasting them into your challenge.

Please copy-paste the following into your Code-Bowling challenges:
*This challenge is using some rules from <a href="https://codegolf.meta.stackexchange.com/questions/11737/code-bowling-index">Code-Bowling: Common Rules, Revision 1.0.0</a>*

  1. Character : Byte Ratio
    In Code-Bowling a character-count is preferred over a byte-count. The obvious reasoning for this is that multi-byte unicode characters (e.g. 🁴) can be used in place of single-byte unicode characters to fluff up byte count and will make bowling more about who renames the most variables with high-byte unicode characters rather than who most strategically creates meaningful complex code. (See Useful tools section at end for character-counting widget)

  2. Variable/Function/Object Names
    All variable names (or object pointers, function names, etc) should be 1 character long. The only acceptable time to use 2-character variables names is after all possible 1-character variables have been used. The only acceptable time to use 3-character variables names is after all possible 2-character variables have been used. Etc.

  3. Non-simplified Arithmetic
    All arithmetic should be in simplified form unless there is a justifiable reason for doing otherwise (e.g. circumventing penalties defined in the scoring system of the challenge (In which case you still must use the smallest possible alternative form)). Finding the simplified form of any equation (as well as a list of small alternative forms) is easy to do using Wolfram|Alpha. (See Useful tools section at end)

  4. Un-used Code
    All code must be used. Meaning the program must fail to always properly complete the task if any individual character (or varying set(s) of characters) is/are removed. Naturally, a subset of the program should not be able complete the task on its own without the rest of the program.

  5. Line-breaks and White-space
    Unless necessary for code function or otherwise specified by the challenge, all line-breaks and white-space should be removed from code before scoring by counting characters.

  6. Comments
    Comments are not permitted towards character-count, unless somehow utilized by your program/function.

Revision History: (Utilizes archive.org)
Revision 1.0.0 - Mar 14 2017
Revision 0.0.2 - Mar 12 2017
Revision 0.0.1 - Mar 11 2017





Common Scoring Metrics and Challenge Styles

Code-Bowling challenges that are simply just to find the largest solution to a problem are often ambiguous and broad (and therefor will get close votes for being too-broad). These also often result in uncreative ∞-byte answers.

Most code-bowling challenges can be made more challenging, fun, and narrow by applying various limitations and penalties so that the solutions will have a theoretical maximum score (typically 4-figures or less in character-count).

(For Challenge types that place limitations on source code, please include that tag in your challenge/question.)

  • Pangram Challenges

    A pangram is a sentence that uses every letter at least once. (The quick brown fox jumps over the lazy dog).

    These types of challenges have scoring systems designed where a perfect pangram would achieve the theoretical maximum score (though you are not required to use every character at least once.) Additionally, using any character more than once will start incurring a penalty.

    These challenges typically expand to more than just [A-Z] by including numbers and sometimes symbols in their scoring metrics.

    Here is an example of a simple pangram scoring system (with an online scoring tool). (See Useful tools section at end):

    1. Each character used increases your score by 1 point.

    2. Any repeated character decreases your score by 1 point. That is, they do not count towards character total.

    Here is another example of a more complex pangram scoring system (with an online scoring tool). (See Useful tools section at end):

        1. Each character used increases your score by 1.

        2. Repeated use of any alphanumeric character (a-z, A-Z, 0-9) will result in a deduction of 3 points per repeat (first use does not result in a deduction).

        3. Repeated use of basic punctuation ([!?.-,":';]) - including the brackets - will result in a deduction of 2 points per repeat.

        4. Repeated use of other ASCII characters {`~@#$%^&*_+=|\/><} - including the curly brackets - will result in a deduction of 4 points per repeat.

        5. Use of spaces, tabs, and newlines will result in a deduction of 1 point per use. That is, they do not count towards character total.

        6. Characters not mentioned above (Exotic Characters) will result in a deduction of 1 point per use. That is, they do not count towards character total.

  • WPM Challenges

    (Note: this challenge type is contested and might not be defined within the scope of CodeGolf.SE)
    WPM (Words Per Minute) is a common measure/metric of one's typing speed.

    WPM challenges include a time limit on typing your code and require you to upload a video of you typing your code (with a visible time signature).

    Typically these challenges will have a 1-minute time limit and you must type your code in or under said time limit. Any code that was not able to be finished during that time will typically deduct 1 character from your score's total.

    Good practice dictates that your video should show your fingers visibly typing on the keyboard along with a physical clock or timer, though digital-online stop-watches are acceptable too as long as they are visible and standard (See Useful tools section at end)

  • Rectangular Challenges

    These are challenges where the source code has to be formatted to be in the shape of a rectangle. Line breaks do count towards character count in these challenges.

    The dimensions (w:h) of the rectangle must be in the range of (2h:h) to (w:2w). So a rectangle of 6 lines of code, each containing 11 characters (6x11) would be valid. But a rectangle of 2 lines of code, each containing 20 characters (2x20) would not be valid. (Naturally, all lines must contain the same number of characters)

    Each line of code must be distinct to a certain threshold. Distinctness is typically calculated using the Levenshtein distance. The threshold may change from challenge to challenge but a typical distinctness threshold is 85%, where the Levenshtein distance between any two lines must be greater than or equal to 0.85*w, where w is the number of characters used in a line of your rectangle.

    Penalties may be added for failing to meet the distinctness threshold, or it may just be listed as a requirement and code that does not meet the threshold is invalid.

    Including a Levenshtein distance calculator in your challenge is good practice. (See Useful tools section at end)





Best Practices

There are many things that can be done in Code-Bowling that, while technically permitted, are frowned upon and will likely result in down-votes. There are also many good things you can do that will be smiled upon and likely result in up-votes. In this section you can find a list of practices that should, in most common cases, be avoided, as well as a list of practices that, in most cases, should be encouraged.

  1. Purposefully Overly-Verbose Languages
    Languages that require a ton of characters on purpose are usually frowned upon in code-bowling. Many challenges might not even really allow these to stand a chance in competing due to the penalties and limitations defined in the challenge. Examples of Overly-Verbose Languages include (but are not limited to):
    ArnoldC
    SPL (Shakespeare Programming Language)
    LOLCode
    • Any other wordy esoteric languages (likely somewhere on this list)

  2. Code That is Too Long to Post
    If your code is too long to post, it is good practice to post it on a text sharing site and then post the link to your code. Hastebin and Pastebin are good resources for this. (See Useful tools section at end)

    If your code is so big that it was not hand-typed it is recommended that you also share your generating function that created the code.

  3. Online IDEs
    It is good practice and courtesy to post a link to an online IDE that is running your code so that others may execute it and see for themselves, as well as tweak your code to potentially help you increase your score. (See Useful tools section at end)

  4. Vague (unenforceable) Rules
    Do not add rules that have no clear measuring objective or systematic ruling system, for example a rule like "All code must be useful". Rules like this are unenforceable and likely to get your question [closed]. All rules should be defined in a way where they could theoretically be enforced with an automated algorithm; so NO SUBJECTIVE RULES.

  5. Bogus Code
    Bogus code (that is added obviously just to fluff up character-count) should be avoided, unless utilizing them for good reason (e.g. to avoid penalties defined in the scoring system). Utilizing bogus code will often result in down-votes from viewers. Common examples of bogus code to avoid are as follows:

    a) Duplicating Variables
    Adding an extra variable for no reason except to increase the number of variables used. For example changing a=5; a++; to something like a=5; b=a; b++;

    b) Significant-Figures Abuse
    Adding extra degrees of accuracy to an object with no real reason to do so
    For example changing f = 3; to something like f = 3.00000000000;.

    c) Literals Abuse
    Adding extra content (typically to literal types) that is un-needed and typically immediately discarded.
    E.g. changing i = 2; to i = numberOfCharacters("abcdefghijklmnopqrstuvwxyz")-24;
    or changing s = "hello"; to s = "hellooooo"[0-4];.





FAQ

Frequently Asked Questions:

This section will be created as questions are asked and answered.





Useful Tools

  1. Character Counting Widget — MotherEff.in, ETHProductions
    This is useful for determining the number of characters used in your application. In Code-Bowling a character count scoring system is favored over a byte count scoring system. (See Rule #1)

  2. Arithmetic/Equation Simplifier — Wolfram|Alpha
    This is useful for simplifying your equations. Input an equation (e.g. x+x+x+x) and it will output the simplified forms (e.g. 4*x) (See Rule #3)

  3. Text Sharing Sites — HasteBin, PasteBin
    These are useful tools for sharing code that is too big to post on the site. (See Best Practices #2)

  4. Online IDEs — Try It Online!, JSFiddle, SE Snippets
    These are useful for allowing others to easily execute your code online and modify it. Try It Online! is useful for most programming languages. JSFiddle is useful for HTML/CSS/Javascript/etc but these can also be executed natively in StackExchange's Code Snippets (See Best Practices #3)

  5. Pangram Scoring Tools — Example 1 (simple), Example 2 (complex)
    These are two automated score calculating tools for common Pangram scoring metric variations (See Common Scoring Metrics #1)

  6. Digital Online Stop-Watch — Online-Stopwatch
    This is an online stop-watch useful for time based typing challenges (WPM Challenges). (See Common Scoring Metrics #2)

  7. Levenshtein distance calculator — PlanetCalc
    This is a Levenshtein distance calculator useful for quantifying the changes made between two lines of code. (See Common Scoring Metrics #3)

\$\endgroup\$
  • 7
    \$\begingroup\$ This is a great post! I believe this is a huge step to making on-topic code bowling questions. I however have a problem with a certain scoring metric: WPM Challenges. This type of challenge is most likely out of scope for this site, as it requires a video of one's typing. Further, it has nothing to do with the skill of the golfer and gives an edge to people with higher WPM/memorization skills. \$\endgroup\$ – Conor O'Brien Mar 11 '17 at 19:16
  • \$\begingroup\$ @ConorO'Brien Thank you Conor! I agree there could be some issues with WPM challenges; I will be finalizing the first revision of this post in less than 72 hours, for now I'll leave it in just to get some feedback from others, if a few people are thinking it could be an issue I'll edit it out in the final revision. Mainly I just wanted to have at least 3 challenge types to launch this post with so that's why it's in there. Can you add that comment as an answer to this post so it can be discussed more visibly? \$\endgroup\$ – Albert Renshaw Mar 11 '17 at 19:17
  • \$\begingroup\$ "Meaning the program must fail to always properly complete the task if any individual character (or varying set of characters) is/are removed." What if you had code like a=12 where any one of the digits 1 or 2 are removed? \$\endgroup\$ – Kritixi Lithos Mar 11 '17 at 19:18
  • 1
    \$\begingroup\$ @KritixiLithos If they can be removed and the entire program will still function properly for all possible inputs, then I would argue that it is breaking Rule 4. \$\endgroup\$ – Albert Renshaw Mar 11 '17 at 19:20
  • 2
    \$\begingroup\$ I'm not clear what the success case looks like here. What flavor of interesting bowling techniques are you hoping to see once the boring ones are ruled out? Perhaps you could link to some examples of code bowling submissions you consider model examples. \$\endgroup\$ – xnor Mar 12 '17 at 8:34
  • 1
    \$\begingroup\$ We can all agree that the king of the verbose languages list, is Whitespace \$\endgroup\$ – Matthew Roh Mar 12 '17 at 9:01
  • \$\begingroup\$ @Matthew, I think Chicken might give it a run for its money. \$\endgroup\$ – Peter Taylor Mar 13 '17 at 6:50
  • \$\begingroup\$ @PeterTaylor Ah, yes, Chicken is long too, but let's exclude simple BF derivatives from the list. \$\endgroup\$ – Matthew Roh Mar 13 '17 at 7:09
  • \$\begingroup\$ This is a better byte/character counter: ethproductions.github.io/bytes. Select the "--------" encoding for characters. \$\endgroup\$ – mbomb007 Mar 14 '17 at 13:49
  • 1
    \$\begingroup\$ I'm pleased to see my ruleset from "Hello World With A Twist" has been viewed as a good basis for pangram-like bowling. \$\endgroup\$ – Glen O Mar 14 '17 at 15:56
  • \$\begingroup\$ @GlenO Yes! That was my favorite example of Code-Bowling I found during my research! I originally had Titus credited with his JSFiddle for scoring too but many changes have had to be made sense then and I didn't want to link his name to my potentially buggy code ahaha \$\endgroup\$ – Albert Renshaw Mar 14 '17 at 16:04
  • \$\begingroup\$ @mbomb007 Added, thanks! \$\endgroup\$ – Albert Renshaw Mar 14 '17 at 16:05
  • \$\begingroup\$ @AlbertRenshaw major problem the levenshtein distance calculator counts newlines as spaces according to Ethproductions \$\endgroup\$ – Christopher Mar 16 '17 at 1:16
  • \$\begingroup\$ @DownChristopher do you have a better tool I can add in there? \$\endgroup\$ – Albert Renshaw Mar 16 '17 at 2:30
  • \$\begingroup\$ 4 probably covers 6. \$\endgroup\$ – CalculatorFeline Jun 20 '17 at 22:45
13
\$\begingroup\$

There are a couple of problems I see:

  1. Variable Name Length. This is a non-observable requirement. The post doesn't say that challenges can't include them, but when we get to esoteric languages it can become really hard to define what a variable name is. For example, say my language doesn't have traditional variables, but rather stores everything in a massive array. What if I store it to key "longVariableName"? Or if I store it at position 10000?
  2. Non-simplified Arithmetic is even harder to define in an objective way. For example, lets say, instead of typing in 1, I did X/X. Wolfram Alpha says "1 (for x != 0)". If you argue that X/X has to be simplified, what if my program had logic that depended on X/X throwing an error when X is 0?
  3. Purposefully Overly-Verbose Languages. You argue that such languages are frowned upon. I disagree. To frown upon verbose languages is to frown upon golfing languages on challenges. While there are many that don't like them, the majority of our users have learned to pick the right language for the job.
  4. Vague (unenforceable) Rules: Actually, "All code must be useful" is actually a pretty easy thing to enforce. You've shown how its enforced: If that code can be removed and the program still runs correctly, then its unused. You literally posted that above.
  5. Bogus code: This is more non-observable stuff. Furthermore the threat of downvotes doesn't really work if its going to produce the winning submission.

Now, I'd like to take a look at your Challenge Styles section. I think your introductory sentence is revealing: "Code-Bowling challenges that are simply just to find the largest solution to a problem are often ambiguous and broad".

is about representing stuff using as little data as possible. When you think about it this way, it becomes obvious that representing something with as much data as possible isn't a challenge at all. It's rather revealing that the example challenges you posted don't pose a challenge from the bowling aspect, but from the other restrictions.

I'd personally argue that for a challenge to work, it'd be so mangled it wouldn't be a challenge anymore.

\$\endgroup\$
  • 1
    \$\begingroup\$ I'd like to note that I think that code-bowling as a concept is fundamentally flawed. However, I don't believe the tag should go away, because there is potentially challenges with a different "concept" that is naturally scored by code-bowling The pangram challenge is a good example. \$\endgroup\$ – Nathan Merrill Mar 12 '17 at 5:00
  • \$\begingroup\$ Thanks for your input! #1 is a good point, I hope in time to beef out the definitions in this index to cover most cases (especially esoteric languages). For #2 I do specify in that rule "unless there is a justifiable reason for doing so". #3 is correct, I may amend that by the time I finalize the first version of this post in a few days. #4 needs a better example of a vague rule, I'll yield. #5 is non-observable so I moved it into the best-practices section, it was originally in rules but I realized it wasn't fitting. My hope is that it's a deterrent even though it's still permissible. \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 5:19
  • \$\begingroup\$ My main issue w/ esoterics is you can't create an esoteric language to solve any programming problem in near-zero bytes, but you can easily create an esoteric language to solve any programming problem in near-infinite bytes. Consider a language where any conditional logic is a 1,000,000,000 byte command. \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 7:37
  • \$\begingroup\$ Re your point 4, "All code must be useful" isn't the same as "All code must be used". It's true that the "Can I delete it?" test goes beyond merely "Is it used?", but it doesn't go as far as "Is it useful?" Consider the architecture astronaut parodies which (as I remember it) were the original inspiration for code bowling. I can make a WidgetFactory (and possibly even a WidgetFactoryFactoryFactory) such that if it's deleted then everything breaks, and due to clever abuse of visibility it's not possible to delete more code and regain the ability to create a Widget. \$\endgroup\$ – Peter Taylor Mar 12 '17 at 7:50
  • 1
    \$\begingroup\$ @AlbertRenshaw and that my friend, is why I believe that that code-bowling as a concept is fundamentally broken. \$\endgroup\$ – Nathan Merrill Mar 13 '17 at 13:27
  • \$\begingroup\$ @PeterTaylor I mean, then what is a definition of "useful"? Fundamentally, if the code isn't golfed, then there's "un-useful" code, yes? \$\endgroup\$ – Nathan Merrill Mar 13 '17 at 13:28
  • \$\begingroup\$ If xyzzy can be golfed to@ then by the "Can I delete it?" criterion it is already golfed. But does it have unuseful code? I think it's subjective. Certainly when you start talking about factories and singletons you get into situations where usefulness depends on the context. \$\endgroup\$ – Peter Taylor Mar 13 '17 at 13:43
  • \$\begingroup\$ Code Bowling isn't "fundamentally broken" as a concept - what was broken was the lack of firm rules and restrictions that prevent unbounded solutions. Many techniques can be used to prevent esoteric languages being created in such a way - for example, counting all commands/functions/whateveryouwanttocallthem as single characters (so "cos(x)" would be equivalent to "c(x)" irrespective of how the "cos" function is named). \$\endgroup\$ – Glen O Mar 14 '17 at 16:07
  • \$\begingroup\$ For a strong example, no esoteric language would succeed consistently at all of the "pangram-style" challenges, where you're punished for using too many of the same character and are restricted to ASCII. \$\endgroup\$ – Glen O Mar 14 '17 at 16:09
  • \$\begingroup\$ @GlenO, calling the pangram challenge style "code bowling" is stretching the term considerably. \$\endgroup\$ – Peter Taylor Mar 14 '17 at 16:25
  • \$\begingroup\$ @PeterTaylor - I don't see how, considering that the aim is to have the largest score, where the primary scoring mechanism is a count of the number of characters. Keep in mind, in actual bowling, you don't just get to keep throwing balls as long as you want, there are restrictions that put the maximum score at 300. Code bowling is similar, when done right. (unless you mean pangram challenges in general, rather than the category of code bowling challenges mentioned above) \$\endgroup\$ – Glen O Mar 14 '17 at 16:27
  • \$\begingroup\$ @GlenO The distinction here is "conceptually" vs "as a scoring method". I think scoring by number of characters maximum wins is totally fine. However, the concept of "represent some information in as many bytes as possible" is broken. \$\endgroup\$ – Nathan Merrill Mar 14 '17 at 16:51
  • \$\begingroup\$ @NathanMerrill - I would argue that the problem lies in the conceptualisation that you are using, rather than the inherent concept. Code Golf emulates real golf, in that you aim to minimise the number of "actions" necessary to achieve the goal. Code Bowling similarly should emulate real bowling, which comes with an inherent maximum score. Your alternate conception is more like "Code Javelin", where the goal is to go as far as possible, and the only limitation is human physical capability. \$\endgroup\$ – Glen O Mar 15 '17 at 6:59
  • \$\begingroup\$ Right. Now we are just arguing what terms means. For my purpose, though, I prefer the term "concept" :) \$\endgroup\$ – Nathan Merrill Mar 15 '17 at 12:07
7
\$\begingroup\$

Non-simplified Arithmetic
All arithmetic should be in simplified form unless there is a justifiable reason for doing otherwise...

...

Vague (unenforceable) Rules
Do not add rules that have no clear measuring objective or systematic ruling system, for example a rule like "All code must be useful"... All rules should be defined in a way where they could theoretically be enforced with an automated algorithm; so NO SUBJECTIVE RULES.

I see a tension. There's no way to automatically enforce a test for whether a reason is justifiable or not. In particular, if I claim "doing it this way is better for number-analytic reasons" then I may be wrong. No algorithm is going to perfectly verify that, and I doubt that most users of the site can either.

I also don't think there's a way to automatically check whether arithmetic is in simplified form - a single expression can be fed into Wolfram Alpha and rejected if it claims a different simplification, but an expression can also be broken up and mangled to be nearly unrecognisable. Undecidability also rears its head: see Rice's theorem.

\$\endgroup\$
  • \$\begingroup\$ Perhaps a better wording is, you must used the reduced form with the least number of bytes, unless you need to use a different form to avoid a penalty defined in the challenge scoring system, in which case you must use the smallest form to avoid that penalty. Wolfram|Alpha has a alternate forms tool too which is nice. The main thing I'm trying to prevent here is people saying 1+1+1+1+1+1+1-1-1-1-1... (infinite characters) instead of just 0. Reduction is a common thing in math but I'm not sure if there is an algorithmic approach to reduction so it does get a little tricky. \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 17:47
  • \$\begingroup\$ There seems to exist an explicit set of rules for reduction (webwork.maa.org/wiki/…) Although in that resource I'm not seeing anything for reducing series like I stated in my above comment, that is a+a -> 2*a, etc. \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 17:50
  • \$\begingroup\$ There are also some issues with these reduction rules when it comes to programming, for example the rule 0/x -> 0 as another user pointed out on this site, the program may rely on it breaking when dividing by zero, whereas this reduction rule cancels that out (also this above example is a crazy "rule" in my opinion because you can't just remove option that in math). Perhaps I will need to make a list of reduction rules for Code Bowling so that it can be algorithmically checked. \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 17:54
  • \$\begingroup\$ I'm realizing the rule could limit creative answers. Example, in pangram challenge (referenced in main post) which has a theoretical maximum score, I could try to utilize every digit by representing 5 as 2+3. That's an acceptably thing I'd say, however it breaks the arithmetic rule. The pangram challenge itself which punishes repeating characters would already satisfy the infinite series issue of arithmetic simplification (e.g. 1+1+1+1...-1-1-1). Perhaps the "Standard Rules" section should be changed to "Common Rules" and the challenger selects which rules they want to use (copy paste) \$\endgroup\$ – Albert Renshaw Mar 12 '17 at 19:44
  • \$\begingroup\$ @AlbertRenshaw, 1+1+1+1+1+1+1-1-1-1-1... is covered by "the program must fail to always properly complete the task if any individual character (or varying set of characters) is/are removed". \$\endgroup\$ – Peter Taylor Mar 13 '17 at 12:36
  • \$\begingroup\$ Hmmm, can be modified to something like: 1+2+3+4+5-15 (or larger) \$\endgroup\$ – Albert Renshaw Mar 13 '17 at 17:12
  • \$\begingroup\$ How about "mathematical expressions must be golfed"? In other words, if in your language "a+a+a" is mathematically the same as "3*a", then you have to write it as "3*a". A language without a multiplication operator obviously would have to use "a+a+a" instead. But if your code relies on "0/x" tripping an error, then golfing it down breaks the code, and thus "0/x" is permissible in this situation. \$\endgroup\$ – Glen O Mar 14 '17 at 16:14
  • \$\begingroup\$ Obviously, it's possible that the person pointing out the expression isn't aware of a shorter way to express it... others pointing out the shorter way to write it in comments should be encouraged in such situations (and who knows, it might even inspire new code golf challenges...) \$\endgroup\$ – Glen O Mar 14 '17 at 16:16
5
\$\begingroup\$

Ok, I don't think I was clear with my last answer, so I hope to make a post to make this clear:

Code bowling (conceptually) doesn't work.

Are you familiar with Sudoku? You know, that awesome puzzle where you try to fill in as many squares as possible?

Let's say I made a challenge where your code had to be arranged like a Sudoku puzzle:

  1. It has to fit in a 9x9 grid
  2. You could only use 9 different characters
  3. Each row and column can't have the same character twice.
  4. An empty spot (a space) counts as 0 characters.
  5. Scored by total number of characters, maximum wins.

This could actually be an interesting challenge. I'd also put a tag on it.

The problem is that this really isn't a code-bowling challenge. It's a challenge that happens to be scored by maximum number of characters. We simply have the tag to make "scored by maximum number of characters" easy to communicate.

is about transmitting as much information in as little space as possible

This is a problem that people everywhere are solving. It's why we gzip our html, or why downloads come in a tar file. This is why general-purpose golfing languages are interesting. They are trying to ensure that it can do as many tasks as possible with as little code as possible.

Transmitting as much information in as much space as possible doesn't make sense

Of course you can do it. This is why challenges are littered with loophole-patches. These "patches" become the real challenge in a similar way that my sudoku-board was the real challenge.

Therefore, don't try and take a challenge and modify it to make it interesting. Simply come up with interesting concepts, and if it happens to be naturally scored by maximum characters, put that tag on it.

\$\endgroup\$
  • \$\begingroup\$ I get what you're saying but there is a real issue with code-bowling challenges in that they are almost always too broad, lack any rules that help narrows the scoring system, sometimes even lack a clear scoring system, and are therefor often [closed] or put [on hold]. The goal of this index is to help create a list of resources for preventing that from happening in the future to challenges like the Sudoku one you suggested. This site already has Standard Loopholes for example but most everything is designed with Code-Golf in mind. At the time of posting this 1/2 of all bowling Qs are closed \$\endgroup\$ – Albert Renshaw Mar 21 '17 at 5:03
  • \$\begingroup\$ For example I had the idea for seeing who could output "Code Bowling" in the most number of characters, but without a real scoring system that challenge would have failed almost immediately or been closed as too broad. Thanks to this index I was able to copy paste in the pangram scoring system on it and the challenge worked great. Within 1 day that post became the highest up-voted code-bowling challenge of all time. The second most voted code-bowling challenge is almost identical but was closed for being too-broad. I'm confident had this index existed then, that wouldnt have happened \$\endgroup\$ – Albert Renshaw Mar 21 '17 at 5:05
  • \$\begingroup\$ @AlbertRenshaw I still feel like the process of "Let's make a code-bowling challenge" will produce lower quality challenges than "Let's make a challenge" that happens to end up being a code-bowling challenge. Even though your pangram challenge wasn't closed (it nearly was), it still had some gaping holes. Not to say they couldn't be patched, but its just a problem that you will always deal with. \$\endgroup\$ – Nathan Merrill Mar 21 '17 at 12:09
  • \$\begingroup\$ Why do you say it nearly was closed? It had not a single vote to close. Also what are the gaping holes? I thought it did fairly well. codegolf.stackexchange.com/q/112827/16513 \$\endgroup\$ – Albert Renshaw Mar 21 '17 at 14:23
  • \$\begingroup\$ I think we are talking about different code bowling challenges. \$\endgroup\$ – Albert Renshaw Mar 21 '17 at 14:54
  • \$\begingroup\$ Yeah, just clicked on the link, I thought you were talking about the one I answered :). The biggest difference between the two challenges is highest score possible. There are lots of languages that don't care about the characters you use, which means that you can get the maximum score (whether that is 94 or 11K) really easily. They both had the same problem IMO, but the second showed the flaw more easily. \$\endgroup\$ – Nathan Merrill Mar 21 '17 at 14:57
  • \$\begingroup\$ I agree they have a flaw, but if patched then I believe pangram-variant of code-bowling becomes very solid and can be used for many challenges with ease (just copy pasting). That's why I've opened this discussion: codegolf.meta.stackexchange.com/a/11817/16513 for patching that issue (¬‿¬) \$\endgroup\$ – Albert Renshaw Mar 21 '17 at 15:01
  • \$\begingroup\$ Even if there is a patch, I'm not really sure that the site would accept more pangram-type challenges. Since the pangram is the challenge, they would be closed as duplicates IMO. \$\endgroup\$ – Nathan Merrill Mar 21 '17 at 15:03
  • \$\begingroup\$ Lets chat :) chat.stackexchange.com/rooms/55760/code-bowling \$\endgroup\$ – Nathan Merrill Mar 21 '17 at 15:05
2
\$\begingroup\$

Preventing infinite-character Answers

Sometimes a challenge can be very well crafted to require some very skillful bowling, but there are a few languages that can easily solve the problem in near-infinite bytes with no real effort, it is hard to exclude these from the challenge in a systematic way.


For example, in my bowling challenge: Rearrangeable Code Bowling you can end up with some really creative solutions that utilize great bowling skill like the following:

MATL: Score 6 — Luis Mendo
CJAM: Score 15 — Martin Ender♦

But then some languages can just as easily post not-so-creative solutions that require no real bowling skill and get a near-infinite score, for example:

Lenguage: Score 1,112,064 — Nathan Merrill
√åı¥®ÏØ¿: Score ∞ — Valyrio Account

While these answers are certainly valid, they don't really go with the spirit of the competition.


Please comment on this answer with any methods, suggestions, or tips you have on creating systematic and concrete rules that can be added to challenges to keep these answers out (if an OP desires to not have answers like that on their challenge, which is reasonable imho)

If some good enough methods are proposed I may edit this into the original post under a new Tips section, or something similar.


Potential Methods:

Will update soon after enough input has been received.

\$\endgroup\$
  • \$\begingroup\$ One possible approach is to define a maximum score that can-not be passed. In the question I posted Rearrangeable Code Bowling one could argue it's reasonable to assume nobody will ever achieve a score higher than 10,000; a rule could possibly be added for "If your answer can be expanded to exceed a score of 10,000 (as potentially pointed out by a commenter), your answer is invalid and must be changed to non-competing"` or deleted. Of course there are some drawbacks with that, like relying on commenters and relying on the answerer to come back online and edit their post. \$\endgroup\$ – Albert Renshaw Mar 20 '17 at 4:39
  • \$\begingroup\$ This simply feels like patching the real problem. That said, let me go and write an interpreter that only accepts input, as long as the input is less than 10,000 bytes. \$\endgroup\$ – Nathan Merrill Mar 21 '17 at 3:38
1
\$\begingroup\$

For pure length comparing, if you can remove some chars make it still work, it's not allowed

x+x+x+x allowed
x+x-x   not allowed as x work
var a,aa,aaa,aaaa
        allowed in this rule, but there may be other ones
numberOfCharacters("abcdefghijklmnopqrstuvwxyz")-24
        not allowed as 2 or numberOfCharacters("ab") work
\$\endgroup\$
  • 1
    \$\begingroup\$ Rule 4 should cover that I believe. \$\endgroup\$ – Albert Renshaw Dec 28 '17 at 8:08
  • \$\begingroup\$ They're same, this is just some example \$\endgroup\$ – l4m2 Dec 28 '17 at 9:43

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .