Sandbox for Proposed Challenges

Question

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".

Answer 1

Just repeat yourself

Write a program that outputs "Do not repeat yourself!"

Your program code must respect the following constraints :

• its length must be an even number
• each character that is in position 2n (where n is an integer > 0) must be equal to the character in position 2n-1. The second character of the program is equal to the first, the fourth is equal to the third, etc.

Examples:

HHeellllooWWoorrlldd is a valid program

123 or AAABBB or HHeello are incorrect

This is code-golf, so the shortest code wins!

Answer 2

The shortest code for testing reliable password ( for Vault Password Rank 3 puzzle )

Introduction

I started playing Empire of Code recently, and there was some challenge. The player is supposed to write a code on a python or on javascript to detect if passed string is reliable password, that is, contains at least one lowercase Latin letter, one uppercase Latin letter and one digit and has at least 10 characters.

It was quite easy for me to fit in 130 characters limit for rank 3 using javascript, however, I spent a lot of time trying to fit in 100 characters limit for rank 3 using Python. Some guy said that he has managed to fit in 71 characters for Python. I was trying hard but still couldn't reduce the code less than 90 characters. Is it possible to use even less than 71 character?

Challenge Vault Password [ the following description is mostly copied from https://empireofcode.com/ ]

We've installed a new vault to contain our valuable resources and treasures, but before we can put anything into it, we need a suitable password for our new vault. One that should be as safe as possible.

The password will be considered strong enough if its length is greater than or equal to 10 characters, it contains at least one digit, as well as at least one uppercase letter and one lowercase letter. The password may only contain ASCII latin letters or digits, no punctuation symbols.

You are given a password. We need your code to verify if it meets the conditions for a secure password.

In this mission the main goal to make your code as short as possible. The shorter your code, the more points you earn. Your score for this mission is dynamic and directly related to the length of your code.

Input: A password as a string.

Output: A determination if the password safe or not as a boolean, or any data type that can be converted and processed as a boolean. When the results process, you will see the converted results.

Example:

golf('A1213pokl') === false

golf('bAse730onE') === true

golf('asasasasasasasaas') === false

golf('QWERTYqwerty') === false

golf('123456123456') === false

golf('QwErTy911poqqqq') === true

Precondition:

0 < "password| ≤ 64

password matches by regexp expression "[a-zA-Z0-9]+"

Scoring:

Scoring in this mission is based on the number of characters used in your code (comment lines are not counted).

Rank1:

Any code length.

Rank2:

Your code should be shorter than 230 characters for Javascript code or shorter than 200 characters for Python code.

Rank3:

Your code should be shorter than 130 characters for Javascript code or shorter than 100 characters for Python code.

How it is used:

If you are worried about the security of your app or service, you can use this handy code to personally check your users' passwords for complexity. You can further use these skills to require that your users passwords meet or include even more conditions, punctuation or unicode.

Answer 3

Compute factorials code-golf

In the style of the Hello, World! catalog, this question is a collection of the shortest programs that compute a factorial (a common task for new programmers) in any given language.

Specifications

Your program must take a positive integer as input from STDIN, and output the corresponding factorial to STDOUT (or your language's closest alternatives).
Your program must also accept the special case of 0! = 1 if 0 is entered. No negative numbers will be entered.

Your program must handle numbers up to 40 factorial (8.159152832×10⁴⁷). Sandbox question: Is 40 factorial too large a minimum requirement? I was also considering 50 factorial is 40 is too small.

Test Cases

3
6

6
720

0
1

11
39916800

Additional Rules

• This is not about finding the language with the shortest approach for computing factorials, this is about finding the shortest approach in every language. Because of this, no answer will be marked as accepted.

• Submissions are scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8. For example, Piet is scored in codels rather than bytes. If you're not sure how your language is scored, you can ask on Meta.

• Nothing can be printed to STDERR.

• Feel free to use a language (or language version) even if it's newer than this challenge. If anyone wants to abuse this by creating a language where the empty program computes factorials, then congrats, you've just created a boring answer.

• Your language must have a valid way to test your program (through an interpreter, compiler, etc.) If there aren't any, you can write one yourself.

• Standard loopholes are disallowed except where specified by these rules.

leaderboard snippet will be added once this challenge is posted

Answer 4

Golf a game of Nim

Similar to my previous Write the shortest game of Alak challenge, this time you have to golf another simple game - Nim.

You may already know how to play, but if you don't, here are the rules:

• In Nim, two players take turns removing objects from heaps (piles).
• Each turn, one player removes at least one object from any heap.
• You can take as many objects as you want, provided they all come from the same heap.
• You can take from any heap you want, but you can't take objects from two different heaps in the same move.
• The player to take the last piece(s) wins.

There are 3 heaps, each starting out with a random number of objects between 2 and 20.

Input

Input is in the form of two numbers - a heap number and the number of objects to take from that heap.
For example, the input 1 2 means "take 2 objects from heap #1".

Output

Every turn, the program must print to STDOUT (or your language's closest alternative) the amount of objects in each heap. (This includes at the start of the game.)
For example, if there were 5 objects in heap #1, 2 objects in heap #2, and 0 objects in heap #3, you would output this:
5 2 0
When one player wins by taking the last piece(s), you have to output P# wins and end the game, where # is the number of the player who won (1 or 2.)

Assumptions

• Input will always be in the form of Heap# Amount. Any invalid input can be handled however you like.
• The input will never ask to take from a heap that doesn't exist, or take more objects than a heap contains.

Questions for Meta

• Are there any loopholes?
• Should the sizes of each heap be set, rather than random?
• Should there be a random number of heaps?
• Should programs have to handle taking objects from non-existent heaps, or more objects that a heap has?
• I'm 99% certain I've covered everything, but have I left out any rules of Nim?

Answer 5

Cookie Clicker

Cookie Clicker: Simple, stupid, and yet strangely addictive. In it you must click a cookie (hence the title). Once you have enough cookies, you can spend them on items that will produce cookies for you. Eventually you will be getting hundreds, then thousands, then millions of cookies per second.

There are a few different items that you can buy for cookies: A clicker (that clicks the cookies for you), a grandma (that bakes the cookies for you), a farm (that grows cookies for you), a factory (that mass produces cookies for you), a mine (that will mine and process veins of dough for you), a shipment (that ships cookies from other planets to you), an alchemy lab (that transforms gold into cookies), and others that we won't worry about.

Let's golf a simplified Cookie Clicker.

Challenge

Write a full program. Your program should always display the number of cookies as a whole integer. Every second, your program should add the current cookies per second (defaulted to 0) to the cookie count.

• When the spacebar is pressed, it adds the base click amount (defaulted to 1) to your cookie count.

• When the key "1" is pressed, if there are 10 or more cookies in the cookie count, subtracts the cookie count by 10 and adds 0.1 to the current cookies per second.

• When the key "2" is pressed, if there are 100 or more cookies in the cookie count, subtracts the cookie count by 100 and adds 0.5 to the current cookies per second.

• When the key "3" is pressed, if there are 500 or more cookies in the cookie count, subtracts the cookie count by 500 and adds 4 to the current cookies per second.

• When the key "4" is pressed, if there are 3,000 or more cookies in the cookie count, subtracts the cookie count by 3,000 and adds 10 to the current cookies per second.

• When the key "5" is pressed, if there are 10,000 or more cookies in the cookie count, subtracts the cookie count by 10,000 and adds 40 to the current cookies per second.

• When the key "6" is pressed, if there are 40,000 or more cookies in the cookie count, subtracts the cookie count by 40,000 and adds 100 to the current cookies per second.

• When the key "7" is pressed, if there are 200,000 or more cookies in the cookie count, subtracts the cookie count by 200,000 and adds 400 to the current cookies per second.

• When the key "0" is pressed, if there are 50 or more cookies in the cookie count, subtracts the cookie count by 50 and adds 1 to the base click amount.

There is no input, only output, being changed every second to update the cookie count. No other key should do anything, so you cannot press enter after every key and have it do something.

Other information

• This is code golf so shortest program in bytes wins.

Thoughts for sandbox

• There are many, many more features I could add to this challenge if it is too simple. I feel that challenge entries for this will already be long enough.

• I do not see many challenges that ask for constant input. Does this mean that this challenge is a bad idea?

• Have I crossed a line?

Answer 6

This is a raw draft about an idea for a popularity contest. Any input would be appreciated.

My watch, it has two buttons

I have this watch with two buttons and a display that can show six characters split into groups of two by colons like this

12:34:56

Each character is displayed by a 5x7 LCD-Matrix, so arbitrary ASCII-characters can be displayed.

I'd like to call the buttons "select" and "modify".

The problem is that the watch is dead. It needs a new operating system.

Since I'm not very trained at designing operating systems I want you to write an emulator for my watch. The emulator should be programmable using the following commands.

• big letters A-Z represent short presses of "select" the corresponding number of times.
• small letters a-z have the same meaning for the modify button.
• < represents keeping "select" pressed for half a second (or something like that).
• > represents the same for the modify button.
• numbers in the code mean to wait for that number of hundredth of seconds.

You're free to program any kind of functionality into my watch, but it should at least be usable as a watch showing the time and as a stopwatch showing minutes, seconds and hundredth of seconds.

One thing I know about my watch is that it can be programmed to receive data from my stdin and send data to my stdout. So once the operating system is installed I could send data and a program to the watch and print the results of the execution to my console.

Answer 7

Spot the differences

Little Timmy is waking you up on this Saturday morning once again to help him solve his puzzles. You love the little bugger, but those Spot the Differences games are starting to undermine your patience. Like always, you plan to delegate this tedious task to Robotic Dad™ so you can better spend your time... planning for your child education? Yeah, I think that was the plan.
Anyway, you tell Timmy not to worry, that you're going to help him soon enough, grab a beer and sit in front of your computer to help your child solve those puzzles, once and for all.

Your task is to write code that will take two similar pictures which differ in a few spots and somehow output the differences between them. The format of the output is free, however a 5 year-old child should be able to get it.

Here are examples of input :

Since there is no formally defined output, this is a popularity-contest.
Please also keep in mind that you'd like to spend a little time sipping your beer calmly in front of your computer. In this regard, built-in solution should be regarded less highly.

---

Meta : I plan to post a community answer as an example output, linking to the http://franklinta.com/2014/11/30/image-diffing-using-css/ article which made me think of this challenge and using a snippet to illustrate it. Is it enough?

Answer 8

Sudoku with handicap

code-golf code-challenge

Note: I've completely reworked this, as the comments convinced me that there's not a good way to describe the restrictions I originally was after in a language-independent way without unreasonably restricting languages. Thanks to all the commenters.

I now reworked the question in a way that also inhibits traditional recursive solving (at least doing so in a straightforward way), and at the same time even allows to add a metrics about the "efficiency" of the algorithm. The basic idea being that your program is called not once, but many times, each time only having limited information about the field.

Also note that this new version requires me to write a driver program; so the question cannot go live until the driver program is written.

Questions are set in italics inside the text

The goal of this challenge is to solve a given Sudoku. However there's a twist: The program cannot access the full board at any time. Instead it is called repeatedly, and each time it has only limited information about the board. I'll refer to the totality of all calls as the "calling loop". The program can then request different information for the next run, or declare that it is finished (that is, request to not be called again; the call loop is terminated).

The only way to pass information between different runs is through the Sudoku board, and a small amount of scratch space. The Sudoku board is initialized before the first call with the Sudoku to solve (obviously) and is then checked after the call loop terminated. During the call loop, the Sudoku board is not checked, so you may "abuse" it to store additional information, as long as at the end, a valid result is generated.

Since it may not be possible to completely solve all Sudokus using such an algorithm, the only hard requirement is that the call loop is guaranteed to eventually terminate, the Sudoku field after termination is in a valid state. The rest is covered by scoring.

Standard loopholes are explicitly disallowed.

The stored data

The data that is stored outside the program consists of 90 nine-it unsigned numerical values (that is, minimal nmumber 0, maximal number 511), 81 of which represent the Sudoku field, and 9 values are scratch space. The values of the field are interpreted as bit fields, as described below.

In the following I'll use as example the Sudoku field

4.5|.7.|89.
..2|.5.|6..
..7|9..|542
---+---+---
..3|5.6|489
...|3.8|...
684|7.9|1..
---+---+---
238|..5|9..
..6|.9.|3..
.79|.3.|2.1

where dots contain fields that have not been filled.

Initially, the data gets filled as follows:

• Each field pre-filled with number $n$ is represented by the value $2^{n-1}$, that is, the bit corresponding to that number is set, and all other bits are unset.

• The unfilled fields are represented by the value $511$ (that is, all nine bits are set).

• The scratch space is filled with $0$.

After the run loop terminates, each pre-filled field needs to have the same value as initially, and each initially empty field must have at least the bit corresponding to the correct solution set. That is, every zero bit represents a value that your program excluded for that field, and a program that excludes the correct solution is disqualified.

The contents of the field is only evaluated at the end of the call loop. So in between your program is free to make creative use of the storage space given.

The input

The program receives its data through standard input of the following form:

The first line contains a description of which data is given to/set by the program in this run. It consists of one to three space-separated words from the following list. On the first run, it is just "S". At later runs, it is exactly what the program requested at its previous run.

The possible values and corresponding interpretation are:

• R1 to R9: The indicated row of the Sudoku, 1 being the uppermost row.
• C1 to C9: The indicated column of the Sudoku, 1 being the leftmost column.
• F1 to F9: The indicated $3\times 3$ subfield of the Sudoku, numbered left to right, up to down. So for example 1 denotes the upper left subfield, 6 denotes the middle right subfield.
• S: The scratch space.

The next one to three lines contain the corresponding data, from left to right, and from up to down, as space separated decimal numbers.

So at the first run, your program will receive the input

S
0 0 0 0 0 0 0 0 0

At the second run with the example Sudoku field, the input to your program might be:

R2 C3 F4
511 511 2 511 16 511 32 511 511
16 2 64 4 511 8 128 32 256
511 511 4 511 511 511 32 128 8

Output

The first one to three lines are the new values to replace the ones given in the input. The number of the lines must be the same as the number of fields in the first input line, and each line must contain nine values separated by whitespace (leading/trailing whitespace gets ignored).

If some field appears in more than one data line, the corresponding values are bitwise anded together. For example, if the initial line of your program's input was

R1 C1

and the first two line of your output read (with question marks replacing values that are irrelevant for this example — of course your code may not actually output question marks here)

3 ? ? ? ? ? ? ? ?
5 ? ? ? ? ? ? ? ?

then the upper left value us the Sudoku storage field will be 3 & 5, that is, 1

Following those data lines, there will be a single line containing either the single word STOP, in which case the run loop is terminated and the resulting field is created, or a line containing one to three whitespace separated words requesting data to be served in the next run, that is, the words to be presented in the first line of the next run of the program.

Scoring:

The score for qualifying entries is calculated as follows (lower score is better):

• You get 1 score point for each run of your program.
• You get 5 score points for each set bit in the final representation of your Sudoku field
• At the end, subtract 45 (because a perfectly solved Sudoku will have nine bits set; if your program leaves less bits set, it will be disqualified anyway).

The total score is then calculated as weighted mean of the test cases, where the difficulty is used as weight, rounded up to the next integer. That is, if $d_k$ is the difficulty assigned to test case $k$, and $S_k$ is the score you achieved at test case $k$, your total score is $$S = \left\lceil \frac{\sum_k d_k S_k}{\sum_k d_k}\right\rceil$$

Sandbox question: Should I change the relative weight of program runs versus unsolved fields? And is the difficulty weighting a good idea, or should I simply add up all scores?

Test cases:

(Hardness as reported by GNOME Sudoku)

Test case 1: Easy (0.17)

4.5|.7.|89.
..2|.5.|6..
..7|9..|542
---+---+---
..3|5.6|489
...|3.8|...
684|7.9|1..
---+---+---
238|..5|9..
..6|.9.|3..
.79|.3.|2.1

Solution:

415|672|893
892|453|617
367|981|542
---+---+---
723|516|489
951|348|726
684|729|135
---+---+---
238|165|974
146|297|358
579|834|261

Test case 2: Hard (0.63)

.6.|52.|..8
7..|...|9.2
.82|71.|56.
---+---+---
.59|...|..6
.76|...|14.
8..|...|72.
---+---+---
.18|.36|25.
6.3|...|..1
5..|.41|.9.

Solution:

961|524|378
745|683|912
382|719|564
---+---+---
159|472|836
276|398|145
834|165|729
---+---+---
418|936|257
693|257|481
527|841|693

Test case 3: Very hard (0.96)

.35|.94|...
..8|.53|..9
4..|8..|...
---+---+---
..1|9..|.85
..9|1.5|3..
54.|..8|9..
---+---+---
...|..7|..1
6..|58.|7..
...|41.|82.

Solution

135|294|678
268|753|149
497|861|532
---+---+---
371|946|285
829|175|364
546|328|917
---+---+---
982|637|451
614|582|793
753|419|826

Sandbox question: Should I add more test cases?

Answer 9

The Drunken Knight

code-golf markov-chain

Inputs

• a: Starting location of the knight, e.g. A2
• b: Target location of the knight, e.g. B4. The starting and target locations may be the same.
• n: An integer equal to or greater than 0.

Output

The probability that a knight starting at a, moving at random for n turns on an 8x8 board, ends at b.

Notes

• The knight has equal probability to move to any of the squares which it can access.
• There are no other pieces on the board that could block any squares from the knight.

Answer 10

Cops and Robbers: Text Transformations

Cops' challenge

The cops must write a fully deterministic program that reads input from STDIN and writes output to STDOUT as its only side effects. The mapping from strings to strings performed by this program will be called f.

A cop's post consists of such a program's source code, along with its length and the name of the language the program is written in. The poster must also prepare a possible crack (see below), and release it when their post is safe. A cop's post is safe when it remains uncracked for exactly two weeks.

A safe post where the original code is n bytes long is worth 1/n² points. The author with the highest point total wins. The tiebreaker is popularity (sum of votes of answers in the robbers' thread.)

A single author may not use the same language twice in two different cop answers.

Robbers' challenge

To crack a cop's post, a robber must figure out which transformation f the program in the post is performing, and write a program P in the language used by the cop, so that both P and f(P) perform the transformation f.

The length, method, or complexity of P are irrelevant; as long as is produces the same output as the cop's original code for any input you pass it, the solution is valid.

Successfully cracking a cop's post is worth one point. The author with the highest point total wins. The tiebreaker is popularity (sum of votes of answers in the robbers' thread.)

---

This is a bit hard to conceptualize, so here's a very simple example.

If the cop's post is:

Python 3, 20 bytes

print(input()[::-2])

(i.e., reverse STDIN and remove every other character) The robber's answer might be:

print(input()[::-2])# ) ] 2 - : : [ ) ( t u p n i ( t n i r p

as passing this program as input to itself yields a new program that does the same thing:

print(input()[::-2])#]-:)tpitip

As another example, if a cop writes a C++ program that rotates lines on STDIN by 90 degrees, a valid solution is a C++ program that also rotates lines by 90 degrees, and does the very same thing if you rotate it by 90 degrees.

---

The difficulty for cops is to come up with transformations that are short to express, but difficult to code around (and, of course, they essentially have to crack their own post -- but at least they know f in advance.)

The difficulty for robbers is to decipher the cops' solutions to find out which transformation f they're performing, and then write any program P such that both P and f(P) perform f.

Answer 11

Watermelon Contest

king-of-the-hill

You and your buddies are contesting a lone piece of watermelon left in the middle of the table. You decide to make a program to contest for you.

The Goal

You want to be the last program standing. Then you get the watermelon.

The Process

Every iteration 1 program will be eliminated from the watermelon contest. This will be decided by a vote among all the remaining programs. This means that your program will have 1 and only 1 vote to spend on the elimination of another program. Whichever program ends up with the most votes is eliminated.

This continues until there are only 1 program left, the winner. This entire process is considered a "round".

After there is a winner, another round will be started with a new piece of watermelon. All programs will be re-entered. When 10,000 rounds have been completed, the program with the most "wins" will be considered the "grand champion". All the rounds combined is considered the "tournament".

The Catch

Every program will have an opportunity to send a message to all the other programs. The message must be the same for every program. The message is a string, up to 500 bytes long.

You may have a file in which you may store any data you wish from previous rounds. This will persist over the entire tournament.

The Program

Write a program or function that accepts the following input in any (convenient) form:

[program-name], [message], "The Slug", "hey! don't vote for me!", "Chucknorium II", "a2TEI5ds#" ...

and outputs the name of the program that you vote for:

Chucknorium II

Notes

• In the likely event of a tie, one of the high scoring programs will be randomly eliminated
• Messages can be anything that doesn't mess with stuff it's not supposed to (e.g. don't mess with the controller or other people's programs). This is what makes the challenge interesting.
• You may not hard-code program names into your program! In other words, numbering the programs randomly at the beginning of the game should produce the same output. Names are just more fun.
• For observation purposes, your program will still be run even if it has been eliminated. It will not, however, have a chance to vote that round.

Answer 12

An Assortment of Sorting

Sorting an array of integers in ascending order is one of the most fundamental tasks in programming. Indeed, there are many algorithms which exist to accomplish this. While it may not be the most interesting challenge, particularly for "usual" languages, it can be nontrivial in many languages. So let's sort some integers!

Rosetta code features lists by sorting algorithm and language of idiomatic approaches to array sorting. However, "most idiomatic" often does not coincide with "shortest." In an effort to make Programming Puzzles and Code Golf the go-to site for code golf, this challenge seeks to compile a catalog of the shortest approach in every language, similar to "Hello, World!", Is this number a prime?, and Golf you a quine for great good!.

Task

Write a full program that, when given an array of strictly positive integers, will print the ascending sorted version of the input array using one particular algorithm that is guaranteed to terminate.

The sorting algorithm used must be specified in the post. Note that bogosort is not allowed as it is not guaranteed to terminate.

Input

To ensure that the focus of submissions is on the mechanics of the algorithm rather than parsing input, a variable (with a name of your choosing) must be hard-coded in the program. However, the hard-coded value must be easily exchangeable; it may appear in only a single place in the entire program. For scoring purposes, submit the program that corresponds to the one-element array 1.

The elements of the array may be in their decimal representations, unary representations (using a character of your choice), as byte arrays (big or little endian), or as single bytes (if this is your languages largest data type).

All elements of the array can be assumed to be in the range 1 to 255, inclusive. Your program must be able to handle an array of any size from 1 to 255, inclusive.

Output

Output has to be written to STDOUT or closest alternative.

If possible, the output should consist solely of the sorted array with an optional trailing newline. The only exception to this rule is constant output of your language's interpreter that cannot be suppressed, such as a greeting, ANSI color codes or indentation.

The output array can be formatted in any reasonable way. For example, [3,2,1] and 3 2 1 would both be fine.

Additional Rules

• There should be only one language and algorithm combination per answer. Please submit separate algorithms in the same language or separate languages with the same algorithm as separate posts.

• All submissions are required to feature some kind of explanation of the code.

• Unless entirely unpreventable in your language, nothing should be output to STDERR.

• This is not about finding the language with the shortest approach for sorting, this is about finding the shortest approach in every language. Therefore, no answer will be marked as accepted.

• Submissions in most languages will be scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8.

  The language Piet, for example, will be scored in codels, which is the natural choice for this language.

  Some languages, like Folders, are a bit tricky to score. If in doubt, please ask on Meta.

• Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. If anyone wants to abuse this by creating a language where the empty program sorts an array, then congratulations for paving the way for a very boring answer.

  Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.

• If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Headsecks or Unary), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.

• Built-in functions for sorting with a particular algorithm are allowed. This challenge is meant to catalog the shortest possible solution in each language, so if it's shorter to use a built-in in your language, go for it. However, you must provide a link that proves that the built-in uses whichever algorithm you claim.

• The input cannot be assumed to already be sorted.

• Unless they have been overruled earlier, all standard code-golf rules apply, including the Loopholes that are forbidden by default.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf; these are still useful to this question as it tries to compile a catalog as complete as possible. However, do primarily upvote answers in languages where the author actually had to put effort into golfing the code.

Catalog

The Stack Snippet at the bottom of this post generates the catalog from the answers as a list of the shortest solutions per language and algorithm, as well as an overall leaderboard.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language, Algorithm, N bytes

where N is the size in bytes of your submission. If you improve your score, you can keep old scores in the headline by striking them through. For instance:

# Ruby, Bubble Sort, <s>101</s> <s>96</s> 90 bytes

If you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

# Perl, Insertion Sort, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

# [><>](http://esolangs.org/wiki/Fish), Heapsort, 121 bytes

Insert a super awesome snippet here

---

code-golf array-manipulation sorting

---

Meta questions:

• Should this be restricted to specific set of sorting algorithms or is it okay to allow any deterministic algorithm?

• Is the title okay? The catalog challenges tend to have straightforward, descriptive, searchable titles (with the notable exception of Golf you a quine for great good!). I figured this title is clear enough while still being interesting, but perhaps it's better to opt for something more straightforward.

• At Peter's suggestion I've modified the input method. Arrays are now to be hard-code rather than being taken as input. This eliminates the need for parsing input. If I were to allow a variable to already exist, submissions would be snippets rather than full programs, which I don't want for this.

• Is the closed interval [1, 255] appropriate for bounds on the integer values in the array as well as the length of the array? Is it better to make the array an arbitrary size?

Answer 13

"The" Gaidhlig Challenge

The Gaidhlig language has some non-trivial rules when it comes to putting "the" in front of a word.

You're challenge is to create a program that takes two inputs, the first input is a string of text, a real word or made up that we can pretend is a noun. The second input is either the letter 'f' or the letter 'b' to denote whether the word is masculine or feminine.

The type of delimiter between these two inputs is your choice but must not be the letters a to z, a dash, or an apostrophe.

1. The first input is always assumed to be a noun.
2. The second input denotes whether the noun is masculine (f) or feminine (b).
3. We will always assume all inputs is valid.

You're output will be the the first input, modified for the following rules:

Masculine Nouns (where 'f' is supplied.)

1. Before vowels: An t-

2. Before b f m p: Am

3. Before all other instances: An

Feminine Nouns (where 'b' is supplied.)

1. Before sl sr sn so se si su: An t-

2. Before b m p c g : A' [with lentition]

3. Before f: An [with lentition]

Before all other instances: An

Whether the word is masculine or feminine:

Words that start with l n r sg sm sp st always start with: An

Lentition

When lentition is asked for, you must add the letter h after the first letter of your word in cases where the word starts with b c d f g m p s t. Otherwise the word remains unchanged. Further, you must not add an additional letter h if there is already a h in place.

Examples

Lentition of Aran: Aran

Lentition of Ghoul: Ghoul

Lentition of Goul: Ghoul

Lentition of House: House

Examples

Cat f An Cat

Cat b A' Chat

fear f Am fear

fear b A' fhear

Obair f An t-Obair

Obair b An Obair

snow f An snow

snow b An t-snow

Shortest code in bytes wins.

Answer 14

I would love to hear your thoughts about the following challenge. Too difficult or contrived? Or should we actually want more complicated and challenging tasks? I'll provide an example implementation in MATLAB by the time I post the challenge.

Concert Harp: Pedal Meddle code-golf

Sometimes I hear people say, ‘Why would anyone outside the ICT business learn how to program?’ Often, they get replies like ‘well, sometimes there are problems to which there is no software available’, but when asked about what kind of problems these would be, they’re forced to admit that all they really wanted was to make Conway’s Game Of Life for their own entertainment.

However, I recently found a problem that I think the home-and-garden programmer could face in reality. It considers a harp (a side effect sharing an apartment with a significant other) and a completely dumbfound pianist/programmer, who’s struggling enough with one pedal as it is. The harp in question has seven.

Now, for some background music/harp theory. You may skip as much as your musical background, or lack thereof, allows.

Music theory (a very condensed version)

Both in a harp and a piano, the strings/keys are laid out as follows:

… C | D | E F | G | A | B C | D | E F | G A | B …

There are seven root notes, [A-G], with at some locations a | in between to signify that there’s a note in between. These |’s are address by making a note higher by appending a #, or lower by appending a b. For example, C#==Db, F#==Gb (and also, Fb==E). Using these notes, we can make a scale. The difference between D and D# is called a half note, and between D and E a whole note.

Scales are made as follows: 1: take the root note 1: Find the next notes by going up a whole or half number of notes in the following pattern (last step in () because that makes you end up at the root note again)

Major: 1 1 ½ 1 1 1 (½)
Minor: 1 ½ 1 1 1 1 (½)

For example, D major and A# minor D E F# G A B C# (D) A# B# C# D# E# F# G# A#

Of course, these notations are not unique, since for example E#==F.

Problem

A harp has seven pedals, each responsible for one note. This note, they can either raise half a note, or lower half a note. For example, the C pedal can either make all C’s sound like C#(==Db) or like Cb(==B). Let’s designate raising by a pedal setting of +1 and lowering by -1, and leaving it as-is as 0. Given an input scale, write a program or function that outputs how each of the pedals should be set to achieve all of the tones in that scale.

Input

A scale designation. Scales are designated as follows: R[m][k]

• R: Root. [A-G]
• [m]: Optional: modification. Either flat b or sharp #
• [k]: Optional: minor key, designated as m.

Valid inputs would be for example

• C C major
• Dm D minor
• Fbm F flat minor

Output

The pedal setting -1, 0 or 1 for each of the pedals, in the following order, reflecting the actual location of the pedals on a harp:

D C B | E F G A

Test cases: (not exhaustive; i.e., there may be more solutions, I only included a double solution to one input)

C , B#, Am -> 0 0 0 | 0 0 0 0
Cm, B#m    -> 0 0 0 | -1 0 0 0
F#m, Gbm   -> 1 1 0 | 1 1 1 1
        or -> -1 -1 -1 | -1 0 -1 -1

Answer 15

Oh, no! There's been a fire at Claus HQ, and it's destroyed Santa's flight route! He has called on you to come up with a route that has him arriving at every home between the hours of 9PM Christmas Eve and 7AM Christmas Day. He'd also like to finish his deliveries in as little time as possible.

Input

Your program will take data for as many geographical areas as you or Santa chooses to enter. For every geographical area to be added, your program will accept:the name of the area, and the geographical coordinates of the area's center and the number of "nice" children who live in that geographical area.

Output In a .csv file your program will place:

1) Each geographical area's name, 1 per line, listed in order, with the area to be visited first placed first, and the area to be visited last placed last.

2) Next to the name, an ETA to the area in local time, and estimated time of departure, assuming Santa takes about 1/6100 seconds per child.

3) At the last line of the file, the total number of miles travelled, as determined by the sum of the great-circle distances - determined using the Vincenty formula, assuming an oblate spheroid Earth - from each stop to the next. Other than as stated above, I don't care what your file looks like. Rules

-You may not use any external library to perform any task except the following:

--Converting from one timezone to another.

-You may give your output file whatever name you choose.

-Estimated departure times must be no later than 7:01 AM.

Scoring For simplicity, scoring will be done using US states as areas. The population inputted will be the number of 14-and-under Christians residing in each state.

You get 1 point for every thousand miles travelled and an additional point for every hour of travel.

Answer 16

Convert your Language to Turing Machine Code

You are locked into a room, with only a laptop and a single-bidirectionallyinfinite-tape, two symbols Turing Machine (Therefore supports only 0s and 1, and it has a tape which is infinite in both directions). Your perverted captor set you a task: he will set you free only if solve all of the problems on the Project Euler page.

However, there is a catch. You are not allowed to solve the problem using your laptop, but you'll need to use the Turing Machine instead.

Since you think it will be incredibly tedious to convert your code to Turing Machine Code, you decided to write an source-to-source compiler on your computer, and since you're incredibly eager to get out, you decide to write your code in the shortest form possible.

---

Summary

• Write in your language of choice an compiler that converts your language into your Turing Machine Code.

• Your language may not need to be completely transformed, but at least the basic operations needed for mathematical computations need to be implemented, therefore you will need to implement at least three of the following, with mandatorily being able to translate a looping construct of your language, then for each more operator implemented you will get a 10% bonus:

  • Addition
  • Subtraction
  • Division
  • Multiplication
  • Modulus
  • Looping (Mandatory)
  • Bitwise operators: &(AND) |(OR) ^(XOR) !(NOT) (they count as 3 distinct ones)

  In practice your code should be able to translate at least a primality testing algorithm into Turing Machine Code.

• When I refer to Turing Machine Code, I refer to code for TML (Syntax explained later here)

---

Technicalities

• The turing machine does not support decimal numbers, only binary, so you may (or may not if you have a better method) write numbers in unary. e.g 11111011 are respectively 5 and 2

• Since the Turing Machine does not have a predefined IO, you may consider leaving the return value on the tape and halting as returning a value. e.g 111110000 and halting will return 5.

• For the Input, you have full access to the starting tape, according that you don't do any other operation rather than initializing the variables. e.g if you implemented add(a,b) and run add(5,7) you may initialize the tape to this: 1111101111111 or 11111001111111 or 111110001111111 exc. but you may not initialize the tape to: 111111111111

• TML Language description. TML which is the language your are interpreting your code to, uses a systems of cards, in this form 0{0-1}{0-1}{Integer}-1{0-1}{0-1}{Integer} where the first value determines which piece of code to execute (reading a value from the tape and comparing it, if it is 0 it will execute the code after the 0 until the dash, else the other piece of code), the second one tells what to write on the tape(0, 1), the third one finally tells the tape whether to go left(1) or right(0). The last value tells us to which card to go next, with the card 0 reserved for halting.

Note that TML is not 100% complete, so if your code follows the specs, but doesn't actually work just let me know, so I can fix the Language interpreter (if it's actually broken)

This is Code Golf, so the shortest code wins!

code-golf compiler

Answer 17

First 100 Twin Primes

What Are Twin Primes?

Twin primes are two prime numbers that has a gap of 2 between them; i.e. 3-5, 5-7, 11-13...

---

Goal

• Take no input and print first 100 twin primes to STDOUT.
• Shortest code in bytes wins.

---

Rules

• Your submission should be an executable complete program.
• Every prime couple should be on a new line.
• Printed twins should have a space between them.
• All standard code-golf rules are applied.

---

Restrictions

• No usage of built-in or external methods or functions that returns a prime number.
• No hardcoded prime numbers except 2 (as number, not count).

---

Any suggestions? I looked to similar questions but i couldn't see an identical one.

Answer 18

Rounding Fractions

code-golf math rational-numbers

Back in the old days of game programming, before FPUs were the norm, games predominantly used fixed-point math to represent non-integer values. Typically, the lower 8 or 12 bits of a 32-bit word are used as fractional parts, and the rest are treated as the integral part. Sometimes when looking at fixed-point constants in old game code, I get confused trying to figure out what they were actually trying to approximate, particularly if it's not a number between 0 and 1 (0x4C = 0.3, 0x119 = 1.1?, 0x73 = ???).

Since just rounding 1/256ths and 1/4096ths has a limited range of applications, the challenge here is to take any integer ratio a/b, and output the simplest fraction that rounds down to it. More specifically, output the ratio p/q with lowest denominator such that a/b ≤ p/q < (a+1)/b.

This code should support any non-negative a and positive b up to at least 10,000, and should run in a reasonable time for anything in that range (nothing on the order of minutes, at least). Answers should be correct, i.e., no rounding errors due to floating-point. Answers can be in the form of a full program or function, and use any convenient input / output (a string '1/2', an ordered pair (1, 2), a list of two integers {1, 2}, etc).

This challenge is code-golf, lowest score in bytes wins.

Some test cases:

1/3 -> 1/3
4/10 -> 2/5
33/100 -> 1/3
66/100 -> 2/3
67/100 -> 19/28
115/256 -> 9/20  (who knew?)
0/417 -> 0/1
653/654 -> 653/654
1404/702 -> 2/1

Sandbox Questions

Hey! I'm a long-time lurker, first-time-question-asker; I'm pretty sure this hasn't been asked before (more general than "Un-round fractions", not quite "Closest fraction"). Not sure what to set for a deadline before accepting an answer, since this is my first time actually participating. Anything else obvious I missed?

Answer 19

Nondeterministic Turing Machine

Introduction

We all know the concept of Turing machines, if not let's reiterate the concept. We have the following things that define a Turing machine:

• A tape that is divided into cells and is (potentially) infinite to the right.

• A read/write head that moves along the tape and reads and writes from it

• A state that changes according to what the head read

• A transition function that defines state changes and the direction in which the head shall move, based on the current state and the input read.

We can now have to supply some input, and the definition of the transition function (the set of states is implicit, and contains all states defined in the function). Additionally we assume that the alphabet is [0-9a-zA-Z!?()^+-] and space is the blank symbol. The tape head is then postioned over the leftmost character on the tape, which in our case is the first character of the input tape. The machine then starts applying the transition function. The computation continues until one of the following happens:

• The machine reaches the HALT state
• There is no transition defined in the transition function for the current state with the given input.

If the first case occurs, we say that the machine "accepts" the word. If the second case occurs we say that the machine "rejects" the word.

We can now extend this definition, to obtain a nondeterministic Turing Machine. To do this we allow the transition function to define more than one "next" state for each state/input combination. The machine can then choose which "execution path" to take. We then say that the machine accepts the word if it reaches the "HALT" state in any execution path, and it rejects it if it does not reach this state in all exection pats.

Problem definition

You must supply a program or function that accepts a string and returns a truth-ish value (either true/false, or 0/1, or anything else, at long as the meaning is clear) indicating wheter the word is accepted for at least one computation path or not. The input has the following for:

(<current_state>,<input_read>,<output>,<follow_up_state>,<move_direction>)

All the parts of the tuple are provided as strings where

• <input read> is a string of length 1, which can contain any character except ","
• <output> is also a string of length 1
• <move_direction> is either "l" (move left) or "r" (move right)

You may assume the following:

• The machine will always halt (i.e. no infite loops)
• There is only one state on which the machine halts which is HALT
• The alphabet is [0-9a-zA-Z!?()^+-] plus space as the blank symbol
• The leftmost character is always a blank, to indicate the ending of the tape on the left side.
• States are defined implicitly by the tranistion function. So the only states the machine knows are the one that occure during the definition of the transition function and there is no explicit definition of the states.
• The initial state is always s_i

The input has the following form

<nr_of_tuples_for_definition_of_transition_function>
<tuple_1>
<tuple_2>
...
<tuple_n>
<input_string>

All lines end with a newline character (\n) and the input string is not under double quotes.

Standard loopholes are disallowed! Shortest answer in byte wins.

Notes

Working example is still missing, I'll update that in the following days

Answer 20

DND Level Tables

In 3rd edition DND, there a lot of stats that you have to keep track for when you level up. Let's fix that by making some nice tables for them.

Crash Course on 3rd edition DND

3rd edition DND is very complex since it does not have "classes" in the traditional sense of most RPG games. Instead of picking a class when you create a character and more or less sticking to it, in 3rd edition you can actually "opt in" into any class you want at any time. Essentially, when you level up, you can choose to put that level in any class you want. This means that you can potentially have three levels in Rogue, two levels in Fighter, etc.

In addition to this, 3rd edition has special things called skills, which are unique to each class. When you level up you get some skill points that you can spend on skills. You can spend one skill point to get one "rank" in a skill. However, if that skill does not belong to your class you only get one-half of a "rank" in that skill. There are also feats, which are essentially general skills that don't belong to any class and have their own "skill points", and stat increases, which are little stat bonuses you get on level up.

All together, this is probably enough to make your head swim. Luckily, this challenge doesn't require you to get too much into the nitty gritty of this.

Challenge

Given an number representing a level as input, print out a table starting from level 1 up to and including the specified level of the following stats:

• The total amount of XP you've gained to reach this level

• Maximum class skill rank you've gained

• Maximum cross-class skill rank you've gained

• Whether you've gained a feat or stat increase (they are not gained every level) and the number of it.

The stats should be in this exact order. The table should be formatted with columns for each stat, with at least 4 spaces between each column. The level, feat and status increase numbers should have their appropriate suffixes (like 3rd). If you do not get a status increase or feat at a level, write -- where the feat or status increase number would go.

Now, without further ado, the math for all of this. Assume x is the level.

Total XP:

Class Rank:

Cross-Class Rank:

Feats: If

(x divisible by 3), then you have gained your

feat. You also automatically gain a feat at 1st level.

Stat Increases: If

then you have gained your

stat increase. Unlike feats, you do not get one of these at 1st level.

Examples

Sample input: 40

Sample output:

1st    0    4    2.0    1st    --
2nd    1000    5    2.5    --    --
3rd    3000    6    3.0    2nd    --
4th    6000    7    3.5    --    1st
5th    10000    8    4.0    --    --
6th    15000    9    4.5    3rd    --
7th    21000    10    5.0    --    --
8th    28000    11    5.5    --    2nd
9th    36000    12    6.0    4th    --
10th    45000    13    6.5    --    --
11th    55000    14    7.0    --    --
12th    66000    15    7.5    5th    3rd
13th    78000    16    8.0    --    --
14th    91000    17    8.5    --    --
15th    105000    18    9.0    6th    --
16th    120000    19    9.5    --    4th
17th    136000    20    10.0    --    --
18th    153000    21    10.5    7th    --
19th    171000    22    11.0    --    --
20th    190000    23    11.5    --    5th
21st    210000    24    12.0    8th    --
22nd    231000    25    12.5    --    --
23rd    253000    26    13.0    --    --
24th    276000    27    13.5    9th    6th
25th    300000    28    14.0    --    --
26th    325000    29    14.5    --    --
27th    351000    30    15.0    10th    --
28th    378000    31    15.5    --    7th
29th    406000    32    16.0    --    --
30th    435000    33    16.5    11th    --
31st    465000    34    17.0    --    --
32nd    496000    35    17.5    --    8th
33rd    528000    36    18.0    12th    --
34th    561000    37    18.5    --    --
35th    595000    38    19.0    --    --
36th    630000    39    19.5    13th    9th
37th    666000    40    20.0    --    --
38th    703000    41    20.5    --    --
39th    741000    42    21.0    14th    --
40th    780000    43    21.5    --    10th

Reference Implementation

Perl:

sub formatNum {
  $_=pop;
  $first = substr $_,-2,-1;
  if($first == "1" and length $_ > 1) { return $_."th"; }
  $digit = substr $_,-1;
  if($digit == "1") { return $_."st"; }
  if($digit == "2") { return $_."nd"; }
  if($digit == "3") { return $_."rd"; }
  else { return $_."th" };
}

sub space { 
  print " "x4; 
}

while(<>) {
  $limit = $_;
  for(my $c = 1; $c <= $limit; $c++) {
    print formatNum $c;
    space;
    print ($c*($c-1)*500);
    space;
    print ($c + 3);
    space;
    printf ("%.1f", ($c - 1)/2 + 2);
    space;
    if($c % 3 == 0) { print formatNum $c/3+1; }
    elsif($c == 1) { print "1st"; }
    else { print "--"; }
    space;
    if($c % 4 == 0) { print formatNum $c/4; }
    else { print "--"; }
    print "\n";
  }
}

Try it online.

Answer 21

coreutils default behavior stdin/stdout

We have a lot of challenges to implement just one of these operations, but a lot more are missing. Instead of adding a challenge for each of them, I thought I'd see if I could make a multiple-holes challenge that's complex enough to inspire some code re-use. This challenge is to reproduce a small subset of what Busybox does, namely to implement the default behavior of [almost] all of the GNU coreutils that (usually) read input from stdin or a file and send output to stdout or a file.

The utilities to reproduce are as follows:

1. cat copy stdin to stdout
2. tac copy stdin to stdout, reversing the order of the input lines (last line first)
3. nl copy stdin to stdout, adding a line number to the start of each line. Start at 1, use spaces to pad each number to a width of 6, and add two spaces between the line number and the original line
4. od I can't come up with a concise unambiguous way to describe the default output from od. I might skip it.
5. base64 for every 3 bytes of stdin, split into groups of 6 bits, look those 6-bit values up in the base64 alphabet, and output 4 such bytes to stdout. wrap output lines at 76 characters. pad missing bits with 0s, and output an all-padding 0b000000 as "="

I'll finish filling out descriptions for some subset of the following if this idea proves popular enough to proceed with.

fmt, pr, fold, head, tail, split, csplit, wc, sum, sort, shuf, uniq, ptx, tsort, cut, tr, expand, unexpand, yes

The format of an entry would be either one program or one function, which can perform all of these tasks, just like busybox can. As a program, it might read its own process name to decide which tool to run. As a program or a function, the first parameter might be which tool to run. As a program, input should come from stdin and go to stdout. As a function, input should be a single string parameter, and return a single string.

Answer 22

Find the nested source codes

A cops and robbers challenge where the cops write between 2 and 8 programs that produce output in the same language and interweave the programs together. WLOG, let's discuss this action being performed on two programs. By interweaving, I mean adding the characters of the second program to the first program so that when the characters of either the (WLOG) first program are removed, the second program can be seen. Obviously, commenting in any program is not allowed.

The cops will post their combined codes, the number of different programs in what they post, and the language the codes are written in, and what the programs print as output. To get credit for cracking the submission, the robbers must post the split codes and what each one outputs.

As a general rule, cops cannot use a language more than once.

Scoring

A cop will receive points if their submission is safe for one week from the time of posting. Their score will be the sum of the two following.

• The first value is 256 divided by 2 to the power of the number of different programs used.
• Round the number of bytes in the combined codes up to the nearest power of 2 and call this number x. The second value is 1024 divided by x.

A cop will lose 10 points for every code that is cracked before the one-week period is up.

Robbers will receive a number of points equal to the sum of the following for each cracked submission.

• The first value is 2 to the power of the number of different programs used in the cop's answer.
• Round the number of bytes in the combined codes up to the nearest power of 2 and call this number y. The second value is 1024 divided by y.

Example

Python, 2 codes

prpriintn("t"(hlellamlao")"[0])

Prints llama and h

Codes: print("llama") and print("hello"[0])

Answer 23

Complete the Digit Sequence

We have a string of digits with some elements missing and marked with .s.

74..7.1..1.3...8.781256

We want to fill the missing parts in a way that they would form an arithmetic sequence with the previous on next elements. E.g. 8...2 becomes 8642. If this kind of filling is not possible with single digits, mark the positions with ?. E.g. 7..3 would become 7??3.

With this rules our original example becomes

745674111123???8?781256

You should write a program or function which receives a digit string as input and outputs or returns the filled sequence.

Input:

TODO

Output:

TODO

Examples:

TODO

This is code golf so the shortest entry wins.

Sandbox note: this seems boring so ideas are welcomed.

Answer 24

code-golfmath

Find runs of triple multiples of squares

Your task is simple: For a given input N, find all runs of three or more consecutive integers less than N which are all perfect squares or multiples of perfect squares (of numbers greater than 1, obviously). You should then list each triplet (or greater) on a single line, indicating the square and the factor that divides it, e.g. 48 = 2² * 12. If a number is a product of two (or more) perfect squares, you may write it in either of two ways, e.g. 100 = 2² * 5² or 100 = 10². If your language doesn't support the ² character, you may use ^2 instead. For example, for an N of 1000, your code should produce the following:

48 = 2² * 12, 49 = 7², 50 = 5² * 2
98 = 7² * 2, 99 = 3² * 11, 100 = 10²
124 = 2² * 31, 125 = 5² * 5, 126 = 3² * 14
242 = 11² * 2, 243 = 9² * 3, 244 = 2² * 61, 245 = 7² * 5
342 = 3² * 38, 343 = 7² * 7, 344 = 2² * 86
350 = 5² * 14, 351 = 3² * 39, 352 = 4² * 22
423 = 3² * 47, 424 = 2² * 106, 425 = 5² * 17
475 = 5² * 19, 476 = 2² * 119, 477 = 3² * 53
548 = 2² * 137, 549 = 3² * 61, 550 = 5² * 22
603 = 3² * 67, 604 = 2² * 151, 605 = 11² * 5
724 = 2² * 181, 725 = 5² * 29, 726 = 11² * 6
774 = 3² * 86, 775 = 5² * 31, 776 = 2² * 194
844 = 2² * 211, 845 = 13² * 5, 846 = 3² * 94, 847 = 11² * 7, 848 = 4² * 53

or

48 = 2² * 12, 49 = 7², 50 = 5² * 2
98 = 7² * 2, 99 = 3² * 11, 100 = 2² * 5²
124 = 2² * 31, 125 = 5² * 5, 126 = 3² * 14
242 = 11² * 2, 243 = 3² * 3² * 3, 244 = 2² * 61, 245 = 7² * 5
342 = 3² * 38, 343 = 7² * 7, 344 = 2² * 86
350 = 5² * 14, 351 = 3² * 39, 352 = 2² * 2² * 22
423 = 3² * 47, 424 = 2² * 106, 425 = 5² * 17
475 = 5² * 19, 476 = 2² * 119, 477 = 3² * 53
548 = 2² * 137, 549 = 3² * 61, 550 = 5² * 22
603 = 3² * 67, 604 = 2² * 151, 605 = 11² * 5
724 = 2² * 181, 725 = 5² * 29, 726 = 11² * 6
774 = 3² * 86, 775 = 5² * 31, 776 = 2² * 194
844 = 2² * 211, 845 = 13² * 5, 846 = 3² * 94, 847 = 11² * 7, 848 = 2² * 2² * 53

The input may be supplied via command line, user input, read from a file, or any other means you see fit (though it should not be hardcoded). This is code golf, so shortest code wins. Usual loopholes apply.

Note that these numbers are sometimes called "non-squarefree" numbers, which are listed at A013929. (This lists all non-squarefree numbers, not just consecutive ones, so it may be useful as a reference, but is not a direct source.)

Side note: The 242-245 and 844-848 runs are the only sets of more than 3 below 1000. It's possible that they become more common at higher numbers, but so far, graphing the sets I know about produces a pretty steady line, with no noticeable curve towards greater or reduced frequency. It would be interesting to see a mathematical proof on whether there are or are not an infinite number of these sets...

Answer 25

The Language Relay!

A typical relay race only has four competitors per team, but where's the fun in that? Instead, let's see how many teammates you can cram onto the bus to the stadium and still finish the race. (This analogy is starting to break down, so I'll cut to the chase.)

Your task is to write a program or function in 256 bytes or less. It will take no input, and its output will be a program or function in another language. That program or function will also take no input, and its output will be a program or function in another language... and so on and so forth, until the last program, which will output the following:

.     \O/      .
|===== |_ =====|
|    _/  |     |

The winner is whoever manages to use the most languages. If there is a tie, the winner is the one with the shortest code in bytes.

You cannot use the same language twice, and different versions of the same language do not count as different languages. The output must also be different every time (no using languages that leave the program or function untouched.)

Here's a small example:

#include<stdio.h>
int main(){printf("print(\".     \\O/      .\\n|===== |_ =====|\\n|    _/  |     |\")");}

This C code produces this Python code:

print(".     \O/      .\n|===== |_ =====|\n|    _/  |     |")

And the Python produces the final output. I've used two languages, so my score is 2, and I'm going to lose terribly.

Answer 26

This might already exist, but through my search I couldn't find anything like it, so here it goes.

---

Find My Number code-golf

My friends and I have made are playing a game where we have a variable N that represents a number from 0 to 10. Using an expression they give us containing + - * / for addition subtraction multiplication and division, > < = for greater than, less than, and equal to, and the integers 0-10, we must find there number or what their number can possibly be.

I’m lazy, so I want you to write a Program that takes an input from STDIN or an acceptable alternative and return the possible numbers to STDOUT or an acceptable alternative.

Examples:

Input:

N+3>N*2-2

Output

1, 2, 3, 4

Input

N+2=N*2

Output

2

Input

N*4/6=N*2

Output

0

Because I might be caught, I want the program to be a small as possible in characters to avoid me friends seeing it, so the shortest solution wins!

Answer 27

I'm thinking I want to make a KOTH challenge that has bots play the classic game of Mafia. Bots will be placed in groups of seven, roles randomly assigned, and they play the game!

Explanation of Game Mechanics The game proceeds in multiple turns, each turn consisting of Night followed by Day. At night, each person completes his role as will be described below. During the daytime, players (in real life) discuss the events of the night (communicated by God, a separate person who does not participate in the game besides prompting people to their roles.) Just before night, the players have the option of voting to lynch another player, the objective being to lynch a mafia member to help the town win. Choosing not to lynch is always an option if you think it is too risky to lynch someone who might be innocent.

In real life, God would tell everyone to sleep, then ask mafia to wake up and silently agree on who to kill, tell them to sleep, and continue with the other roles in a similar manner. Town wins if all the mafia are dead; mafia wins if they at least outnumber the town.

There are four roles in this game, but I have played many games with more than seven people with more ridiculous roles that are very fun to play. Each player bot is assigned an ID number indicating his role.

• Mafia - There will be 2 mafia in this game. The two mafia will come to a consensus on who to kill. If one is dead the other decides on his own. The two mafia can not choose one of them to be killed. Mafia has a role of either 1 or 2, which are identical in function.

• Inspector - There will be 1 in this game. At night he visits a person, and receives a report on that person's innocence. Both Mafia members will appear as guilty and the rest will appear as innocent. He can not inspect himself nor dead people. His number is 3.

• Doctor - There will be 1 in this game. At night he visits a person, and that person will not die that night. Doctor can not save himself nor dead people. His number is 4.

• Townsperson - Does nothing at night. Numbers 5, 6, 7.

The Challenge

You will write a Java player class who will have (at least) three important methods: night, claim, and vote. All of these three methods will return the player to 'act' on (of course, depending on your role), given an ArrayList of information that the other players have claimed in public.

I am not very clear on how to run a KOTH challenge and what github is supposed to do and how to use it so it would be very helpful if someone could point me in the right direction. As of now I'm still working out the exact details of a Java class to run the game, as well as making a generic Player class that the answers will have to extend and use methods from.

Right now, I have a generic Player class that each answer will extend, and each Player object has two Identity objects: a public, claimed Identity and a private Identity. The private Identity will hold the players actual role (kept secret, of course), as well as a doctor arraylist of Integers and a cop arraylist of Strings. If the player happens to be a cop, the controller program will add an entry to the private cop arraylist which will serve as his way of receiving a verdict. I'll make a method called verdict() which returns the last element to make the programming easier. An example string is "4G" which means that player 4 is guilty. This player 4 may be mafia 1; player numbers are just given for discussion purposes and to identify a player based on his claims and is independent on role. Doctor is the same except integers because you only need to store who was saved that night.

The public, claimed Identity works in much the same way except that the controller will never modify it, only the player can. An identity object contains a role (an integer representing the role number), an ArrayList of strings called 'visits' (to be used if you are a cop or doctor, to store a list of people visited and any outcomes), and an ArrayList of suspicions to indicate that your bot suspects or is guessing that another player has a given role. It will also have a lynch value which can be changed during the day, and this is where a player decides on who to lynch (if at all). Finally, it will have a boolean for if the player is dead or alive. You had better not mess with this. The idea of having two is that you can claim whatever you want; so a Mafia can claim to be Cop or a townsperson and the doctor can claim to be a cop.

Initially your public claim ID is 0, indicating that you have not claimed. The program will give you your private ID, which will contain your actual role and and is not necessarily meant to be made public just yet. The program controller will only modify your private ID object, and only then if your are Doctor or Cop. It will append to the visits ArrayList in the private identity object the result of the visit; the doctor will have access to everyone he has visited, and the cop will have access to everyone he has inspected and their alignment.

The controller, each night, will ask Mafia 1 for his choice then Mafia 2 for his choice, then repeat, say, 25 times. If at any point the two mafia agree, then it stops because the Mafia have just made their choice. The number of times attempted thus far will be given to the Mafia's night method, so the code will look like M1.night(<other players info>, 1) then M1.night(<other players info>, 2), etc. is that arraylist of public identities previously mentioned. If no consensus, no kill. Similarly prompt cop and doctor once for their choice on who to visit.

In the day time, every player's lynch value will be 0, indicating that they do not vote yet; each player will be given 25 chances to act. An action can consist of adding to the list of suspected values, claiming a role, changing a role, changing the list of suspected values, voting to lynch someone, changing a lynch vote, etc., or more. Some actions are smarter than others, and your goal is to have a good action strategy. Upon each call of a players act() method, he will be given an arraylist of everyone else's public identity objects, as well as how many times before he has been prompted. This gives him access to what other players claim to be, who other players claim to have visited and outcomes, who they suspect as who, and who others are voting to lynch. If at any point there is a majority (more than half but not exactly half) of people wanting to lynch a person (No lynch, indicated by the value -1, counts too), then day time ends, that person is lynched and his role revealed. If majority voted -1 (no lynch) then nobody dies and day time ends.

Again, please guide me on how I should design my classes, controller, and what files I should put up and how people are going to test their bot at home. I would be glad to show you what I have so far, which includes a controller program and a dummy player class.

Answer 28

Generate a graphical representation of a Stern–Brocot tree of depth n

I am aware of this challenge. Would this be considered as a dupe?

Answer 29

Gilbert-Shannon-Reeds Shuffle

code-golf random array-manipulation

Background

The Gilbert-Shannon-Reeds (GSR) shuffle is a simple model of riffle shuffling close to how real humans shuffle a deck of cards. The well-known rule of thumb to riffle-shuffle a deck of 52 cards seven times for sufficient randomness is based on the GSR shuffle.

Algorithm

• Cut the deck at a position k, 0≤k≤n. If there are n cards, the probability that any given k is chosen is (n nCr k)/(2^n).

• Put the first k cards into one pile, and the other n-k in a second pile.

• Until all the cards are gone:

  • Where the sizes of the two piles are x and y, choose the first pile with probability x/(x+y) and the second pile with probability y/(x+y).

  • Move the first card in that pile to the new array.

Challenge

Input: An array of positive integers, of length n<1000.

Output: The array shuffled once.

Rules

You may use any algorithm that gives equivalent results to the GSR shuffle.

Answer 30

Play Chess with a One-Move Lookahead

"I see only one move ahead, but it is always the correct one."

– Jose R. Capablanca, World Chess Champion 1921-1927

This is a chess tournament with a twist: your chess engine is only allowed to look 1 move (2 ply) ahead. In order to succeed, you must create the best board evaluation algorithm.

Additional Rules

• En passant, castling, and under-promotion will be allowed. Of course, it is up to you if you want to bother adding those capabilities to your AI. I personally find these to be some of the best rules of chess.

I am considering making a "template" bot which implements alpha-beta pruning, and requiring users to just fill in the method for board evaluation. Otherwise, there may be ways to stretch what it means to "look ahead." The benefit for users would be that they don't have to write their own getLegalMoves() method.