571
\$\begingroup\$

This "sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to main. This is useful because writing a clear and fully specified challenge on your first try can be difficult, and there is a much better chance of your challenge being well received if you post it in the sandbox first.

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

\$\endgroup\$
2
  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4704 Answers 4704

1
59 60
61
62 63
157
1
\$\begingroup\$

Store a secret

Given a password and a secret,

  • Serve at localhost:8080.
  • If you receive a POST request to / with the parameter p=(...) then check the given password against the fed in password.
    • If it is correct, return a plaintext file with the secret.
    • If it is incorrect, return a 400 error
  • Return 400 for any other requests

Rules

  • No need to salt and hash the password
  • Your server should be able to start in five seconds.
  • Your server must be able to server for at least five hours.
  • Your server must be able to handle at least 20 connections a second at least in theory. Test script:

import requests, random, time
import sys
from string import printable

def gen_string():
    s = ''
    for i in range(random.randint(1, 20)):
        s += random.choice(printable)
    return s

def make_request(str):
    is_child = os.fork()
    if is_child:
        requests.get(str)
        sys.exit()

while True:
    for i in range(20):
        make_request(gen_string())
    time.sleep(0.05)
\$\endgroup\$
1
  • \$\begingroup\$ The spec seems somewhat incomplete to me. It's necessary to read between the lines even to know that the protocol the server is supposed to implement is HTTP. But even having worked that out, it's not clear how much of HTTP should be implemented. What content types must be supported for the POST body? What about encodings? When returning a 400 error, is it sufficient to set the Status header or should it also have a body? \$\endgroup\$ Commented Jan 22, 2017 at 19:16
1
\$\begingroup\$

Exponentiation by squaring

Given an integer x and a non-negative integer n, compute xn using exponentiation by squaring. The key feature of this method is that the time complexity for exponentation can be reduced from Θ(n) using naive exponentiation to Θ(log n) using exponentiation by squaring. There are other names for this method as well as multiple methods which each have an equivalent time complexity. One of them will be explained but feel free to implement the one that is best suited for golfing in your language.

An iterative version is displayed below in Python

def exponentiate(x, n):
    if n == 0:
        return 1
    y = 1
    while n > 1:
        if n % 2 == 0:
            x = x * x
            n = n / 2
        else:
            y = x * y
            x = x * x
            n = (n - 1) / 2
    return x * y

Rules

  • This is so the shortest code wins.
  • Your function or program must have a time complexity of Θ(log n). Keep in mind that only time is restricted, not space.
  • Your function or program must support all inputs which would not result in integer overflow in your language's integer datatype.
  • You are not allowed to use any builtins that perform exponentiation.
\$\endgroup\$
5
  • \$\begingroup\$ I would change the name of your Python function as pow is a built-in function. Also an iterative function calls itself inside the function. The above isn't iterative. Otherwise it looks intriguing. \$\endgroup\$
    – user63571
    Commented Jan 22, 2017 at 17:28
  • \$\begingroup\$ @JackBates Yes, a different name might be better to avoid confusion. I'm not familiar with that definition of iterative. I've usually seen recursive used to describe a function that calls itself. \$\endgroup\$
    – miles
    Commented Jan 22, 2017 at 17:32
  • \$\begingroup\$ @JackBates this isn't codereview.stackexchange.com . And it is iterative - recursion is when the function call itself, iterative is when it's done in a loop instead. \$\endgroup\$
    – FlipTack
    Commented Jan 22, 2017 at 17:40
  • \$\begingroup\$ Sorry about that, got a bit mixed up! \$\endgroup\$
    – user63571
    Commented Jan 22, 2017 at 17:41
  • 1
    \$\begingroup\$ Technically the time complexity for the naïve loop isn't Θ(n) and the time complexity for the improved loop isn't Θ(lg n) because the complexity of a multiplication isn't Θ(1), unless you replace exponentiation with expmod. The rule about integer overflow effectively says that languages which use bounded integer types can do expmod, so on a strict reading this challenge can be answered in C but not in Python. I assume this isn't intentional. The most elegant fix is probably to require polylog time rather than log time. \$\endgroup\$ Commented Jan 22, 2017 at 19:07
1
\$\begingroup\$

Polytope of the pops

In 3 dimensions, there are 5 regular convex polytopes: the platonic solids. enter image description here

In 2 dimensions, there is an infinity of regular convex polytopes: the triangle, the square, the pentagon, the hexagon, etc…

In 4 dimensions, there are 6 such polytopes, and for 5 dimensions or more, only 3 polytopes - check that cool video for more details.

Challenge

Given as input an integer n>=0, return the number of regular convex polytopes in n-dimensional space, or -1 if the number is infinite.

The sequence (A060296) is (starting with 0 dimensions):

1, 1, -1, 5, 6, 3, 3, 3, 3, 3, 3, 3...

Test cases

0 → 1
1 → 1
2 → -1
3 → 5
4 → 6
5 → 3
2017 → 3
\$\endgroup\$
1
\$\begingroup\$

Interpreter chain!

Create an interpreter for the previous submission! The interpreter could take a string, an array of characters, etc.

Your interpreter must be able to identify each command in the input and interpret the commands.

The first answer must print the integers from 1 to 10.

I/O

(We need this because some languages have trouble with arrays of strings)

To chain the answers, we would need a delimiter to separate the code to interpret and the input of the interpreted code. Thus, you may use any single-character delimiter of your choice to separate the two inputs. Your program must be able to separate the two inputs. Your actual input will always be one string.

What if the previous answer is in Mathematica?

You only need to implement the commands used in the previous submission. That is, if your program/function is run with the previous submission as input, it should become an interpreter for the submission before that. Chaining all the answers would ultimately give integers from 1 to 10.

The commands in the previous answer are too complicated/high-level!

There is no need to implement all aspects of those commands. Your implementation only needs to have identical behavior to the original command when it is used in identical manner to the previous answer.

For instance, if the previous answer is in Brainf*ck, and it uses only 10 cells, you do not need to make an infinite tape; a length-10 array will suffice.

If the previous answer is in Jelly and has a . to put 0.5 in the stack, you do not need to implement the usage of . to form decimal numbers (unless it is used that way).

Note: Commands that are no-op still should be implemented as no-op (your code must recognize the commands).

How do I test my interpreter? It takes too long to evaluate the chain!

To prevent this issue, each answer must contain a test program for the next answer. The test program must use all commands in the interpreter, in the same manner.

Example of an interpreter

An Aheui program:

방망희 (* This program takes an integer as input and puts it in a stack (방),
          prints it as integer (망), and then terminates (희) *)

Invalid interpreters in Mathematica:

Print[Input[];Input[]]
(* This does not interpret the previous solution; it just does the identical task, ignoring the first input (the Aheui code) *)

If[Input[]=="방망희", Print[Input[]]]
(* This doesn't define each command *)

Fold[Switch[#2, "방망", Print[Input[]], "희", Abort[]]&,, Input[]]
(* This doesn't define each command *)

Valid interpreter in Mathematica:

Fold[stack={}; Switch[#2, "방", AppendTo[stack, Input[]], "망", Print[Last@stack];
  stack = Most[stack], "희", Abort[]]&,, Input[]]

Rules

  • Loopholes are not allowed
  • Any four consecutive answers cannot contain the same language twice.
  • The second to last submission (i.e. proven not to break the chain) by Feb 12 (0:00 UTC) will be the winner.

Answer format

4. [Language](https://link.to.specifications)

Your code here

This answer interprets language XYZ.

[Try it Online!](https://tio.run/nexus/language#@___/___)

Explanation

code snippet

This part interprets the x command.

code snippet

This part interprets the y command.

List of commands

A, B, C, D

Test program

... A( ... ); B( ... ); C( D( ... ) ); ...

\$\endgroup\$
31
  • 3
    \$\begingroup\$ Why would anyone bother to read the code on input at all, when it is already known exactly what the program needs to do? \$\endgroup\$
    – feersum
    Commented Jan 26, 2017 at 7:57
  • \$\begingroup\$ @feersum If the submission does not even read the input, it is no longer an interpreter. The interpreter must somehow identify each command in the input and execute the commands in order. I guess "You will need to define each function separately." wasn't that clear... (changed "function" to "command") \$\endgroup\$ Commented Jan 26, 2017 at 16:04
  • \$\begingroup\$ It's going to be hard to define a victory condition here. It'd be fairly easy to write a ridiculously long, complex program in a high-level language which would therefore be pretty much impossible to interpret. \$\endgroup\$
    – user62131
    Commented Jan 26, 2017 at 16:10
  • \$\begingroup\$ @ais523 I edited the question. Would that work? (The winner is the second to last answer) \$\endgroup\$ Commented Jan 26, 2017 at 16:18
  • 1
    \$\begingroup\$ Possibly. I'm still unsure that the question as a whole works, but maybe you'll find a way to define things precisely. \$\endgroup\$
    – user62131
    Commented Jan 26, 2017 at 16:37
  • 2
    \$\begingroup\$ @JungHwanMin "This is/isn't an interpreter" is a completely subjective identification which isn't appropriate in a code golf specification. \$\endgroup\$
    – feersum
    Commented Jan 26, 2017 at 22:36
  • \$\begingroup\$ @feersum This is an answer-chaining question. Also, I don't understand how "interpreter" is a subjective word. Could you give me an example, perhaps? \$\endgroup\$ Commented Jan 26, 2017 at 23:42
  • \$\begingroup\$ I mean, for a specification on this site (other than popularity contest). OK, if it's not subjective, please give me some code which can take as input a language A, a program X in language A, and a program Y, and output whether Y is interpreting X or not. \$\endgroup\$
    – feersum
    Commented Jan 27, 2017 at 0:14
  • \$\begingroup\$ @feersum That problem can be easily solved by requiring some explanation from the answerers (+ a link to language specifications). They would also need to write a list of commands used in their answers for the following answers. \$\endgroup\$ Commented Jan 27, 2017 at 0:21
  • 1
    \$\begingroup\$ @JungHwanMin I think what feersum is trying to say is this. An interpreter implements some programming language, which consists of some set of valid programs and their behaviors. Suppose that the first answer A is written in Java. The next answer B should be an interpreter for which A is a valid program whose behavior is to print the integers from 1 to 10. But what else are valid programs for B, and what should their behaviors be? Not every Java program has to be valid, as per the rules. What about all Java programs that use the same "commands"? (contd.) \$\endgroup\$
    – Zgarb
    Commented Jan 27, 2017 at 8:43
  • 1
    \$\begingroup\$ If A uses a Java function that has a very complicated implementation, but only a small subset of that is needed for A, can B choose to only implement that subset? If A uses a syntax that's very complex to implement generally, but can be treated as a no-op in A, does B have to implement the general case? It's hard to draw the line. \$\endgroup\$
    – Zgarb
    Commented Jan 27, 2017 at 8:45
  • \$\begingroup\$ @Zgarb Those are very good points. For your first comment, I would say that for language B, the valid programs are programs (in language A) that use the same commands in answer A with the same purpose (perhaps, it may be a good idea to require each answer to have a test program that prints from 1 to 10; the program would only use the commands in the interpreter). For your second comment, only a subset could be implemented; the no-op still has to be implemented, however (the interpreter must still acknowledge that the command is there). \$\endgroup\$ Commented Jan 27, 2017 at 15:41
  • \$\begingroup\$ In that case the chain could be broken by a language which is good at interpreting other languages but can't count from 1 to 10. (It wouldn't surprise me if one already existed; it might be fun to construct one if it doesn't.) \$\endgroup\$
    – user62131
    Commented Jan 27, 2017 at 22:01
  • \$\begingroup\$ @ais523 The only requirement is to print numbers from 1 to 10. Technically, something like print("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n") would be fine. Also, if the first answer uses a for-loop (to print 1,2,3,...,10), then all the languages after that needs to have something similar... -- Anyway, I changed the requirement to "the test program must use all commands in the interpreter" to prevent such issues. \$\endgroup\$ Commented Jan 27, 2017 at 23:36
  • \$\begingroup\$ Could I get feedback instead of unexplained downvotes? If this question is too broad/impractical, it can be improved. Any suggestion is welcome. \$\endgroup\$ Commented Jan 27, 2017 at 23:41
1
\$\begingroup\$

Chicken

No, before you ask,this challenge is not about the language.

Chicken is a game played with two cars (or two computers) where two drivers face each-other on a street. Each car may swerve or stay fixed in its path. Here is an idealized payoff matrix

              Player 1
                  Swerve        Stay
Player 2 Swerve    +3/+3        +10/+1          

Stay +1/+10 -25/-25

The values given for both swerving reflects the lack of ego damage, +3 is given for a win, but both staying results in a bothersome predicament with a high risk of a crash and where both have to reverse.

Now your job is to write a bot that will play this game. You will be provided with needed information as command line arguments.

A sample invocation will look like this.

foolanguage myBot.foo 4 w,w,w,w,w,w,t,w

Where the first command line argument is a string containing the number of goes you have had in the match and the second is a list containing each of you and your opponents decisions respectively (w is swerve and t is stay). Here is a break down of the list.

 (your first move),(opponents first move),(your second),(opponents second) 

This will be set up in a round robin fashion. You will play some arbitrarily high (say 100) rounds against each bot and your score will be totalled. Least damaged bot (highest scoring bot) wins!


Entering

You will provide a command stem and a unique bot name. So the sample bot can be called fooBot, and the command stem (after which arguments are appended) looks like "foolanguage myBot.foo"

Your bot will then output w (swerve) or t (stay) with 50 ms.

Your bot must be be able to make both choices. No locking in to just one choice.

Also, your bot must be deterministic (prng's may be seeded with a private seed. If you wish to do this, insert a dummy seed, and change it right before the competition) please publish the has to ensure you don't tweak it in light of other submissions.


The payoff matrix isn't quite realistic, but in order to make this game make sense and various strategies to work, I decided its important to tailor it this way.

\$\endgroup\$
14
  • \$\begingroup\$ 1) The payoff matrix shows that it's best to swerve every time, so the highest scoring bot will never "stay", but this goes against the rules. (2) Does the bot play against another bot or a human? (3) Does the bot have to output for just one round or multiple? \$\endgroup\$
    – Luke
    Commented Jan 29, 2017 at 22:04
  • 1
    \$\begingroup\$ "your bot must be deterministic" opens the way for metagaming where bots use seeded PRNGs and the person who posts last wins because they managed to tweak their seed to give them an edge. \$\endgroup\$ Commented Jan 29, 2017 at 23:06
  • \$\begingroup\$ @Luke serving gives three while staying four. Its in the format player 1, player 2. \$\endgroup\$ Commented Jan 30, 2017 at 0:50
  • \$\begingroup\$ @Luke output one round at a time, and then each round you receive a history, no need to store a history into a file. \$\endgroup\$ Commented Jan 30, 2017 at 2:05
  • \$\begingroup\$ @Luke also readjusted weights on the matrix \$\endgroup\$ Commented Jan 30, 2017 at 2:05
  • \$\begingroup\$ @PeterTaylor allowed hiding a seed, but mandated publishing its hash to ensure it doesnt get changed. \$\endgroup\$ Commented Jan 30, 2017 at 2:05
  • \$\begingroup\$ I think this would be more interesting if you changed the payoff matrix to include a prisoner's dilemma \$\endgroup\$
    – Luke
    Commented Jan 30, 2017 at 17:28
  • \$\begingroup\$ @Luke looking back on it, I should do that. Makes it more logical \$\endgroup\$ Commented Jan 30, 2017 at 23:47
  • \$\begingroup\$ @Luke I will fix it \$\endgroup\$ Commented Jan 30, 2017 at 23:47
  • \$\begingroup\$ @Luke it seems to be a dupe if the pay off matrix exactly reflects a prisoners dilemma, will need to tweak this game. Please do edit if you can mke it more interesting \$\endgroup\$ Commented Jan 30, 2017 at 23:55
  • \$\begingroup\$ IMO, this still feels too close to prisoner's dilemma. Despite the fact that the numbers are different, pretty much all of the existing submissions on our past challenge from the old challenge will work just fine, meaning that this is a duplicate. \$\endgroup\$ Commented Jan 31, 2017 at 3:49
  • \$\begingroup\$ @NathanMerrill, it's borderline. I did a bit of reading around, and there has been research on the different performance of the same approaches when applied to iterated prisoner's dilemma and iterated chicken (with a range of parameters for both). The strategies don't perform equally well, but it's probably true that the same strategies would be posted and there wouldn't be much innovation. \$\endgroup\$ Commented Jan 31, 2017 at 8:30
  • 1
    \$\begingroup\$ Watch out for another black hat program (The one that replaced others AI) \$\endgroup\$
    – user63187
    Commented Jan 31, 2017 at 16:19
  • \$\begingroup\$ I'm going to come up with another spin on this same theme, I like this format, but I think I need a different game entirely. \$\endgroup\$ Commented Jan 31, 2017 at 23:55
1
\$\begingroup\$

This is my first attempt at posting a code golf question. :) The following task is something that I've been thinking about for a while now. To me it seems that most code golf tasks, while often quite amazing, are of little more than of academic interest to anyone. In the modern world (of the World Wide Web), however, RESTful web services are of utmost importance.

I haven't seen many tasks like this here, so I wonder if it's appropriate, or if it needs any additional specs?


RESTful Web Service

Your task in a nutshell: implement a web server that can store and return values in a key-value fashion.

Rules

  1. Your application must act as a web server on localhost. The TCP port number must be 80 or higher.
  2. The server must be usable with the command line tool named curl, which comes pre-installed in every Linux system.
  3. The server is essentially a key-value storage where the keys are integers. You may choose to have your keys start from either 0 or 1, i.e. from localhost:80/0 or localhost:80/1. Your server must support storing at least 256 values, i.e. up to localhost:80/255, or /256 if you chose 1-based indexing.
  4. "HTTP PUT" to an address must update the value, "HTTP GET" must retrieve it: for example, "curl -XPUT -d 'foo' localhost:80/5" must store the value "foo" into position 5. "curl -XGET localhost:80/5" must then return "foo". "GET" and "PUT" are the only HTTP verbs that need to be supported.
  5. The server must always return the HTTP status code "200 OK", unless the user GETs an URL where nothing has been stored yet, in which case the status code must be "404 Not Found".
  6. The server must be able to store values that are of at least 64 bytes long.

This is a code golf task, so the shortest answer wins.

\$\endgroup\$
7
  • \$\begingroup\$ I don't know enough about web services to judge your spec, but general advice is to have your spec be perfectly thorough and exact in describing the required behavior. In a competition to cut bytes, any "useful" features or properties that are not required will be cut. Imagine your spec is being read by an adversary trying their hardest to find loopholes that let them get away with doing as little as possible. \$\endgroup\$
    – xnor
    Commented Jan 28, 2017 at 23:18
  • \$\begingroup\$ I'd indicate that GET and PUT are the only rest commands they need to support. As far as I'm concerned, this challenge actually seems pretty well specified to me. \$\endgroup\$ Commented Jan 31, 2017 at 13:27
  • \$\begingroup\$ 1. There are a couple of existing questions which ask people to implement basic HTTP daemons. I think it's borderline whether the specific handling here makes a non-duplicate. Other people may have stronger opinions. 2. If I'm correct that PUT includes a request body, it would be good to specify the MIME type(s) which implementers need to handle. Not everyone has access to curl to do their own tests. 3. Point 5 of the spec seems wrong: a PUT to a URI other than the 256 specified ones should probably give a 403. \$\endgroup\$ Commented Jan 31, 2017 at 16:51
  • \$\begingroup\$ @NathanMerrill, thanks, that's good feedback, I've added that point! \$\endgroup\$
    – ZeroOne
    Commented Feb 1, 2017 at 7:53
  • \$\begingroup\$ @PeterTaylor, I suppose you are referring to these questions: codegolf.stackexchange.com/questions/3988/… and codegolf.stackexchange.com/questions/41638/418-im-a-teapot I think the first one is too laborous to be fun and the second one is too simple. My question should be somewhere in the middle. Also I don't want to impose too many constraints, MIME types can be whatever, and for all I care the app may even crash if you PUT to wrong URLs. \$\endgroup\$
    – ZeroOne
    Commented Feb 1, 2017 at 8:07
  • \$\begingroup\$ There's also codegolf.stackexchange.com/q/12221/194 which I think is closer to yours, although it does also have a client-side HTML/JS component. \$\endgroup\$ Commented Feb 1, 2017 at 8:32
  • \$\begingroup\$ OK, ouch, that one has only 4 answers. I consider that a failure, the task obviously requires too much work so that not many people even bothered to attempt it. \$\endgroup\$
    – ZeroOne
    Commented Feb 1, 2017 at 9:12
1
\$\begingroup\$

Blank Card + Jera + Batteries


Background

In the dungeon-style game "The Binding of Isaac", there is a trick involving the use of three items, called the Blank Card, Jera, and the Battery. The Blank Card is a usable item that allows for the use of single-use items repeatedly when charged, the Jera item (single-use) allows for the duplication of items on the ground, and the Battery is a ground item which charges the current usable item. Having all three at once allows the player create as many batteries as they please, allowing them to gather all the player-stat altering items in the game with minimal effort.

However, the number of batteries which appear when repeatedly duplicating the batteries depends on a few things. Say that, at any given time, you have n batteries on the ground. Every time that you grab the battery and use the card simultaneously, you end up with 2n - 1 batteries on the ground (where n is the number of batteries you had just before picking up the battery). Your new n is now the current number of batteries on the ground. This sequence continues with each use of the blank card (hereon referred to as an "iteration").

General Formula

For the sake of clarification, the general formula for this sequence may be found below:

general form

Where b represents the number of batteries and n represents the number of iterations.

Task

Given two positive integers x and y, where x is an initial amount of batteries (b0) and y is the number of iterations to enact (n), write a program or function which finds the number of batteries you end up with on the ground.

Examples

Let f(x, y) be the function defined in the task and let [] symbolize the steps taken to reach the answer (not included in this challenge):

>>> f(1, 5)
1
[1, 1, 1, 1, 1]

>>> f(2, 4)
17
[3, 5, 9, 17]

>>> f(8, 8)
1793
[15, 29, 57, 113, 225, 449, 897, 1793]
\$\endgroup\$
4
  • 2
    \$\begingroup\$ There's no really much space for interesting golfing in "Given x and y calculate 2**y * (x-1) + 1". \$\endgroup\$ Commented Feb 4, 2017 at 21:17
  • \$\begingroup\$ @PeterTaylor Except that's not how it works... x_{n+1} = 2 * (x_n - 1), where x_0 = y. \$\endgroup\$ Commented Feb 4, 2017 at 21:27
  • \$\begingroup\$ The question clearly says that if you have n batteries and you apply one iteration you get 2n - 1 batteries, not 2(n-1) batteries. The examples also show the iteration mapping x_{n+1} = 2 * x_n - 1, not x_{n+1} = 2 * (x_n - 1). And the question also clearly states that "x is an initial amount of batteries and y is the number of iterations to enact". So your comment makes absolutely no sense. \$\endgroup\$ Commented Feb 6, 2017 at 9:01
  • \$\begingroup\$ @PeterTaylor Yup, my comment is off. D: Sorry. I think that the question needs rewording as well. \$\endgroup\$ Commented Feb 6, 2017 at 13:08
1
\$\begingroup\$

Display text in Comic Sans!

I haven't seen any challenges that require outputting text in a variable-width font, and of course I had to pick the best one.

Goal:

Display some text in the font Comic Sans. Characters must be variable width; i should use less space than W, for example. Kerning is not required.

Notes:

Your score is the program size (in bytes).
You may assume that the font "Comic Sans MS" is installed on the computer, or that a font file (or image containing the characters in that font) is in the current directory. Storing additional data in this file is not allowed; it must be a standard font or image file.

Input:

A string containing the text to display. This will only contain printable ASCII characters (32 to 126). This can be passed to a function, typed in by the user, loaded from a file, etc.

Output:

The text written in Comic Sans. This can be saved as an image, or just displayed on the screen graphically. However, direct text output is not allowed. For example, this would not be a valid HTML solution:

*{font-family:"Comic Sans MS"}
<input>

\$\endgroup\$
5
  • \$\begingroup\$ I'd like a clearer explanation on what is allowed and what is not. You are not allowed to (for example) save a .html file containing <style>*{font-family:"Comic Sans MS";}</style>Example Text is a bit vague \$\endgroup\$
    – satibel
    Commented Feb 6, 2017 at 16:00
  • \$\begingroup\$ Is this better? \$\endgroup\$
    – 12Me21
    Commented Feb 6, 2017 at 16:08
  • \$\begingroup\$ Can we assume that the font "Comic Sans MS" is installed on the system? (This challenge would be extremely different if not :P) \$\endgroup\$ Commented Feb 6, 2017 at 17:17
  • \$\begingroup\$ yeah, I said that "The size of the font is not included, but it must be in a standard format", but I think I should re-word that \$\endgroup\$
    – 12Me21
    Commented Feb 6, 2017 at 17:52
  • \$\begingroup\$ you maybe should provide a list of what constitutes a standard font file, as something like a nintendo ds font file might be considered standard by some, while not by others. Same thing with raw bit map, there are a bunch of different formats. I think something like an image or font file that was used at least once before the question was posted or just providing a list of allowed formats. would be clearer. \$\endgroup\$
    – satibel
    Commented Feb 8, 2017 at 12:47
1
\$\begingroup\$

Crossed out 44 is still regular 44

As it happens, the HTML strikethrough <s>4</s> lines up (at least on some systems) with the crossbar of the number 4 so that the two don't differ in appearance: 4 and 4 look like the same thing. This causes crossed out bytecounts in answers to code golf questions seem a bit confusing if they consist entirely of 4s or if they end or begin with a 4.

For instance, 48 44 34 31 bytes seems a bit silly.

However, there is a way to make the strikethrough over a 4 appear more clearly. If the bytecount begins with the digit 4, adding a non-breaking space (ASCII character 255) before the number will make the strikethrough extend beyond the crossbar of the digit 4. Similarly if the bytecount value ends with 4, the non-breaking space is appended to the end.

For example, 44 becomes  44 , 457 becomes  457 and 64 becomes 64 .

The Goal

The task here is to automate this fix.

Take a string like this: <s>48</s> <s>44</s> <s>34</s> 31 bytes as the input, and output or return the string with added non-breaking spaces at the end of each striken through number that ends with the digit four, and to the beginning of each striken through number that begins with the digit four.

So, for example, <s>48</s> <s>44</s> <s>34</s> 31 bytes becomes <s> 48</s> <s> 44 </s> <s>34 </s> 31 bytes. And here's the difference in effect: 48 44 34 31 bytes becomes  48  44  34  31 bytes.

Be sure to use non-breaking spaces, not regular spaces. Do not add them before or after numbers that are not crossed out. You can assume that all strikethroughs are closed (so there's no <s> that's missing its </s>). If there is anything else than the number inside the strikethrough block, no spaces should be added.

Your solution can be a program or a function. This is , so the shortest submission (for each language) wins. Standard loopholes apply.

\$\endgroup\$
6
  • \$\begingroup\$ Can there be spaces before or after the numbers in the strikethrough tags and what should behaviour be in that case? \$\endgroup\$ Commented Feb 13, 2017 at 13:39
  • \$\begingroup\$ I think at least make an example that shows something like <s> 48<\s> still has a nbsp added in front of the 4. \$\endgroup\$ Commented Feb 13, 2017 at 13:45
  • \$\begingroup\$ @LliwTelracs I changed it so that if there are any other characters inside the strikes, the spaces should not be added. \$\endgroup\$
    – Steadybox
    Commented Feb 13, 2017 at 13:55
  • \$\begingroup\$ Lol, I didn't acknowledge that there was a way to fix it. I fixed my answer's title now xP \$\endgroup\$
    – busukxuan
    Commented Feb 13, 2017 at 14:11
  • \$\begingroup\$ The premise of this question is wrong. Maybe some people have combinations of browser, system fonts, and configuration which make the strikethrough invisible, but to assert as a universal truth that the strike lines up with the crossbar is to err. \$\endgroup\$ Commented Feb 13, 2017 at 14:45
  • 1
    \$\begingroup\$ A test case with a 4 as a middle digit would be good. \$\endgroup\$ Commented Feb 14, 2017 at 14:29
1
\$\begingroup\$

Texplode


Texplode is like Hexplode, but played on a tetragonal (square) grid. explains the rules

I/O

You will provide two device files / named pipes / terminals / COM ports / other. One of these will be for input, and the other will be for output.

The input provided to your program will be a series of ASCII numbers n^2 characters long, followed by a ; character. The file will be flushed after this is put into it. The meaning of each number is as follows:

  • 0: There are no counters here. You can place here.
  • 1: There is one counter here, but it is not yours.
  • 2: There are two counters here, but they are not yours.
  • 3: There are three counters here, but they are not yours.
  • 4: There is one counter here, and it is yours. You can place here.
  • 5: There are two counters here, and they are yours. You can place here.
  • 6: There are three counters here, and they are yours. You can place here.

These numbers should be interpreted as being laid onto a n by n grid.

The output provided by your program should be a number followed by a ;. The number should be the position in the input stream that your program wants to place a counter. It must be a position that you can place in, otherwise Undefined Behaviour will occur.

Controller

The Texplode engine will be here soon.

\$\endgroup\$
13
  • 1
    \$\begingroup\$ Controller being reviewed here. \$\endgroup\$
    – wizzwizz4
    Commented Feb 15, 2017 at 17:43
  • \$\begingroup\$ If you're communicating with external programs then I'd expect validating the response to be a negligible extra cost for the controller, and it would allow you to automate the disqualification of a player, and their exclusion from the leaderboard tournament, so the rule abiding players don't have to wait longer for a leaderboard. \$\endgroup\$ Commented Jul 27, 2017 at 15:23
  • \$\begingroup\$ Sounds awesome, by the way... \$\endgroup\$ Commented Jul 27, 2017 at 15:23
  • \$\begingroup\$ Will you choose n large enough that the game cannot be solved optimally? I dont' think it takes very large an n for this... \$\endgroup\$ Commented Jul 27, 2017 at 15:24
  • \$\begingroup\$ @trichoplax With the current implementation the invalid responders just lose their turn. If they are still connected to the stream but not sending input I couldn't do anything about it anyway, apart from adding a time limit. \$\endgroup\$
    – wizzwizz4
    Commented Jul 27, 2017 at 15:26
  • \$\begingroup\$ @trichoplax n will vary. It will depend on how many contestants there are and how much computer time I have. \$\endgroup\$
    – wizzwizz4
    Commented Jul 27, 2017 at 15:39
  • \$\begingroup\$ I'd recommend some sort of time limit as this game benefits from an arbitrary amount of calculation for even relatively small n. Without a time limit there will be incentive to use more and more time per turn, particularly in the end game. \$\endgroup\$ Commented Jul 27, 2017 at 15:43
  • \$\begingroup\$ Also, it might be a very different contest depending on how long each turn lasts. After a certain point it will be a heuristic only game, but the turn length and board size will determine how many turns into the game this happens. You could choose the turn length based on what you prefer to see. \$\endgroup\$ Commented Jul 27, 2017 at 15:48
  • \$\begingroup\$ @trichoplax Does that matter much? Many good strategies exist that are simple, including Corner Hugger. I'll probably add a ~1 minute time limit, but only so the contest can finish in a reasonable amount of time. \$\endgroup\$
    – wizzwizz4
    Commented Jul 27, 2017 at 15:48
  • \$\begingroup\$ If you'd like to see simple approaches, I'd definitely recommend a time limit, otherwise they won't stand a chance of competing. \$\endgroup\$ Commented Jul 27, 2017 at 15:49
  • \$\begingroup\$ I think it will be very interesting either way. \$\endgroup\$ Commented Jul 27, 2017 at 15:50
  • \$\begingroup\$ @trichoplax I'm inclined to find a way to convert usercode time to clock cycles and standardise the number of cycles, but that seems too complicated. \$\endgroup\$
    – wizzwizz4
    Commented Jul 27, 2017 at 15:51
  • \$\begingroup\$ Any time limit should do, as long as the contestants know what it is. I don't think it makes much difference what it's measured in \$\endgroup\$ Commented Jul 27, 2017 at 15:56
1
\$\begingroup\$

Render STL files

STL means StereoLithography. It's a common file format, used in 3D printing.

The way it works is quite simple. You change every surfaces to triangles. For example, a cube would have 12 triangles, since it has 6 sides, and each sides has 2 triangles.

In this challenge, you have to read STL(A) files and render them.


Explain me more about the file format..

Well, technically, I linked you to the wikipedia, but I'll just explain, You can just, uh, go to the wiki if you want, you know?

Alright. the file is in this format.

solid [optional name]
facet normal ni nj nk
    outer loop
        vertex v1x v1y v1z
        vertex v2x v2y v2z
        vertex v3x v3y v3z
    endloop
endfacet
endsolid [optional name]

The part you have to look is the vertexes. you can see there are 3 vertexes each with three numbers (each of them are coodrinates of each axes). Remember I told that you change every surface to triangles? These three vertexes form a triangle.

and the part between facet normal and endfacet will be given multiple times, forming multiple triangles, forming a 3D object. like the cube I told you before.

You do not have to look at the numbers right after the facet normal. it will not affect the shape. (at least in this challenge)


Examples

I couldn't copy all of them so I decided to leave a link.

\$\endgroup\$
13
  • 1
    \$\begingroup\$ "render (ASCII)" needs to be clarified. Dumping triangles to an OpenGL renderer is is easy enough. Drawing wireframe lines with a perspective camera of our own is still fine. Drawing lines out of pixels is something I'm yet to code. \$\endgroup\$ Commented Feb 15, 2017 at 10:59
  • \$\begingroup\$ @JanDvorak No, I meant Ascii STL(STLA), which is simpler than the usually used binary STL. Look at the wiki \$\endgroup\$ Commented Feb 15, 2017 at 11:01
  • \$\begingroup\$ Are we to output STLA? If so, what is the input? \$\endgroup\$ Commented Feb 15, 2017 at 11:03
  • \$\begingroup\$ @JanDvorak the input is the STLA, and the job is to render the given STLA \$\endgroup\$ Commented Feb 15, 2017 at 11:04
  • \$\begingroup\$ What does it mean to render something in ASCII? Is it sufficient to raytrace a two-char palette (hit/no-hit), or is shading or drawing the edges required? If you want edges, do we need to cull backfaces and occluded edges? \$\endgroup\$ Commented Feb 15, 2017 at 11:08
  • \$\begingroup\$ @JanDvorak Uhh, no. Noone told you to render in ASCII. \$\endgroup\$ Commented Feb 15, 2017 at 11:14
  • \$\begingroup\$ It looked like you did. So, is it okay to just dump them into an OpenGL context and be done with it? Do note the default OpenGL settings use flat shading and put the camera straight at the back-front axis. \$\endgroup\$ Commented Feb 15, 2017 at 11:18
  • \$\begingroup\$ Eh, I don't even need a 3D renderer if I ignore the Z axis and draw lines from X,Y to X,Y. \$\endgroup\$ Commented Feb 15, 2017 at 11:21
  • \$\begingroup\$ Yes. Dumping to OpenGL is completely OK. But you should really beware of matlab, since matlab has A BUILTIN \$\endgroup\$ Commented Feb 15, 2017 at 11:24
  • 7
    \$\begingroup\$ This is very underspecified. I don't see any mention of projections (orthonormal or perspective), back-face culling, z-buffering, shading, lighting, ... \$\endgroup\$ Commented Feb 15, 2017 at 11:30
  • \$\begingroup\$ It seems that this is basically "receive a bunch of triples of 3D coordinates as input, and draw the resulting triangles". Is that the OP's intent? If so, I would do the usual thing of allowing flexible input structures. If the OP's intent is to text-process STL files, I don't find that too interesting. \$\endgroup\$ Commented Feb 15, 2017 at 17:23
  • \$\begingroup\$ @GregMartin Correct. That is the challenge. \$\endgroup\$ Commented Feb 16, 2017 at 5:29
  • \$\begingroup\$ I have the feeling that wireframe with orthonormal projection would fit this challenge, but I do not know how to specify. \$\endgroup\$ Commented Feb 16, 2017 at 5:30
1
\$\begingroup\$

Sandbox notes

  • This is the first time I write a controller; and it's been a while since I wrote an actual program. If you feel so inclined, feedback is appreciated.

Initial draft of the controller (java) here: https://github.com/S119349/cooperative-koth


The Cooperation Game

In this challenge, instead of competing, players will have to work together to beat a game. The player who on average gets the best results over all game runs, is the winner for this challenge. The game is inspired on the mechanics of "The Game".

Game mechanics

The goal of the game is to play as much cards as possible on four piles on the table. Two piles can only accept cards in strictly increasing order, the other two in strictly decreasing order. The game is over as soon as a player cannot play a card.

Piles

The game starts with four piles, numbered 0 through 3 inclusive. Piles 0 and 1 accept cards in strictly increasing order; piles 2 and 3 accept cards in strictly decreasing order. Initially, the piles are

Pile number |  0  |  1  |  2  |  3  |
       Card |  1  |  1  | 100 | 100 |

There is an exception to the rule of accepting only strictly increasing/decreasing order. You are allowed to play a card exactly 10 less or more respectively than the current card. For example, if the piles are

Pile number |  0  |  1  |  2  |  3  |
       Card |  1  |  32 |  78 | 100 |

you are allowed to play 22 on pile 1, or 88 on pile 2.

Taking turns

The game starts with a shuffled draw stack containing 98 cards, numbered 2 through 99 inclusively. Each player is dealt 6 cards at the start of the game. The cards are known only to the players themselves.

During a turn, a player must play at least two cards Exception: you only have one card, or you're out of cards, because the draw stack is empty, up to all the cards in their hand. After their turn, the player will restock from the draw stack to 6 cards (or less at the end of the game).

Reacting

After each card is played, other players are allowed to react: if you have the perfect card in your hand, you may want to warn players not to add anything to that pile! Since your cards are secret to you, this is done by assigning priorities to each pile. The priority is from 0 to 5 inclusive, with 0 signifying no interest at all in that particular pile, and 5 begging other players not to add anything to that pile. Other players can use these priorities as they deem fit; including completely ignoring it.

Interaction with the controller

You will create a player that extends the abstract Player class. You will have to implement void turn() (for playing a card) and int[] react() (for announcing your priorities). A reference implementation, SimpleTom, is provided, but may be removed from the competition if there are enough competitors.

In void turn(), you are required to either playCard(int card, int pile) or endTurn(). Note that you may only play one card per invocation of turn(), to give other players an opportunity to react(). Doing anything else (playing two cards, playing no cards at all) will result in losing the game, with all the cards still in the game adding towards each player's score!

In int[] react(), you are required to return an array of your priorities on each pile. An example would be return new int[] {a, b, c, d} with a through d the priorities for each pile. Here, 0 <= a <= 5.

To see what is happening, you have access to some members

  • ArrayList<Integer> hand contains all cards currently in your hand.
  • In the gameState member of the default Player class:
    • int [] gameState.piles contains the four piles. It is an integer array of size 4, with each element the last played card on that pile.
    • Map<Player, int[]> gameState.priorities. A map containing the latest priorities issued by each Player in the game.
    • Player[] gqameState.players can be used to list all the players in the current game; as well as determine how many cards they have by calling int nHandCards(). Note however that you may not access these players in any other way! (force them to do a turn, force them to lose, make them expose their hand, etc).

Concerning the other players: you may know who is playing and assess their skill during a game (for example, figure halfway through a game that SimpleTom is not trustworthy, and that two of the other players are of type SimpleTom). You may not save this information between games, or hard-code strategies concerning other players.

Do's and don'ts

All entries are open-source. You are encouraged to write commonly used functions (e.g., something to keep track of what cards have already been played) as separate functions, so others may use them. When you use code from others, always attribute your source. It is not OK to copy someone's algorithm and just tweak a few values - your code should be significantly different from others.

You are allowed to use a different languages than Java, if you write your own wrapper class (or use someone else's wrapper class). I usually only use Try it Online!, so I don't have any compilers installed on my Ubuntu box. If you use another language that is not available on Ubuntu by default, please include a few lines on how to install your language. Your entry will be non-competing if it takes me more than two minutes to follow these instructions, so a script or copy-pasteable command line code is preferred.

\$\endgroup\$
13
  • \$\begingroup\$ The API needs a bit of clarification: I don't see any way to access my hand; the spec contradicts itself on the return type of react(); and gameState.priorities exposes information about who else is playing: can I use that information or not? \$\endgroup\$ Commented Feb 17, 2017 at 11:01
  • \$\begingroup\$ I think I understand the game. There's just one point, which I was going to mention in the previous comment but forgot: "Doing anything else (playing two cards, playing no cards at all) will result in losing the game!" What does that mean exactly? I presume that it's game over for everyone, not just the misbehaving player, but what does everyone score? \$\endgroup\$ Commented Feb 17, 2017 at 11:51
  • \$\begingroup\$ @PeterTaylor Good point! It means game over for everyone - this is cooperative gaming, and this means no player can just wing it. However, averaging the scores over all runs should sort this out, and if it becomes a problem, I could modify the code to make sure all match combinations are played instead of my current Monte Carlo approach. \$\endgroup\$
    – Sanchises
    Commented Feb 17, 2017 at 12:27
  • \$\begingroup\$ The biggest reason it's important to specify it is that now that you've confirmed that players can see who the other players are, some might want to deliberately sabotage the game in the presence of their biggest rivals. \$\endgroup\$ Commented Feb 17, 2017 at 12:43
  • \$\begingroup\$ @PeterTaylor I think I outlawed that by saying You may not save this information between games, or hard-code strategies concerning other players.. So sure, you can try to detect other players and sabotage them, but you would have to write some darn good AI to do that. \$\endgroup\$
    – Sanchises
    Commented Feb 17, 2017 at 12:44
  • \$\begingroup\$ @PeterTaylor if all the bots lose at the same time, then sabotaging your opponents sabotages yourself equally. \$\endgroup\$ Commented Feb 17, 2017 at 13:52
  • \$\begingroup\$ @LliwTelracs, which is why it would be selective. If there might be multiple instances of the same bot in a game, I think it could work, at least as a king-making strategy. Sanchises, "hard-code strategies concerning other players" sounds like it could create arguments over whether heuristic X is a hard-coded strategy targetting a given player or not. \$\endgroup\$ Commented Feb 17, 2017 at 14:00
  • \$\begingroup\$ @PeterTaylor I'm fine with targeting strategies at other players (isn't that what all KoTH competitors do?), as long as it's not hard-coded to act on a specific player (class name). In other words, your entry should behave exactly the same if another player changes their player name. So, it's allowed to know that player 1 and 2 are both the same type, and deduce that player 3 sucks, but it's not allowed to check that player 1 is actually the same bot as player 4 from the last game. \$\endgroup\$
    – Sanchises
    Commented Feb 17, 2017 at 14:10
  • \$\begingroup\$ I figured I did not have to enforce that in code, but given this confusion, perhaps I better enforce that using an interfacing class instead of directly? \$\endgroup\$
    – Sanchises
    Commented Feb 17, 2017 at 14:15
  • 1
    \$\begingroup\$ @Sanchises in my experience: yes. Make your API airtight. If they shouldn't be able to modify/read something, make it impossible to do so (outside of reflection). \$\endgroup\$ Commented Feb 17, 2017 at 18:39
  • \$\begingroup\$ Also, self plug: I've got a KoTHComm Java library that makes cross-language communication easy, as well as handles many tasks, such as assigning players to games, creating random variables for determinism, and even automatically downloading submissions. If you are interested, I'd be happy to help you use it. \$\endgroup\$ Commented Feb 17, 2017 at 18:42
  • \$\begingroup\$ @Nathan thanks for your suggestion. I should like to see what your library has to offer, but note that I code as a hobby, not professionally, so I'll excuse myself for odd questions in advance \$\endgroup\$
    – Sanchises
    Commented Feb 17, 2017 at 22:12
  • \$\begingroup\$ @Sanchises Java is a hobby for me as well :) I've created a chat room, if you want to come in. \$\endgroup\$ Commented Feb 17, 2017 at 22:24
1
\$\begingroup\$

Implement Fizz Buzz in the C Preprocessor without the use if #if

Note: I understand that there is already a question for Fizz Buzz and the preferred method is to place a bounty on an existing question instead of asking a new one. However, I believe that this warrants its own question.

The C Preprocessor Language is Turing Complete when used in a loop. Your task is to implement Fizz Buzz up to and including a given integer without the use if #if.

  • You must be able to implement Fizz Buzz for inputs from 6 to 100. You can support more if you wish, but it is not required.
  • #define INPUT <input> will be placed at the top of the file to provide input. This is not included in your bytecount.
  • The output is defined as the output of cpp compilation with all lines beginning with # stripped away fed back into cpp for as many times as needed until the results of two steps are identical.
    • You must be able to prove this takes a finite amount of steps.
  • Specify the version of the C Preprocessor Standard to use.
  • No custom compiler flags.
  • No using compiler extensions.
  • You can delimit items with the delimiter of your choice.
  • There can be extra delimiters at the start.
  • Trailing newlines are allowed.
  • #if is not allowed!
  • It must be exactly Fizz, Buzz, and FizzBuzz. Case sensitive.

A submission might look like this:

#define MAIN(...) \ 
  // ... 
MAIN(INPUT)

It will be compiled as

#define INPUT <input>
#define MAIN(...) \ 
   // ... 
MAIN(INPUT)

...using the command cpp filename.

Steps for getting output:

  1. cp file file2
  2. cp file2 file
  3. cpp file > file2
  4. Remove all lines beginning with # in file 2.
  5. If file2 is identical to file, exit. The current file2 is defined as the output.
  6. Repeat steps 2-5 until exit.

Examples

Multiple outputs for a single input indicates all are valid

6 -> 1, 2, Fizz, 4, Buzz, Fizz
6 -> 1, 2, Fizz, 4, Buzz, Fizz, 
6 -> , 1, 2, Fizz, 4, Buzz, Fizz
6 -> , 1, 2, Fizz, 4, Buzz, Fizz, 
15 -> 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz,
\$\endgroup\$
6
  • \$\begingroup\$ I take issue with the statement that cpp (the preprocessor C and C++ use) is Turing-complete; that's only true if you run it in a loop, which isn't what you're doing in this question. Also, I suspect you've forgotten that #if supports arithmetic operators, including modulo, that make the problem trivial. Note also that as C++ and C use the same preprocessor, there's no real need to specify "the C++ preprocessor"; just run cpp directly. (Note also that C++ is Turing-complete at compile time using templates, even without the preprocessor involved.) \$\endgroup\$
    – user62131
    Commented Feb 19, 2017 at 20:47
  • \$\begingroup\$ To be clearer: "Since there is no concrete definition of what constitutes the C++ macro language" is just a huge misconception: a) there is a concrete definition in both the C and C++ standards of "translation phases", which separate preprocessing from the rest of the code; b) there's also a concrete definition in terms of executable programs and implementations, because it's possible to simply run cpp directly! \$\endgroup\$
    – user62131
    Commented Feb 19, 2017 at 20:49
  • \$\begingroup\$ @ais523 I will change the rules 1. run in a loop 2. prevent the usage of #if or templates. #2: will fix \$\endgroup\$ Commented Feb 19, 2017 at 20:52
  • \$\begingroup\$ I'm not convinced cpp can split a string into characters, or do anything with it other than comparing it to another string (and maybe not even that if there's a hyphen), so the solutions here may be less interesting than you like; the input format is simple inappropriate for the purpose, now that you've banned #if (which would let you treat the number as an integer). Incidentally, running it in a loop is unlikely to be necessary; it's needed for the language to be Turing-complete, but it's still fairly powerful even without the loop, and likely easily powerful enough to answer the question. \$\endgroup\$
    – user62131
    Commented Feb 19, 2017 at 21:01
  • \$\begingroup\$ @ais523 I changed it to FizzBuzz to make it much more interesting. \$\endgroup\$ Commented Feb 19, 2017 at 21:18
  • \$\begingroup\$ restricted-source? \$\endgroup\$
    – ckjbgames
    Commented Feb 19, 2017 at 21:32
1
\$\begingroup\$

Nibbles Nostalgia

People from my generation certainly know what is the Nibbles game! If you are not here included, what I am asking is a one-line version the level 1 of https://www.youtube.com/watch?v=UmeKHtei0qo (time: 14s—54s)

The challenge is to write a game that is a one line, one level Nibbles game using only the line buffer.

Rules:

  • You must output to one or both of stderr/stdout
  • Line Width is 80 chars
  • Snake will always begin at the middle with 2 chars in width
  • For a user to loose, the head of the Snake must hit one of the ends
  • Each time a number {1...9} is catched the snake grows using the formula new_witdh= current_width + 2 * catched_number
  • Of course numbers appear in an random position of the white space, never in Snake's body
  • The char for each snake block body is ASCII \219 █
  • It only accepts two keys, the Arrows for Left and Right. Does nothing when in the same sense; inverts head and tail when inverse
  • First move is always to right
  • It must be available somewhere online for me to play
  • Timing between each turn of snake movement is 200 ms (This will be adjusted to make it more realistic)
  • If user looses, you will output in the same line a full line of ASCII \127 char ⌂ and quit.
  • If user wins, you will output in the same line a full line of ASCII \2 char ☻ and quit

It is a [code-golf] challenge, where there will be no accepted answer; I just made the challenge for my own fun!

UPDATE: I made a nice discovery: The original game is playable on http://stevehanov.ca/blog/index.php?id=92, by mouse clicking on Compile and Run

\$\endgroup\$
21
  • \$\begingroup\$ How does a user win? And could you provide some ascii examples how some frames of the game should look? Does the console needs to be cleared after each line or can the new frame be printed to the next line? \$\endgroup\$
    – Laikoni
    Commented Jan 9, 2017 at 22:21
  • 1
    \$\begingroup\$ "The char for each snake block body is ASCII \219 █". Not sure about this. It's adding unnecessary stuff. Why not just * or + or # or something else simple? I don't see why the character used is an important part of the challenge. \$\endgroup\$
    – ElPedro
    Commented Jan 9, 2017 at 22:24
  • \$\begingroup\$ @ElPedro: To make it more like to the original game! \$\endgroup\$
    – sergiol
    Commented Jan 9, 2017 at 22:26
  • \$\begingroup\$ I hear what you are saying but the challenge is to recreate the game in the shortest code and not the graphics or am I misunderstanding what you are asking? If is a graphics challenge then that is a different story. \$\endgroup\$
    – ElPedro
    Commented Jan 9, 2017 at 22:29
  • \$\begingroup\$ "The challenge is to write a game that is a one line, one level Nibbles game using only the line buffer." I guess it is possible to sometimes overcomplicate things by being too specific. \$\endgroup\$
    – ElPedro
    Commented Jan 9, 2017 at 22:30
  • \$\begingroup\$ Btw, I have upvoted in the sandbox because I think this has potential. It doesn't mean that you should repost now :-) \$\endgroup\$
    – ElPedro
    Commented Jan 9, 2017 at 22:36
  • \$\begingroup\$ I would also suggest that you temporarily delete from the main site as you already have one downvote (not me). \$\endgroup\$
    – ElPedro
    Commented Jan 9, 2017 at 22:39
  • 4
    \$\begingroup\$ Honestly, I was confused when I saw this, because I've never heard of a "Nibbles" game. It's called "Snake". en.wikipedia.org/wiki/Snake_(video_game) \$\endgroup\$
    – mbomb007
    Commented Jan 9, 2017 at 22:41
  • \$\begingroup\$ @mbomb007: youtube.com/watch?v=UmeKHtei0qo \$\endgroup\$
    – sergiol
    Commented Jan 9, 2017 at 22:53
  • \$\begingroup\$ @Laikoni: A user wins if catches all the {1...9} numbers without the snake hitting on the ends. The idea is to use only one line. \$\endgroup\$
    – sergiol
    Commented Jan 9, 2017 at 22:59
  • 4
    \$\begingroup\$ My point is you can't assume people know what it is. You have to include all relevant information within your post. \$\endgroup\$
    – mbomb007
    Commented Jan 9, 2017 at 23:01
  • \$\begingroup\$ @mbomb007: Is it better now with the video link on the question? \$\endgroup\$
    – sergiol
    Commented Jan 9, 2017 at 23:06
  • \$\begingroup\$ 1. If all the numbers from 1 to 9 appear once, the snake would be 92 characters long and thus no longer fit into one line. 2. I don't think that a video of a 2D snake game adds much to a challenge about a custom 1D version. \$\endgroup\$
    – Laikoni
    Commented Jan 9, 2017 at 23:22
  • \$\begingroup\$ @Laikoni: I made the count and the max is 74; didn't you forget that after catching 9, you don't need to make the Snake grow? \$\endgroup\$
    – sergiol
    Commented Jan 9, 2017 at 23:38
  • 2
    \$\begingroup\$ 1. There's no such thing as "ASCII 219". ASCII is a 7-bit character encoding. 2. How does the snake grow? 3. What does "It must be available somewhere online for me to play" mean? Only languages for which a JavaScript implementation with console emulation exists? \$\endgroup\$ Commented Jan 10, 2017 at 15:33
1
\$\begingroup\$

Caps Lock Morse Code

Inspired by Blink the CAPS LOCK

Input will be a string that contains only characters that can be represented in morse code.

Convert the input string to morse code and then output it using either the Caps Lock, Num Lock or Scroll Lock indicators on the keyboard

Thoughts on the challenge

  • I think this would be good as a code golf
  • How specific should I be on defining what the output looks like, is the above sufficient or should a specific time length be given for dots and dashes?
\$\endgroup\$
2
  • 2
    \$\begingroup\$ It is a little derivative of the challenge it was inspired by. I'm not sure if it would provoke interesting solutions. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Feb 22, 2017 at 23:47
  • \$\begingroup\$ @WheatWizard I was worried that would be the case \$\endgroup\$
    – user19547
    Commented Feb 23, 2017 at 0:09
1
\$\begingroup\$

Free the Prisoners

Your task is to free a few prisoners. Here they are, in their cells:

[sad] [shame] [cops]

Rules, explained

They have to be specifically freed using whitespace as replacement for each replaced letter, and then place the words to the right of the string, with an additional space separating the string area.

The first example would become:

[   ] [     ] [    ] sad shame cops

Here is a code snippet that lets you see the prison cell before and after, plus a JS function. The square brackets ([]) are assumed, and do not need to be typed in the box.

console.log(`Original Cell:     Waiting for input...`);
  console.log(`Emptied Cell:      Waiting for input...`);
  console.log(`Empty Cell Length: Waiting for input...`);

var string = '';
var emptyCell = function(string) {
  string = string.replace('[', '').replace(']', '');
  return ' '.repeat(string.length);
};

window.onkeyup = function() {
  string = document.getElementById('cagecontent').value;
  
  console.clear();
  
  console.log(`Original Cell:     '${string}'`);
  console.log(`Emptied Cell:      '${emptyCell(string)}'`);
  console.log(`Empty Cell Length: ${emptyCell(string).length}`);
};
<textarea id='cagecontent' placeholder='Place text, minus the brackets, here.'></textarea>

There is one known error for this script: the first bracket rule doesn't work. Sorry about that.

Any whitespace on the edge of an imprisoned string (ex. test with a space before) would stay while emptying the cells, but would be trimmed when placed outside. The aforementioned test with some extra whitespace on the edge would look like this:

[ test]
[     ] test

As you can see, instead of two spaces between the original string and the freeing area, there is only one.

[test]]
[    ]] test

Rules, simplified

  • Trailing spaces are allowed.
  • Replace each character in a prison cell string with a single blank space.
  • Place each freed thing to the right of the original string.
    • Separate the original string and the freed things with a single space.
    • Extra whitespace on the sides of a string, when placed to the right of an original string, is removed.
  • Your testing string will be: (Let us out!)>[mad] [angery] [11]]
    • Should result in: (Let us out!)>[ ] [ ] [ ]] mad angery 11
  • No common loopholes, of course.

Scoring

If you look at the tags, you can see that this question is a puzzle. The tag wiki excerpt for this tag is:

Code-golf is a competition to solve a particular problem in the fewest bytes of source code. If you want to score by characters instead of bytes, please state this explicitly in the challenge. If source code length is not the primary scoring criterion, consider using another tag instead.

That means, the question (of any language) with the least amount of bytes is the top-scoring solution!

\$\endgroup\$
5
  • \$\begingroup\$ I noticed the number of brackets can be unbalanced. I'm not sure that's a particularly handy requirement. I'd suggest either making the excess brackets behave like regular text (ie, also be freed), or guaranteeing a balanced number of brackets, \$\endgroup\$
    – steenbergh
    Commented Feb 23, 2017 at 9:51
  • \$\begingroup\$ The first ending bracket ends it. An unmatched bracket is untouched. This is already a rule. \$\endgroup\$ Commented Feb 23, 2017 at 11:31
  • 1
    \$\begingroup\$ 1) Your script and the tag wiki excerpt unnecessarily bloat the challenge without adding information, so I would recommend removing them both. 2) I read the challenge twice and did not find a The first ending bracket ends it. An unmatched bracket is untouched. rule, only There is one known error for this script: the first bracket rule doesn't work. which does not state said rule. 3) You should include not just a single but multiple test cases. \$\endgroup\$
    – Laikoni
    Commented Feb 23, 2017 at 15:40
  • \$\begingroup\$ Can there be arbitrary characters between the cells? What about nested cells? Are the prisoners lower case ascii characters only? \$\endgroup\$
    – Laikoni
    Commented Feb 23, 2017 at 15:47
  • \$\begingroup\$ @Laikoni Anything but a ]. \$\endgroup\$ Commented Feb 23, 2017 at 15:56
1
\$\begingroup\$

Is this bitstring divisible by 3?


Your challenge is to write a program or function that, given a string of bits representing a positive integer, outputs or returns a truthy value if it's divisible by 3, and a falsy value otherwise.

Rules

  • You may not convert the input to a number in any way. You may manipulate the string or loop through each digit, so long as you don't convert it to your language's native number type.
  • Input may be given as a string or an array of digits.

Truthy examples

11
110
1001
1100
1111
10010
10101
11011
111111
10010011
1010010001
10101010101
100100101010001011110101010001
1000000000000000000000000000000000000000000000000001
1111111111111111111111111111111111111111111111111111
11000001001011110010001010001001010110000010100001001000100101
1111001111110010001110111011001010100100001000110100010011101011110010010111100111011100110101000011100110011111001010000111011110010111000100001010101001000001111011011111000101001111010010010010000110101100011001011111111000111001110110011011101010011000

Falsy examples

1
10
100
101
111
1000
1010
1011
1101
10000
11111
10101010101011
1101001000100001000001000000100000001
10000000000000000000000000000000000000000000000000001
11111111111111111111111111111111111111111111111111111
11000001001011110010001010001001010110000010100001001000100110
1101011111110011110010011101010011000001101011001111001001011010100000000110001111001101100000001010010111100111000101001001000011100000110111010010100000100001100101110000011010000010110010101011110010100110101100000011101101010000010011000001001001010101

Sandbox questions

Obviously as a Do X without Y question this is walking a very fine line. There are several string manipulation techniques (which I won't spoil here) that I'd like to see used, rather than solutions that just loop through the string and repeatedly add a digit and take modulo 3. I could be more strict and not allow any numbers in the process, but I don't know if that's a good idea... Suggestions? Is it even possible to make this a good challenge?

\$\endgroup\$
2
  • 1
    \$\begingroup\$ This is going to be very hard to specify cleanly and still leave possible in most languages. E.g. in Java I can't loop through each digit without converting it to a native number type, because char is a native number type. (Well, I might be able to use a regex to split it into one-character strings, but that would be a crazy requirement). \$\endgroup\$ Commented Feb 25, 2017 at 20:13
  • \$\begingroup\$ I think it should be possible to treat each digit as a number, just not the full string. \$\endgroup\$
    – Leo
    Commented Feb 26, 2017 at 14:14
1
\$\begingroup\$

Leaderboard golf: posted

\$\endgroup\$
1
\$\begingroup\$

The Mass Murderers of Josephus

Everyone knows the Josephus challenge and its setup: you arrange n people in a circle, and the first person kills the second, and from then on the first alive person to the right of the previous "killer" kills the next alive person to their right. For example, with four people:

  1
4   2    (4 people in a loop)
  3

  1
4        (1 kills 2)
  3

  1
         (3 is closest to the right of the previous killer 1,
  3       and kills 4, who is to the right)

  1      (1 is closest to the right of the previous killer 3,
          and kills 3, who is to the right)

The last remaining person is 1, in this case.

Your task, however, is to find the most murderous of these people - or whoever killed the most people. In the above example, the "murderer" is 1, who killed 2 people: 2 and 3.

In a bigger example, of 10 people (this is a line of 10 people, right wraps around to the left):

PEOPLE ALIVE  | KILL TALLY
1 2 3 4 5 6 7 |
1   3 4 5 6 7 | 1: 1
1   3   5 6 7 | 1, 3: 1
1   3   5   7 | 1, 3, 5: 1
    3   5   7 | 1, 3, 5, 7: 1
    3       7 | 3: 2; 1, 5, 7: 1
            7 | 3, 7: 2; 1, 5: 1

There's a tie for the person with the most kills: when a scenario like this arises, the answer is average of all the people with the most kills - in this case, it is (3 + 7) / 2 = 5.

Task:

You must make a program or function that takes one input, the amount of people in the circle, and output the murderer (or the average of multiple murderers).

Rules and specs:

  • The input will never be above 2^31 - 1.
  • The input is guaranteed to be a positive integer.
  • Your program must work out 100 within the timeframe of TIO (60 seconds). If you're not using TIO, provide an interpreter for me to test your program on (preferably an online one).
\$\endgroup\$
2
  • \$\begingroup\$ Averaging multiple murderers seems really artificial. I recommend either outputting the list of all most-murderous people, or saying that any of them can be the single output. Once such a change is made, I'd upvote this proposal! \$\endgroup\$ Commented Mar 5, 2017 at 19:51
  • \$\begingroup\$ Borderline, but IMO this is a dupe of codegolf.stackexchange.com/q/64667/194 or codegolf.stackexchange.com/q/5891/194. If n in binary starts 10 there's a unique murderer, and it's just the Josephus problem; if n in binary starts 11 there's a tie between two people, who are the last two people to die (simple variant on the first candidate dupe); or alternatively the last one to die is the standard Josephus problem, the second-last to die differs in the most significant bit of n (e.g. in the example n=7 the most significant bit is 4 and the murderers differ by 4). \$\endgroup\$ Commented Mar 5, 2017 at 23:31
1
\$\begingroup\$

Chemistry 101

Question

Given the atomic number of an element in the range [1-118] print out the group and period, of that element as given by the following Periodic Table Of Elements.

For elements in the Lanthanide and Actinide series, (ranges [58-71] and [90-103]), you should instead print L for the Lanthanides and A for the Actinides

You may write a program or a function and use any of the our standard methods of receiving input and providing output.

You may use any programming language, but note that these loopholes are forbidden by default.

[Source] I couldn't have put it better!

enter image description here

[Source]

Test Cases

The output here separates the group and period with a single space

| Input | Output |
|   1   |  1 1   |
|   33  |  15 4  |
|   45  |  8 5   |
|   71  |  L     |
|   93  |  A     |
|   117 |  17 7  |

Scoring

Simple . Shortest number of bytes wins

\$\endgroup\$
11
  • \$\begingroup\$ I'd suggest replacing the table with a text-based one. Otherwise, you're probably good to go. You should allow more flexible output, though. Not everyone likes converting their arrays to string. \$\endgroup\$ Commented Mar 8, 2017 at 11:22
  • \$\begingroup\$ Thanks for the feedback. I'm happy to be flexible on the output, but curious as to what benefit a text based table would provide over the image? Mobile users? \$\endgroup\$ Commented Mar 8, 2017 at 11:24
  • \$\begingroup\$ Mobile users, yes. Also, low-bandwidth users and people sitting behind overly restrictive firewalls. Not an issue here, but text is easier to edit than images. Also, prevents issues if imgur ever decides to start deleting images. \$\endgroup\$ Commented Mar 8, 2017 at 11:35
  • \$\begingroup\$ Point taken. I'll wait to see if this question is well received before I type up (or find) a text based version! \$\endgroup\$ Commented Mar 8, 2017 at 11:36
  • \$\begingroup\$ You should allow non-string output as well. Remember that answerers may submit functions instead of full programs. \$\endgroup\$ Commented Mar 8, 2017 at 11:37
  • \$\begingroup\$ I would like to maintain that the result is printed rather than just returned, but otherwise, I don't specifically mention data types. \$\endgroup\$ Commented Mar 8, 2017 at 11:39
  • \$\begingroup\$ Why would you do that? It's but an inconvenience for the answerers, not a challenge. Also, there are languages where functions can't have side effects - they can only return IO actions that the caller may execute or discard. \$\endgroup\$ Commented Mar 8, 2017 at 11:42
  • \$\begingroup\$ I think it's probably because I haven't used any of those languages. I conceed! \$\endgroup\$ Commented Mar 8, 2017 at 11:49
  • \$\begingroup\$ In Haskell: the interesting part is f x = (foo x, bar x). With string output it's f x = show (foo x, bar x). As an IO action it's f x = print (foo x, bar x) but now the type is now IO() instead of (Int, Int) or String. A full program is f x = (foo x, bar x); main = readIO >> print.f - unless the compiler can't infer that x is a number, in which case you have to add that bit somewhere, too. \$\endgroup\$ Commented Mar 8, 2017 at 11:58
  • 2
    \$\begingroup\$ Rather than a text-based table I would say that since there are only 118 possible inputs you might as well just provide an exhaustive test suite. \$\endgroup\$ Commented Mar 9, 2017 at 8:59
  • \$\begingroup\$ @PeterTaylor that makes me think of - do we have a tag for a finite number of possible inputs? \$\endgroup\$ Commented Mar 9, 2017 at 17:24
1
\$\begingroup\$

Android Lock Screen Art


Background

In the land of Android, there exists a password type that looks like this:

slide lock

It's essentially a connect-the-dots for a password. Today, we'll be making art with it.

The Task

Your program should export as many distinct combinations of pattern lock as image files with the following specifications:

  1. Images should be 500x500 pixels large.
  2. Dots should be located at positions (x, y):
    • (125, 125)
    • (125, 250)
    • (125, 375)
    • (250, 125)
    • (250, 250)
    • (250, 375)
    • (375, 125)
    • (375, 250)
    • (375, 375)
  3. Lines should be drawn with a circular brush head of radius 8px.
  4. Background color and line color may be any color of your choosing, but must not be the same color and it must be consistent.
  5. The pattern should pass through all points ONCE, with the exception of the first point, which should be the first and last point drawn from/to.

Examples

The following output is valid (starts at top-left):

valid

The following output is valid:

valid 2

The following output is invalid:

invalid

This breaks condition 5 (repeat use of top-left, middle, and middle-left).

The following output is also invalid:

invalid 2

This passes through the top left twice and the start point is not the same as the end point (breaks rule 5 twice).

Scoring

The program with the largest number of distinct outputs wins, with the shortest program being the tiebreak.

\$\endgroup\$
8
  • \$\begingroup\$ "The program with the largest number of distinct outputs wins, with the shortest program being the tiebreak." Some simple math gives that there are 362880 possible permutations (9 options for the starting point, 8 options where to go next, 7 options left for the next point...). I think that most, if not all, answers would opt to produce all of these. Makes me wonder how an answer would deal with outputting all these images. Also, it would probably be useful to add a link to the I/O rules: [x](http://meta.codegolf.stackexchange.com/q/2447/13486 "Default for Code Golf: Input/Output methods") \$\endgroup\$ Commented Mar 11, 2017 at 11:05
  • \$\begingroup\$ @user2428118 So... roughly 1.5 GB of images per run on my machine. Not bad. \$\endgroup\$ Commented Mar 11, 2017 at 11:59
  • 1
    \$\begingroup\$ @user2428118 Also, that math doesn't hold, considering that choosing to go from one corner to any of the others forces pathing through intermediate points, so there are slightly fewer than that many options. \$\endgroup\$ Commented Mar 11, 2017 at 12:02
  • \$\begingroup\$ What do you mean by distinct? There are many lock patterns that are visually the same but require a different path to be made. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Mar 12, 2017 at 17:48
  • \$\begingroup\$ Also I don't believe that your first two outputs can be made. A closed loop is not possible on the android lock screen. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Mar 12, 2017 at 17:50
  • \$\begingroup\$ In fact, reading your specification a little more thoroughly, I don't believe that the patterns you are describing are really all that similar to the Android lock screen. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Mar 12, 2017 at 17:52
  • \$\begingroup\$ @WheatWizard It's similar - I have added the "closed loop" to the spec to increase difficulty and to sate my perfectionism. \$\endgroup\$ Commented Mar 13, 2017 at 23:01
  • \$\begingroup\$ You should still specify what types of moves are legal a little more thoroughly because there are a bunch of niche moves that can be done with the android lock screen that are not clear from your post. Especially if you change some aspects of the way they work. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Mar 13, 2017 at 23:07
1
\$\begingroup\$

Unary-binary trees

\$\endgroup\$
6
  • \$\begingroup\$ Suggestions numbered for ease of reference. 1. I think the notation would be clearer with 0 1 2 instead of t u b. 2. Ideally a question should be self-contained. There's plenty of room in the 30k character limit to explain what the trees are rather than relying on external links. 3. I would guess that answers should take a parameter n and enumerate the unary-binary trees M(n), but the question can also be interpreted as wanting infinite output of M(1), M(2), ... This should be explicit. \$\endgroup\$ Commented Mar 7, 2017 at 15:59
  • \$\begingroup\$ I'll going to make a moderately large edit reordering some stuff. If you don't like it you can revert it. \$\endgroup\$ Commented Mar 7, 2017 at 21:34
  • \$\begingroup\$ @PeterTaylor Thanks!!! Much appreciated. \$\endgroup\$
    – Guy Coder
    Commented Mar 7, 2017 at 22:11
  • \$\begingroup\$ You say the output format is flexible, but does it have to list the node type 0, 1, or 2 in some form? Could each node just be a list that contains 0, 1, or 2 sublists? \$\endgroup\$
    – xnor
    Commented Mar 7, 2017 at 22:20
  • \$\begingroup\$ It's always worth leaving something in the sandbox for at least 48 hours (longer at weekends) because other people might spot other ambiguities (as xnor has just demonstrated). \$\endgroup\$ Commented Mar 7, 2017 at 22:34
  • \$\begingroup\$ @GuyCoder No, I mean like [[[]][]] for (2 (1 0) 0). \$\endgroup\$
    – xnor
    Commented Mar 7, 2017 at 22:35
1
\$\begingroup\$

Image Quine

The challenge is to quite simply, output an image of the source code of your program exactly as it is.

Scoring is by shortest source code wins.

The image must visibly contain the source code, and no other characters or decorations.

Standard quine rules apply, so:
- No 0-byte solutions
- No reading the source code

This is just a draft, so I'll make it more detailed should it be good enough to post.

\$\endgroup\$
1
\$\begingroup\$

Block Puzzle

A popular brain teaser commonly known as a the "IQ Block Puzzle" is comprised of 8 colored shapes which can be rotated, moved and flipped on a 8x8 grid. The puzzle is known as a geometric magic square.

Block Puzzle

Challenge

The challenge is to generate and then output all 40 possible pattern combinations that the pieces can be placed in.

The output can be in any form, but must somehow represent the position of all pieces, for example:

Combination 1 of 40:

  11113333
  12213333
  12214444
  22555448
  22555448
  66657788
  66657788
  66777788

...

There will be a winner for both:

  • Shortest code in bytes
  • Fastest calculation of all shapes in ms
\$\endgroup\$
4
  • \$\begingroup\$ How can you beat a simple print statement? \$\endgroup\$
    – Blue
    Commented Mar 23, 2017 at 19:45
  • \$\begingroup\$ That looks interesting but may require additional specifications. For instance, do the 40 patterns include symmetrical/rotated solutions? Including the actual shapes of the pieces as ASCII (or whatever) rather than relying on the picture alone would also help. Otherwise looks good! \$\endgroup\$
    – Arnauld
    Commented Mar 23, 2017 at 19:47
  • \$\begingroup\$ I forgot: I don't think having two distinct winning criteria is a good idea. \$\endgroup\$
    – Arnauld
    Commented Mar 23, 2017 at 20:00
  • \$\begingroup\$ It should be clarified that the shapes in the sample output are the actual shapes that the program should operate with. Also, this doesn't work as fastest-code; it's highly likely to be fastest to hardcode the output (with the only interesting part of the challenge being the fastest way to output a medium-length constant string, which is actually non-obvious). \$\endgroup\$
    – user62131
    Commented Mar 24, 2017 at 14:35
1
\$\begingroup\$

Self-Generator

Challenge: Create a program that, given no input, outputs n programs (in the same language, but not necessarily the same language as the original program) separated by newlines, where each of those programs will print a section of the original program. When these sections are put together, it create the original program.

Your score is the number of bytes in the original program divided by (the number of sections that your code is split into) squared.

\$\endgroup\$
9
  • \$\begingroup\$ hm, this looks pretty interesting. The problem is, it may easily be won by a short answer with only a couple output programs. \$\endgroup\$
    – Riker
    Commented Mar 23, 2017 at 16:07
  • \$\begingroup\$ Good point. Do you have any scoring ideas? \$\endgroup\$
    – user42649
    Commented Mar 23, 2017 at 16:08
  • \$\begingroup\$ Not at the moment, sadly. I have a very similar one in the sandbox, it's been mostly abandoned for a while though. (not a dupe though, by any means) I've been trying to think of a scoring criterion, and I'll keep thinking for your post also. \$\endgroup\$
    – Riker
    Commented Mar 23, 2017 at 16:12
  • \$\begingroup\$ Also, this isn't code-golf. That tag is for pure bytecount scoring, not formulas. Doesn't matter if it's supposed to be a shortest program. \$\endgroup\$
    – Riker
    Commented Mar 23, 2017 at 16:12
  • \$\begingroup\$ @Riker Oh, okay. Thanks. And oh, I came up with the scoring system after putting the [code-golf] tag first... whoops... thanks for catching that! \$\endgroup\$
    – user42649
    Commented Mar 23, 2017 at 16:13
  • \$\begingroup\$ Perhaps square the number of sections? 20/3 is considerably less appealing than 20/(3**2) \$\endgroup\$ Commented Mar 23, 2017 at 16:36
  • \$\begingroup\$ @ETHproductions Perhaps that would be a better option. I'll consider that. \$\endgroup\$
    – user42649
    Commented Mar 23, 2017 at 16:38
  • 1
    \$\begingroup\$ I think in many languages just putting the standard quine on as many lines as you please would work just fine. You might want to do something to ensure that the parts of the program are unique (perhaps say that no section can be its own quine?) \$\endgroup\$ Commented Mar 23, 2017 at 17:45
  • \$\begingroup\$ Isn't it fairly easy to score zero in the limit here, with the squared sections? In most languages, simply writing n copies of a standard quine will give you a score of (length of the quine) / n (because each copy of the quine will output the quine itself, then each of those outputs will output itself (being a quine), thus all those outputs can be combined back into the original program). It might need a few tweaks for newline handling (e.g. adding a duplicate newline at the end of the program) but those are easy enough to make. \$\endgroup\$
    – user62131
    Commented Mar 24, 2017 at 14:32
1
\$\begingroup\$

Average of a tune


Often times when I'm bored, I'll find I have a catchy tune from a song stuck in my head. Then I notice the fingers on my right hand moving as if playing that tune on a piano. If I have nothing better to do, I'll spend some time calculating where on the scale I need to play so that all five fingers get optimal usage. For example, given the tune

C4 C4 G4 G4 A4 A4 G4 F4 F4 E4 E4 D4 D4 C4

I try to center the notes such that if they were weights arranged on a board, the board would balance on my middle finger. (That's probably not a tune I'd have stuck in my head, but you get the idea.) In this case, the notes can be arranged like so:

C4          G4
C4 D4 E4 F4 G4 A4
C4 D4 E4 F4 G4 A4
=================

Now we have to balance the board. If the fulcrum is placed under E4, it will be equivalent to summing the following weights:

-2          +2
-2 -1  0 +1 +2 +3
-2 -1  0 +1 +2 +3

The result is +6, indicating that the board is leaning to the right. So we try moving right so that the fulcrum is under F4, which gives us the following:

-3          +1
-3 -2 -1  0 +1 +2
-3 -2 -1  0 +1 +2

The sum is -8, indicating that the board is leaning to the left, and also leaning further than it had before; therefore, the optimal middle note is E4.

By this point I've usually wasted all the time I had at my disposal, plus a good bit more. So your task is to write a program or function that does this calculation for me. Since I have more important things to waste my memory on, your code should be as short as possible.

Task

Write a program or function which takes in a list of notes and outputs the average of these notes.

  • Only notes on the scale of C major (C, D, E, F, G, A, B) should be taken into account; you never need to deal with sharps or flats.
  • The notes can range from C0 to B9, inclusive; you'll never get A-1 or C12.
  • The input can be given as an array, or as a string separated by spaces, newlines, commas, etc.
  • The input will always contain at least one note.
  • Input/output can be given in whichever case is desired. If your code only accepts one case or the other, make a note of this in your answer.
  • If there are two valid outputs for a given input, you may output either or both.

Test cases

Input -> Output(s)
C3 -> C3
C0 -> C0
B9 -> B9
C3 C3 -> C3
C3 D3 -> C3 or D3
C3 E3 -> D3
C0 B9 -> B4 or C5
C3 C3 C3 -> C3
C3 C3 D3 -> C3
C3 C3 E3 -> D3
C4 D4 E4 F4 -> D4 or E4
E4 E4 E4 C4 E4 G4 G3 -> D4
C3 D3 E3 F3 G3 A3 B3 C4 -> F3 or G3
C3 C3 E3 F3 G3 A3 B3 C4 -> F3
A3 A3 A3 C4 A3 A3 A3 A3 G3 F3 E3 -> A3
C5 D4 C4 C5 D4 C4 A4 C5 D4 C4 C5 D4 C4 -> F4
C4 C4 G4 G4 A4 A4 G4 F4 F4 E4 E4 D4 D4 C4 -> E4
E3 E3 F3 G3 G3 F3 E3 D3 C3 C3 D3 E3 E3 D3 D3 -> E3
C4 C4 E4 E4 A3 A3 C4 C4 F3 F3 A3 A3 G3 G3 B3 B3 -> B3
C3 C3 E4 E4 A2 A2 C4 C4 F2 F2 A3 A3 G2 G2 B3 B3 -> E3
A3 A3 A3 G3 A3 A3 A3 B3 B3 C4 C4 C4 B3 C4 G4 G4 B3 B3 -> B3
G3 G3 A3 G3 C4 B3 G3 G3 A3 G3 D4 C4 G3 G3 G4 E4 C4 B3 A3 F4 F4 E4 C4 D4 E4 -> B3
B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 A6 -> A9

(Imaginary bonus point for each song you recognize)

Scoring

Since this is , the shortest code in bytes in each language wins.


Sandbox questions

  • Is there a plain "average of an array of integers" challenge, and would this be a duplicate?
  • Is anything unclear, or does any information need to be added?
  • Suggestions for a title? I feel like there's a "tuna fish" pun waiting to be made...
  • Suggestions for test cases?
\$\endgroup\$
0
1
\$\begingroup\$

Multiplivision

Hopefully a nice simple challenge that's not trivial.

Given an input list of positive integers, alternately multiply and divide them to yield a single numerical answer, according to the following rules:

  • start with the first number;
  • with the remaining numbers, alternate between dividing and multiplying, one at a time (that is, in a left-associative way), with the last operation being multiplication

For example, the input {3, 4, 2, 7} would start with 3, then successively compute 3 * 4 = 12, then 12 / 2 = 6, then 6 * 7 = 42 and output 42. (In other words, the input {3, 4, 2, 7} yields the output (((3 * 4) / 2) * 7) = 42.) The first operation had to be a multiplication, because if we'd started with a division, then the last operation would have been division as well, which isn't right.

If the answer is not an integer, then it can be output either as an exact fraction, or as a decimal equivalent, accurate to at least 6 significant figures (either truncating or rounding the end of the decimal is fine). For decimals that terminate before 6 significant figures, either the terminating decimal alone (1.5) or a version with trailing zeros (1.50000) is fine.

Other test cases (only the numerical answer needs to be output, not the intermediate parsed expression):

{3} -> 3
{3, 4} -> 3 * 4 = 12
{3, 4, 2} -> 3 / 4 * 2 = 3/2 or 1.5
{5, 4, 3, 2} -> 5 * 4 / 3 * 2 = 40/3 or 13.3333
{1, 2, 3, 4, 5, 6, 7, 8} -> 1 * 2 / 3 * 4 / 5 * 6 / 7 * 8 = 128/35 or 3.65714
{42, 42, 42, 42, 42, 42} -> 42 * 42 / 42 * 42 / 42 * 42 = 1764
{42, 42, 42, 42, 42, 42, 42} -> 42 / 42 * 42 / 42 * 42 / 42 * 42 = 42

This is , so the shortest code in bytes wins! Golfed answers in all languages are welcome.

\$\endgroup\$
3
  • \$\begingroup\$ accurate to at least 6 significant figures (including decimals that terminate before the 6th significant figure) In the 3rd test case, shouldn't it then be 1.50000 as it has to be 6s.f.? \$\endgroup\$
    – Thunda
    Commented Mar 29, 2017 at 3:21
  • \$\begingroup\$ thanks, clarified above \$\endgroup\$ Commented Mar 29, 2017 at 3:22
  • \$\begingroup\$ In most languages that happens automatically, I really don't think it's necessary \$\endgroup\$
    – Thunda
    Commented Mar 29, 2017 at 3:40
1
\$\begingroup\$

King of the Hill: Risk(k)

We all know these well spend evenings where family members and friends got to temporary enemies while playing Risk the board game. The rules are not so complicated, the world is divided in territories on 6 different continents. enter image description here The different players take control over those territories and afterwards play to conquer the neighbors, form alliances and betray each other until one player reaches world domination.

But wouldn't it be cool, if you just write a bot for you to play this game? here comes your chance.

This is a King of the Hill challenge to write the best bot to play Risk(k). Like in the original game (but not entirely) the world is divided into 6 continents with a total of 41 territories. Afterwards the bots will play this game with reduced rules in a round-based setting. Your bot can be written in or . Although any other language is possible which is capable of producing a dll with cdecl-functions or to implement interfaces. The controller can be found on Github.

enter image description here

A short classis-game explanation

For all of you, who aren't familiar with this game. Every player plays on his own against all other players. The game begins with the claiming of territories (by positioning a single unit there) which is done consecutively for every player until all territories are owned by a faction. Now the players get the chance of using all units they have left to enforce their territories. Now the game begins round-wise. Every player makes a Attack-Stage and Move-Stage. In the attack-stage the players can attack other territories. This is done with dices. When thrown (the attacker and defender), the dices on each side are ordered and the highest ones are compared to each other. Whoever has the higher dice destroys a unit of the opposite side. Equal dices are considered a tie and no unit dies. You can only attack with max. 3 units at the same time, even when you have more than 3 units on your attacking territory. Also a territory with one unit cannot attack to prevent territory loss. Likewise a territory with two units can only attack with one etc. . When a territory falls to zero units, the attacking territory has to send units over (at least on and max. all except one - in the controller, all units except one are send automatically). After the attack stage, one player gets the chance to move units in the Move-Stage. One can only do so, if the territories you want to move units between are connected by territories owned by you. If your are done with this, the next players turn begins. The game ends, when one player has conquered the whole world.

The game&rules:

  • All bots have to obey the rules. Cheating bots will be punished by the program or by me. Standard loopholes are forbidden.
  • Each bot must be in a dll file (name.dll) in the same directory, as the controller.
  • Each program with the c++ interface must end with name.cpp.dll
  • When the program is started each bot gets loaded into the program and is checked if everything works. The bots get instantiated only one time when the game starts.
  • All bots loaded are participating in the game.
  • The initialization stage begins:
    • Each bot gets asked through the interface about its name and color.
    • All bots get introduced to another with their names.
    • All bots get consecutively called to select one of the remaining free territories. This goes till no territory is free anymore.
    • All bots get to distribute the units left to all territories. [UnitCount = Ceil(82 / BotCount) ]
  • The game will stop for now till the user pushes the start-button.
    • The game will be round based where each bot will get consecutively called in four stages: Strategy-Stage, Enforcement-Stage, Attack-Stage, Move-Stage
    • The Strategy-Stage gives your bot the opportunity to plan a strategy for this round.
    • The Enforcement-Stage will give your bot the opportunity to distribute all new units to your territories. Units are gained to: Count of owned territories divided by 5 and floored, continent-bonus (owning a whole continent: North America: +5, South America: +2, Europe: +5, Africa: +3, Australia: +2, Asia: +7), capital-bonus (+1 for each owning of: East US, Brazil, North Europe, South Africa, East Australia, China) and +1 if you conquered a territory last round. You're guaranteed to get at least one new unit per round if your bot is still alive.
    • In the Attack-Stage you can order the program do make attacks on enemy territories which can lead to loss on your or the enemy side or you conquering a new territory. The attack will be called multiple times (max.: 100 times) as long as you make an attack every call.
    • In the Move-Stage you can move units around owned, connected territories. You can also again plan your strategy there for the next round.
    • Each round is time constricted for every bot with 200ms. Taking longer than this will lead to a punishment (suspension) for the next round.
  • The game ends when only one bot still lives or when two bots get into an infinite loop (which is surprisingly possible and not rare for the random-bots)

The controller&interface

How the interfaces work is explained in the template files and the example-bots.

For c#, .NET Programmer

Your bot has to be in a class which inherits and fully implements the IBotInterface. The class must be compiled into a class-library (dll). Afterwards you can just copy your dll into the game-directory and start the game.

EmptyBot is an empty template which implements the minimum required and adds a lot of useful helper-methods. It can be used as a template.

RandomBot is a bot which implements random behavior in all functions and stages. It acts as a full working example.

For C++, C, cdecl-function-able-languages

Your dll must implement eight functions with an external definition and cdecl-calling convention. A minimal implementation can be looked at at EmptyCPPBot.

Your dll can afterwards be copied into the game-directory which can be started normally afterwards. Your dll must have the following name structure: nameOfYourDll.cpp.dll to distinguish it from the managed dll's.

RandomCPPBot is a bot which implements random behavior in all functions and stages. It acts as a fully working example.

Contest Rules

  • Players may submit multiple bots and are free to edit them to the deadline.
  • A submission must be made as an answer on this thread. The source code can come in pieces, as full project, single file or whatever. And may be provided via download, push request or simple pasted code in the answer with code-tags. If not compile-able with Visual-Studio, i request fairly simple instructions how to compile it myself.
  • A submission must specify the name and color of the bot. Although not necessary, an explanation of the bot's strategy would be nice.
  • Bots are not allowed to use sources outside the dll/program (no files, no webrequest or similar things).
  • Bots must be compatible with the provided interface and work under windows. Custom interfaces are not explicitly forbidden as long as they don't generate a advantage or are not compatible with the main-interface/program.
  • The competition will be held in the provided controller (possible altered to automate the process) with all pairings possible to find the best 4 bots.
  • The last 4 bots are fighting each other in 10 games. The bot which has won the most, wins the tournament. In a tie situation, the bots will take a single match against each other (golden goal), until one wins.
  • Rules are can be changed when necessary which would be introduced on top of this thread.
  • The contest ends when a week long no new submissions got made or when I say, its time to end this.
  • And again, just to be sure: standard loopholes are forbidden.
\$\endgroup\$
4
  • \$\begingroup\$ How do you organize players into games, how do you score a single game, and how do you aggregate those scores? When are you instantiating each bot (only once for the tournament, once for each game, or once for each method call?) I'd recommend describing the rules of risk in full for those poor souls that don't know them. \$\endgroup\$ Commented Mar 30, 2017 at 21:45
  • \$\begingroup\$ I added a relative "short" description of the classical game. Also I added the answer to all your question into the thread but i'll also anwser it here: 1. All players in the game directory are participating. The tournament will provide automatic pairings if necessary. 2. You score a single game by letting your bot win it. 3. You can't. But you can restart infinitely often. 4. All bots are instantiated on the start of the program. But i could change that to the start of every game (so a reload also instantiate the bots new). \$\endgroup\$ Commented Mar 30, 2017 at 22:35
  • \$\begingroup\$ 1. What if there are lots of players (10 or even 20?). How would you automatically pair? 2. So the second to last survivor gets the same number of points as the first one to die? What happens if there's an infinite loop? 3. You have to come up with some way to combine the scores across multiple games. 4. Are you OK if submissions store data across games? How do submissions know when a new game starts? \$\endgroup\$ Commented Mar 30, 2017 at 22:46
  • \$\begingroup\$ Risk is a famously unbalanced game in which luck is very important. To balance that out you'll need to play hundreds of games per match-up. Each game involves thousands of player decisions. I would not be surprised if it ends up taking a week to run the tournament, and part-way through that week someone might submit a new bot. \$\endgroup\$ Commented Mar 31, 2017 at 12:31
1
\$\begingroup\$

Check for repeated repeated words

Task

Your code should either read in a stream/file containing printable ASCII text or define a function that takes a string containing printable ASCII and output any repeated words (including their repetitions). If you read from a file then it can have a name of your choice. Output can be a single linefeed-separated string, or a list of strings (one per repeated word).

A word is defined by the regex [0-9A-Za-z'-]+, i.e. it's a run of letters, digits, apostrophes and/or hyphens.

A word is considered to be repeated if it occurs twice or more in succession, separated only by one or more spaces. Repetition is case sensitive: WORD, Word and word are all different.

Test Cases

Individual test cases are separated by an empty line. For each test case, the first line is the input, subsequent lines are the output. Note that the last test case does not contain any repeated words.

Hello how how are you?
how how

Hello my my friend. Is that that your pen pen pen?
my my
that that
pen pen pen

This is not. not a case of repeated? repeated words! Neither neither is this. 

\$\endgroup\$
6
  • \$\begingroup\$ Why do you disallow functions? \$\endgroup\$
    – mbomb007
    Commented Mar 31, 2017 at 16:08
  • \$\begingroup\$ @mbomb007 I don't :) \$\endgroup\$
    – user9206
    Commented Mar 31, 2017 at 16:13
  • \$\begingroup\$ "No other ways of getting input are allowed." Which means function arguments. \$\endgroup\$
    – mbomb007
    Commented Mar 31, 2017 at 16:16
  • \$\begingroup\$ @mbomb007 That text shouldn't have been there. Thanks. \$\endgroup\$
    – user9206
    Commented Mar 31, 2017 at 16:23
  • 3
    \$\begingroup\$ If underscores aren't a valid word character for this challenge, you'll want to add a test case that has underscores. I can see a lot of regex submissions being based on \w otherwise. \$\endgroup\$
    – DLosc
    Commented Mar 31, 2017 at 17:17
  • 1
    \$\begingroup\$ REgex would would win \$\endgroup\$
    – user63187
    Commented Mar 31, 2017 at 20:28
1
\$\begingroup\$

Island Golf #3: Random Generation

Given the dimensions of a rectangular patch of ocean and the desired number of land tiles, randomly generate a valid island of that many tiles within that rectangle.

Input

Your input will be three positive integers:

  • w, the width of the grid
  • h, the height of the grid
  • n, the number of tiles to make the island

w and h will always be 3 or greater. n will always be 1 or greater. Also, n will be small enough to fit inside the grid allowing for a border of water tiles: specifically, n <= (w-2)*(h-2).

Output

Your code must output a w by h rectangular grid consisting of two characters, representing land and water. (In the examples below, land is # and water is ., but you may substitute any two distinct characters you wish.) There must be exactly n land characters, in one contiguous block, representing an island. For example, an input of w=11, h=9, n=40 might result in the following output:

...........
...##......
..#####....
..#######..
.#########.
...#######.
...#####.#.
....####...
...........

Requirements:

  • The land tiles must all be contiguous (i.e. there's only one island).
  • Land tiles can be connected horizontally or vertically, but not diagonally.
  • The water tiles must also be contiguous (i.e. there must not be any lakes).
  • The outer border of the grid must remain as water tiles.

Some illegal outputs:

.....
.#.#.   Multiple islands
.....

....
.#..    Diagonal connection
..#.
....

......
.####.  Contains a lake
.#.##.
.##...
......

....
.###    Border contains a land tile
.##.
....

Details

Your solution may be a full program or a function. Any of the default input and output methods are acceptable. Any of these definitions of randomness are acceptable. Every valid island for a given input should occur with nonzero probability.

You may take the input numbers in whatever format and base is convenient for your language. You may take the three numbers in any order.

Your output may be a multiline string, a list of strings, or a 2D array/nested list of characters/single-character strings. Your output may (optionally) have a single trailing newline. As mentioned above, you may use any two distinct characters in place of #..

Please mention any unusual I/O methods/formats in your submission, so others will be able to test your code more easily.

Test cases

Given as width, height, size. Note that the first three test cases specify islands of maximal size for the given width and height.

3, 3, 1
9, 3, 7
5, 5, 9
5, 5, 1
10, 10, 60
80, 22, 1100

Validation program

Here is a validation program in Pip to test whether your output for a given input meets the spec. It expects the three parameters and an island in the format given in this question; for example:

5, 5, 9
.....
.###.
.###.
.###.
.....

If your code has a different output format, you'll need to convert it to this format before plugging it into the validation program.


Sandbox questions:

  • This seems like a pretty obvious random-generation challenge, but I didn't find a duplicate in a quick readthrough of previous challenges. Did I miss anything?
  • Should I add more stringent rules on what counts as random? Related reading
  • Should I allow output to be a 2D array (or nested list) of any two distinct values, not just chars and single-char strings? (E.g. integers 0 and 1, booleans false and true, etc.)
\$\endgroup\$
1
  • \$\begingroup\$ To the downvoter, if you see this: What's your reason for downvoting? If it's something I can improve about the challenge, I'd like to know so I can improve it. \$\endgroup\$
    – DLosc
    Commented Apr 6, 2017 at 1:28
1
59 60
61
62 63
157

You must log in to answer this question.

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