493
\$\begingroup\$

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

| |
\$\endgroup\$

2996 Answers 2996

1
16 17
18
19 20
100
2
\$\begingroup\$

Stratego

This is a KOTH challenge based on the popular board game Stratego.

Rules

Stratego is played on a 10x10 board which looks like this (starting position):

  12345678910

A **********
B **********
C **********
D **********
E ..~~..~~..
F ..~~..~~..
G xxxxxxxxxx
H xxxxxxxxxx
I xxxxxxxxxx
J xxxxxxxxxx

*: enemy piece; x: your piece, .: empty space, ~: lake

There are twelve types of pieces: the flag (F), the bomb (B), the spy (S), and pieces numbered 2-10 (ten is 0). You can see the identities of your pieces, but not your opponent's. Each player starts with:

  • 6 bombs
  • 1 flag
  • 1 ten
  • 1 nine
  • 2 eights
  • 3 sevens
  • 4 sixes
  • 4 fives
  • 4 fours
  • 5 threes (miners)
  • 8 twos (scouts)
  • 1 spy

A player may arrange their pieces however they wish within their starting area.

The players take turns moving one piece into an adjacent square.

  • The bomb and flag may not move.
  • Twos (scouts) may move any number of squares in one direction, like a chess rook.
  • You may not move into a square containing one of your pieces.
  • If you attempt to move into a piece containing an enemy piece:
    • The identities of both pieces are revealed to the other player.
    • If both pieces are equal, they both lose.
    • If both pieces are numbered, the higher piece wins.
    • If the attacked piece is a bomb…
      • and the other piece is a miner, the miner wins.
      • otherwise, the bomb wins.
    • If the attacked piece is the flag, then the player owning the flag loses.
    • If the attacking piece is the spy…
      • and the defending piece is a 10, the spy wins.
      • otherwise, the spy loses.
    • If the attacked piece is the spy, it loses.
    • If the attacking piece won, the attacked piece is removed from the board and the attacking piece moves into its place.
    • If the attacked piece won, the attacking piece is removed from the board and the attacked piece remains in place.
    • If both pieces lose, they are both removed from the board.
  • A scout's move may end on an enemy piece, but it may not go over enemy pieces during its move.

Play continues until one player loses their flag or is unable to move on their turn, at which point that player loses.

Protocol

Bots may be written in any language that I can get to run on macOS. They will communicate with the server using newline-separated JSON on stdin/stdout. When a bot is started, it should send the following message:

{
  "type": "start",
  "layout": "..." /* starting layout, as 4x10 string; last line is edge of board */
}

When it is the bot's turn, the server will send the following message:

{
  "type": "turn",
  "board": "...", /* current board state, as 10x10 string; you half of the board is always on the bottom */
  "yourPreviousTurn": { /* result of your previous turn; not present on your first turn */
    "from": "B8",
    "to": "B9", /* you moved a piece from B8 to B9 */
    "movedPiece": "5" /* you moved a 5 */
    "attackedPiece": "8" /* the piece you attacked was an 8; only present if you attacked a piece on your last turn */,
    "winner": "them" /* their piece won; only present if you attacked a piece */
  },
  "theirPreviousTurn": { /* result of the turn they just took; not present on first turn of the game */
    "from": "H8",
    "to": "G8",
    "movedPiece": "4" /* they moved a 4; only present if they attacked */
    "attackedPiece": "9" /* they attacked your 9; only present if they attacked */,
    "winner": "you" /* your piece won; only present if they attacked */
  },
  "yourGraveyard": ["B", "3", ...], /* array of your pieces that have already died */
  "theirGraveyard": ["7", "4", ...] /* array of their pieces that have already died */
}

You must respond with:

{
  "type": "move",
  "from": "A6",
  "to": "A7"
}

Answering

Submit your bot as a pull request to [github link added here]. You do not need to include your entire bot in the SE answer, but please include the main/interesting parts of the code; I would recommend not including the layouts that you are using so that they remain secret (not that secret, but better than nothing). I will run bots regularly and post the latest scores here.

| |
\$\endgroup\$
  • \$\begingroup\$ 1. Can you give references to indicate that there is no legal issue here (with respect to copyright, trademarks, etc)? 2. Why 2 to 9 and then 0? Would it be simpler to use 1 to 9? 3. The list of starting pieces could be presented much more succinctly as a single string (BBBBBBF9...), and the combat table as a grid with columns and rows headed by B, F, etc and using one of three symbols to indicate the outcome. 4. Docker images? Are you serious? You should be trying to lower the barrier of entry, not raise it. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 9:57
  • 1
    \$\begingroup\$ This is a dupe of my stratego challenge.... \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 14:10
  • \$\begingroup\$ meta.codegolf.stackexchange.com/a/9653/46918 \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 14:11
  • \$\begingroup\$ 1. I feel that the copyright on the game is unlikely to be enforced for something this small. 2. The original game uses 2-10, so I am staying with that. 3. That would be more succinct, but less useful for understanding the game -- it would be nice not to have to analyze a table to understand things like "larger number wins." 4. Agreed. I will edit to remove the Docker requirement. \$\endgroup\$ – Gaelan Aug 25 '16 at 15:29
  • \$\begingroup\$ @Peter see above \$\endgroup\$ – Gaelan Aug 25 '16 at 15:31
  • \$\begingroup\$ Whether the copyright holder decides to take action or not is irrelevant: if posting this challenge would violate copyright then this site's legal terms prohibit it. (CC @RohanJhunjhunwala). \$\endgroup\$ – Peter Taylor Aug 25 '16 at 16:48
  • \$\begingroup\$ @PeterTaylor game rules can not be copyrighted: copyright.gov/fls/fl108.pdf \$\endgroup\$ – Gaelan Aug 25 '16 at 17:09
  • 1
    \$\begingroup\$ @PeterTaylor from what I understand, developing an AI to play a game isn't really breaching the copyright of the game holder. However I feel we should take this to meta. \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 17:31
  • \$\begingroup\$ @PeterTaylor feel free to continue to discuss this here meta.codegolf.stackexchange.com/q/9925/46918 \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 17:35
  • \$\begingroup\$ Gaelan, the document you link states that game rules are subject to copyright: it's the mechanics which aren't. The design elements probably extend to such matters as board layout and tile distribution: or, at least, the major Scrabble clones' owners weren't confident enough of winning against Hasbro, and changed their layouts and distributions under legal pressure. And I (and the SE legal terms) also mentioned trademarks: Stratego is a registered trademark in the US. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 21:49
  • \$\begingroup\$ @RohanJhunjhunwala, the AI might not be, but a king-of-the-hill doesn't work without a controller. \$\endgroup\$ – Peter Taylor Aug 25 '16 at 21:50
  • \$\begingroup\$ @PeterTaylor I will rename the challenge to avoid the trademark issue. Nothing in the PDF says anything about rules being copyrighted. It says the specific wording of the rules that came with the game are copyrightable, but I wrote the rules in my own words from memory. Also, see the dupe link in the meta question. \$\endgroup\$ – Gaelan Aug 25 '16 at 21:57
  • \$\begingroup\$ @Gaelan you have failed to address the issue that it is a dupe of my challenge \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 22:00
  • \$\begingroup\$ @PeterTaylor sure I can edit the name of my challenge to avoid stomping on a trademark. (But from what I understand you can saw the name of a company, without infringing their trademarks) \$\endgroup\$ – Rohan Jhunjhunwala Aug 25 '16 at 22:01
  • \$\begingroup\$ @RohanJhunjhunwala sorry, I didn't realize your challenge was this recent. Are you still planning on running your challenge? \$\endgroup\$ – Gaelan Aug 25 '16 at 22:03
2
\$\begingroup\$

De-Parenthesize Ruby

Reuben wants to start programming and golfing in Ruby. However, since he learned programming from his siblings Cecil and Emma, who program in C and ECMAScript respectively, he's developed a habit of adding parentheses to all sorts of functions when he doesn't need to. However, he can't just remove all the parentheses either! Help him by writing a short program that will remove some of the parentheses for him.

The Challenge

Given a snippet of Ruby code (you don't need to worry if it's valid code or not), apply the following rules to remove parentheses from function calls wherever possible. Whenever parentheses are removed, put a whitespace in between the function call and the arguments (even if in actual golfing practice it isn't needed, such as in the case of print"hello")

For the purposes of this challenge, not all parts of Ruby need to be checked:

  • Variables/functions will contain alphanumerics and underscore only, and won't start with numbers. (No functions like array.slice!(1,4).include?(6), and no variables like $a)
  • Blocks (curly braces after functions, or for declaring stabby-lambdas) are not present. No array.map{|i|i+1}
  • Function definitions like def f(x) will not be present.
  • No backslashes \ so you don't have to parse something like "\"hello\""
  • No comments. (Comments in Ruby start with #.) If a # appears in code, it's going to be part of a string.

These are the only rules you need to check for:

Functions without any parameters always have their parens removed.

array.size()+array.something().length() -> array.size+array.something.length

Functions at the end of a method chain can be removed only if they are not next to an arithmetic operator.
For the purposes of this challenge, the operators used will be +, -, *, /, %.

num.parse(3,7) -> num.parse 3,7
string.gsub("this","that").count("t") -> string.gsub("this","that").count "t"
1+string.count("T") -> 1+string.count("T") # no change
1+(string.count("T")) -> 1+(string.count "T")
puts(3,8*7) -> puts 3,8*7

If a function contains another function call as its only function argument, apply the other rules to that function as well.

print(print(x.sub(a,b.to_s(16)))) -> print print x.sub a,b.to_s(16)

If a string substitution operator #{...} is present within a string (enclosed with double quotes), remove parens from the functions in accordance to the other rules.
Assume that the contents within the string substitution don't include any literal strings, including single-character "question mark" strings like ?a. This means that things like "#{"a}#{"}" or "#{?}}" do not need to be dealt with.

"hello() #{world().string(5)}" -> "hello() #{world.string 5}"
"hello() # {world()}" -> "hello() # {world()}" # no change

Might add more rules or other things in the future if people want, before it gets published of course.

Would this be a duplicate of something like Remove unnecessary parentheses? It's a similar concept but with different rules

| |
\$\endgroup\$
  • \$\begingroup\$ The "only if they are not in an expression with an arithmetic operator" part seems like it might potentially be a problem. What about 1+(string.count("T"))? Or, how about: print(foo().bar())+1? I think you may want to more aggressively remove some of these edge cases. \$\endgroup\$ – FryAmTheEggman Aug 19 '16 at 12:45
  • \$\begingroup\$ @FryAmTheEggman that's a good point. I will think about how to phrase that case with parentheses to make more sense. For the second example, since the first rule says that empty parens are always removed, it'd become print(foo.bar)+1 as expected anyways. \$\endgroup\$ – Value Ink Aug 19 '16 at 18:40
  • \$\begingroup\$ I think a whitelist of language constructs would be clearer than listing a lot of things that aren't allowed. \$\endgroup\$ – feersum Aug 28 '16 at 11:59
  • \$\begingroup\$ @feersum I don't understand what you mean by that. Should I say something like "only alphanumerics, the dot operator ., these arithmetic operators, and the string substitution operator in strings"? \$\endgroup\$ – Value Ink Aug 29 '16 at 17:23
  • \$\begingroup\$ Yes, or better some sort of grammar describing the allowed input. \$\endgroup\$ – feersum Aug 29 '16 at 22:36
2
\$\begingroup\$

Shift and Sum

(I need a better title)

Write a program or function that given an input list of non-negative integers of length l, outputs the sum of all the lists of length 2*l-1 that are the input list padded with 0s to each side.

(Please suggest ways of improving this description)

For example, with the input [1,2,3]:

[1,2,3,0,0]+
[0,1,2,3,0]+
[0,0,1,2,3]=
[1,3,6,5,3]

More test cases:

[1]->[1]
[2,1]->[2,3,1]
[1,0,1]->[1,1,2,1,1]
[0,1,0]->[0,1,1,1,0]
[10,20,30]->[10,30,60,50,30]
[0,0,0,0,0,0]->[0,0,0,0,0,0,0,0,0,0,0]

You may take input in any reasonable format. If you have any questions about whether an input form is reasonable, ask about it in the comments.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ In other words, convolution [inserts dup] \$\endgroup\$ – Leaky Nun Aug 31 '16 at 1:42
  • \$\begingroup\$ Do all the inputs consist of lists of integers 0-9, or can they be greater/negative? \$\endgroup\$ – Theo Aug 31 '16 at 1:42
  • \$\begingroup\$ @Theo I was thinking they would be lists of non-negative integers. I will clarify that. \$\endgroup\$ – DanTheMan Aug 31 '16 at 1:47
  • \$\begingroup\$ codegolf.stackexchange.com/q/80030/194 \$\endgroup\$ – Peter Taylor Aug 31 '16 at 7:38
2
\$\begingroup\$

End the tabs versus space war

So, there has been a great deal of debate of whether to use tabs or spaces to indent/format code. Can you help the university settle the dispute, by going to an incredibly crazy unique method of formatting.


Your job is to write a full program or function which expands all tabs into four spaces. And then replaces a run of n leading spaces with "/(n-2 *'s)/". You will receive input over multiple lines in any reasonable format (single string array of strings for each new line. Columnar array etc.)

Sample input shamelessly stolen. Note that tabs get automagically expanded to four spaces on SE, but you must handle tabs as well.

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
    Not zero so multiply by 256 again to get 65536
    [>++++<-]>[<++++++++>-]<[>++++++++<-]
    +>[>
        # Print "32"
        ++++++++++[>+++++<-]>+.-.[-]<
    <[-]<->] <[>>
        # Print "16"
        +++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
    # Print "8"
    ++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
    this is preceded by a tab
        two tabs
            three tabs etcetera! 

Sample output

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
/**/Not zero so multiply by 256 again to get 65536
/**/[>++++<-]>[<++++++++>-]<[>++++++++<-]
/**/+>[>
/******/# Print "32"
/******/++++++++++[>+++++<-]>+.-.[-]<
/**/<[-]<->] <[>>
/******/# Print "16"
/******/+++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
/**/# Print "8"
/**/++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
/**/this is preceded by a tab
/******/two tabs
/**********/three tabs etcetera! 


Because the university needs space to download both Vim and Emacs. You are alloted very little storage for your code. Therefore this is and the shortest code wins.

Disclaimer

This "excellent" formatting strategy came courtesy of Geobits, and is reproduced with his permission. No programmers were harmed during the production of this challenge.

| |
\$\endgroup\$
  • 4
    \$\begingroup\$ Disclaimer: By using this formatting, you hereby absolve Geobits of any liability for any injuries (intentional or otherwise) or damages you may receive as a result. Void where prohibited. \$\endgroup\$ – Geobits Aug 31 '16 at 4:00
  • \$\begingroup\$ Also, do only leading spaces/tabs get replaced? \$\endgroup\$ – Geobits Aug 31 '16 at 4:03
  • \$\begingroup\$ What does "expands all tabs into four space*" mean? Is it a straight replacement à la codegolf.stackexchange.com/q/57462/194 or does it mean expanding to tab stops every 4 chars à la codegolf.stackexchange.com/q/18960/194 ? \$\endgroup\$ – Peter Taylor Aug 31 '16 at 7:32
  • \$\begingroup\$ @PeterTaylor essentially line.repaceAll("\t"," "); \$\endgroup\$ – Rohan Jhunjhunwala Aug 31 '16 at 12:07
  • \$\begingroup\$ So all tabs get replaced by spaces, and then only leading spaces get replaced by "comments"? \$\endgroup\$ – Geobits Aug 31 '16 at 13:45
  • \$\begingroup\$ @Geobits yes that is a very clear way of putting it. \$\endgroup\$ – Rohan Jhunjhunwala Aug 31 '16 at 15:22
  • 1
    \$\begingroup\$ this is genius, I should start using it. \$\endgroup\$ – Maltysen Aug 31 '16 at 17:55
  • \$\begingroup\$ You should delete this. now that it's been posted. \$\endgroup\$ – James Sep 2 '16 at 0:09
2
\$\begingroup\$

What is my birthday?

In the system of surreal numbers, every number has a birthday, which is used to resolve ties in the case of there being more than one surreal number that would otherwise satisfy an equation.

The very first surreal number to be created is zero, written as {|}. Its birthday is therefore zero. Having created zero, the next two surreal numbers to be created are 1 and -1. Their birthdays are therefore both 1.

Each subsequent day brings in twice as many surreal numbers as the previous day: 2ⁿ-2 numbers are obtained by taking the averages of all the consecutive pairs from all previous days, with the first and last numbers simply incrementing in absolute value. For example, on the second day, the previous surreal numbers are -1, 0 and 1, giving averages of -½ and ½, to which we also add -2 and 2, whilst on the third day the new numbers are -3, -1½, -¾, -¼, ¼, ¾, 1½ and 3.

As you can see, all finite floating-point representations have a finite birthday. (Most real numbers have an infinite binary fraction and therefore an infinite birthday). Your task is to write a program or function that outputs the birthday for a given floating-point number (using your native floating-point format). Although the birthday is always an integer, you can return it as an integer valued floating-point number if you prefer (e.g. if you don't have an unlimited integer type). Test cases:

Number  Birthday
  1        1
  0.5      2
-21       21
  6.5      8
 -7.9375  12

This is , so the shortest program wins.

| |
\$\endgroup\$
  • \$\begingroup\$ Could you perhaps please add how the number generation process works? \$\endgroup\$ – Sp3000 Sep 2 '16 at 11:13
  • \$\begingroup\$ @Sp3000 The line beginning "In general" was supposed to explain that, although there was some spurious text on it that you may have found confusing. \$\endgroup\$ – Neil Sep 2 '16 at 11:31
  • \$\begingroup\$ Hmm right, I see. Sorry it took me a while to get what it meant - maybe a quick example, e.g. saying the third day takes averages from 2, 1, ½, 0, -½, -1, -2? (to drive home the "all previous birthdays" part). But otherwise I think this looks pretty good. \$\endgroup\$ – Sp3000 Sep 2 '16 at 14:59
  • \$\begingroup\$ Maybe you should give more examples from Knuth because, for instance, from your current explanation it is unclear why 1/3 should have a birthday of ω: it is not a finite sum of dyadic rationals. Or better give example inputs and expected outputs. \$\endgroup\$ – Andreï Kostyrka Sep 3 '16 at 1:10
  • \$\begingroup\$ Consider adding these test cases: Input: 1, 0.5, -21, 6.5, -7.9375 and Output: 1, 2, 21, 8, 12. \$\endgroup\$ – Andreï Kostyrka Sep 3 '16 at 1:56
2
\$\begingroup\$

Show the Key Signature

Here is are the key signatures for the key of C♯ Major in the treble clef, and C♭ major in the bass clef:

           ♯
─────♯───────────────────────   ─────────────────────────────
                    ♯
──────────────♯──────────────   ─────────────────────────────
        ♯                               ♭
───────────────────────♯─────   ──────────────♭──────────────
                 ♯                                  ♭
─────────────────────────────   ─────♭───────────────────────
                                           ♭
─────────────────────────────   ─────────────────♭───────────
                                                       ♭

A full list of key signatures can be found here. Hopefully you will notice that a) the sharps and flats are two notes lower in the bass clef as compared to the treble clef b) all key signatures can be obtained from the C♯ Major and C♭ Major key signatures by removing trailing sharps and flats appropriately.

Your task is, given a suitable representation of the clef and key, to output the appropriate key signature using the above format.

  • Your output must have at least 11 lines, in order to accommodate all possible placings of sharps and flats.
  • To compensate for the terrible aspect ratio, each sharp and flat must be separated by two columns, and there must be at least five empty columns at the beginning and end, but no more than 29 columns in total.
  • You may use #, b and - characters instead of ♯, ♭ and ─.

This is , so the shortest solution wins!

| |
\$\endgroup\$
  • \$\begingroup\$ Can I adopt this abandoned challenge? \$\endgroup\$ – programmer5000 Jun 9 '17 at 12:07
  • \$\begingroup\$ @programmer5000 Sorry, I'm not very good at checking back to see how my Sandbox posts are doing. As I don't have many questions myself, I'd rather be the person to ask it, if you don't mind. (But feel free to comment on any changes you think I should make first.) \$\endgroup\$ – Neil Jun 9 '17 at 12:25
  • \$\begingroup\$ Ok sure. I think it is ready to post. \$\endgroup\$ – programmer5000 Jun 9 '17 at 12:26
  • \$\begingroup\$ @programmer5000 Oh, I meant to ask, what input format do you think I should accept for the clef and key? Representing the key as a number between -7 and 7 feels like cheating to me. \$\endgroup\$ – Neil Jun 11 '17 at 21:15
2
\$\begingroup\$

Handwriting Recognition

I made a similar suggestion a month or so back which was deemed to be too similar to an existing one, so I've added something along the lines of a kolmogorov-complexity requirement.


The MNIST dataset is a series of handwritten digits used as a standard testbed for machine learning, pattern recognition techniques. Each image is of a single digit, 0-9; as a 28x28 pixel grayscale matrix with values from 0-255.

MNIST example images

The challenge is to create a classifier for MNIST that scores an Error Rate of less than [TBD] in the least number of bytes possible.

Your program must take a 784 element long array in whatever format is applicable for your language representing a single image and return a number between 0 and 9, guessing what the number is.

For example, the input for the first digit might be:

[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3, 18, 18, 18,126,136,175, 26,166,255,247,127,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0, 30, 36, 94,154,170,253,253,253,253,253,225,172,253,242,195, 64,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0, 49,238,253,253,253,253,253,253,253,253,251, 93, 82, 82, 56, 39,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0, 18,219,253,253,253,253,253,198,182,247,241,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0, 80,156,107,253,253,205, 11,  0, 43,154,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0, 14,  1,154,253, 90,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,139,253,190,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 11,190,253, 70,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 35,241,225,160,108,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 81,240,253,253,119, 25,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 45,186,253,253,150, 27,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 93,252,253,187,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,249,253,249, 64,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 46,130,183,253,253,207,  2,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 39,148,229,253,253,253,250,182,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,114,221,253,253,253,253,201, 78,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0, 23, 66,213,253,253,253,253,198, 81,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0, 18,171,219,253,253,253,253,195, 80,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0, 55,172,226,253,253,253,253,244,133, 11,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,136,253,253,253,212,135,132, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]

Each algorithm will be tested over a set of 200 images and are expected to get [TBD]/200 correct.

Of course, when developing any good classifier, you need to test how well it works with a completely unknown sample. The twist of the challenge, these are the 200 images I am going to test with right here: (a link to 200 images and their correct labels). You only need to make sure you can classify at least [TBD]/200 of these, your algorithm won't be run on anything else. As such, this can be considered a kolmogorov complexity challenge with an acceptable error rate.

Conditions:

  • This is code golf. The shortest piece of code that meets the criteria wins.
  • The code must take a provided 784 element long input and attempt to classify it.
  • Testing will take place on my computer at 12pm AEST on Saturday the (date two weeks after the competition is published). I will run each classifier over the published set of 200 images. To be considered, it must correctly classify [TBD]/200 of them. If I can't get your code to run, it wont be counted, so help with loading the images in your language would be appreciated.
  • Standard loopholes are not permitted.

Questions for Sandbox

  • Overall thoughts on the challenge?
  • Any ideas on a good cutoff for the classifier? I was thinking around 60% correct. Very low when compared to existing solutions to MNIST, but should promote good code golfing. I was going to have a go at it myself to see what I could reasonably achieve.
  • Does the testing clause make sense? Is it reasonable? Should I put a limit on the languages so I know I'll be able to run them?
  • Since barrier to entry is a bit high (knowing how to get hold of the images, possibly some ML experience), is there anything extra I should do to make it easier to start the challenge.
  • This is a modification of my first suggestion for a challenge, is there anything I'm missing?
| |
\$\endgroup\$
  • \$\begingroup\$ I recommend a time limit, especially if you intend to test them yourself. It can be generous, but without one then the requirement to golf will naturally give very long run times which you may not wish to commit your computer to... \$\endgroup\$ – trichoplax Oct 18 '16 at 12:09
  • \$\begingroup\$ Do submissions need to be deterministic? That is, should the results be identical each run? \$\endgroup\$ – trichoplax Oct 18 '16 at 12:22
  • \$\begingroup\$ For choosing the maximum error rate, think about what kinds of approaches you want to see. For a sufficiently high error rate, it may be possible to look only at a small number of pixels and ignore most of the image. If you want this kind of approach, try to choose an error rate that makes it challenging but possible. If you prefer more complex approaches, the error rate will need to be set a little lower. \$\endgroup\$ – trichoplax Oct 18 '16 at 12:33
2
\$\begingroup\$

Classify Alternating Permutations

An alternating permutation of [1, 2, 3, ..., n] is an arrangement such that each element is either greater than its previous and greater than the next, meaning p[i-1] < p[i] > p[i+1] or lesser than the previous and lesser than the next, meaning p[i-1] > p[i] < p[i+1]. In other words, this means that each run of three consecutive elements should never be strictly increasing or decreasing. There is a further distinction that an alternating permutation can be either UP or DOWN. For UP, this means that the alternating permutation begins with the first element being less than the second, and the opposite is true for DOWN. For example, there are 4! = 24 permutations of [1, 2, 3, 4]

1 2 3 4
1 2 4 3
1 3 2 4  Alternating UP since 1 < 3 > 2 < 4
1 3 4 2
1 4 2 3  Alternating UP since 1 < 4 > 2 < 3
1 4 3 2
2 1 3 4
2 1 4 3  Alternating DOWN since 2 > 1 < 4 > 3
2 3 1 4  Alternating UP since 2 < 3 > 1 < 4
2 3 4 1
2 4 1 3  Alternating UP since 2 < 4 > 1 < 3
2 4 3 1
3 1 2 4
3 1 4 2  Alternating DOWN since 3 > 1 < 4 > 2
3 2 1 4
3 2 4 1  Alternating DOWN since 3 > 2 < 4 > 1
3 4 1 2  Alternating UP since 3 < 4 > 1 < 3
3 4 2 1
4 1 2 3
4 1 3 2  Alternating DOWN since 4 > 1 < 3 > 2
4 2 1 3
4 2 3 1  Alternating DOWN since 4 > 2 < 3 > 1
4 3 1 2
4 3 2 1

The permutations left unmarked are NOT alternating.

Your goal is take a permutation and output whether it is

  • alternating UP
  • NOT alternating
  • alternating DOWN

Rules

  • This is so the shortest code wins.
  • You are allowed to modify the input be 0-indexed, 1-indexed, or a permutation of the English alphabet abcdefghijklmnopqrstuvwxyz in uppercase or lowercase.
  • The length of the input will be between 2 and 26.
  • You are allowed to choose your own output to represent the three classes but you must state what they are in your submission.

Test Cases

1 2  UP
2 1  DOWN
1 2 3  NOT
1 3 2  UP
2 1 3  DOWN
2 3 1  UP
3 1 2  DOWN
3 2 1  NOT
<more to be added...>
| |
\$\endgroup\$
  • 1
    \$\begingroup\$ The phrase "each element is greater than or less than the previous element" is not very clear (arguably, it just means that consecutive elements are distinct, which always holds in a permutation). I suggest something like "doesn't contain an increasing or decreasing run of three consecutive numbers", and then you can clarify that the permutation alternates between rising and falling pairs. \$\endgroup\$ – Zgarb Oct 20 '16 at 10:20
  • \$\begingroup\$ @Zgarb I've tried to clarify the definition a bit more \$\endgroup\$ – miles Oct 20 '16 at 11:53
  • \$\begingroup\$ Isn't "each element is either greater than its previous and lesser than the next or lesser than the previous and greater than the next" the exact opposite of what an alternating permutation is? It should be either greater than both the previous and the next, or lesser than both. \$\endgroup\$ – Emigna Oct 20 '16 at 13:11
  • \$\begingroup\$ @Emigna Thanks, I got it backwards. \$\endgroup\$ – miles Oct 20 '16 at 18:13
  • \$\begingroup\$ Can I adopt this abandoned proposal? \$\endgroup\$ – programmer5000 Jun 9 '17 at 12:38
2
\$\begingroup\$

Note: this is an attempt to fix up a currently closed question by someone else so that they can rescue it, not an attempt to steal their question.

When implementing an algorithm for correcting aliased measurement data, I hit the need to implement following function. The function takes input bitstring on the left, and should produce the integer and list on the right:

               1 =>   1, [0]
              10 =>   1, [0]
             100 =>   1, [0]
             101 =>   2, [0, 1]
            1000 =>   1, [0]
            1011 =>   3, [0, 2, 1]
     ... more test cases at end of post ...

Note that it is guaranteed that the input bitstring is aperiodic.

Physical background

Consider a digital system that changes its output every N clock cycles. A measurement system doesn't know N, so it reads the output every M cycles, where M <= N.

Now some of the measurement samples will be identical to the previous ones, which is represented as 0 in the bitstring and the sample is discarded. When the value changes, 1 is added to the bitstring and the sample is stored.

However, the timestamp of the sample will be too late. The numbers in the output array represent a correction that must be applied. The output format expresses this correction as a fraction of the sample interval, where the standalone integer is the denominator and the array contains the numerators.

As an example with N = 4 and M = 3:

Clock cycle     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
Output          A A A A B B B B C C C C D D D D E E E E
Measurement     A     A     B     C     D     D     E
Bitstring       1     0     1     1     1     0     1
                |---------------------| This is the period of the aliasing

Timestamp       |       |---|   |-|     |       |---|
  correction    0          2/3   1/3    0          2/3

With this example the input would be 1011 and the output would be 3, [0, 2, 1].

Here are a few observations to get you started:

  • The input sequence always begins with 1 and is aperiodic.
  • The output sequence length always equals the number of 1-bits in the input.
  • The output sequence array is always a permutation of 0 to M-1 and begins with 0.

Test cases:

               1 =>   1, [0]
              10 =>   1, [0]
             100 =>   1, [0]
             101 =>   2, [0, 1]
            1000 =>   1, [0]
            1011 =>   3, [0, 2, 1]
           10000 =>   1, [0]
           10010 =>   2, [0, 1]
           10101 =>   3, [0, 1, 2]
           10111 =>   4, [0, 3, 2, 1]
          100000 =>   1, [0]
          101111 =>   5, [0, 4, 3, 2, 1]
         1000000 =>   1, [0]
         1000100 =>   2, [0, 1]
         1001010 =>   3, [0, 2, 1]
         1010101 =>   4, [0, 1, 2, 3]
         1011011 =>   5, [0, 3, 1, 4, 2]
         1011111 =>   6, [0, 5, 4, 3, 2, 1]
        10000000 =>   1, [0]
        10010010 =>   3, [0, 1, 2]
        10101101 =>   5, [0, 2, 4, 1, 3]
        10111111 =>   7, [0, 6, 5, 4, 3, 2, 1]
       100000000 =>   1, [0]
       100001000 =>   2, [0, 1]
       100101010 =>   4, [0, 3, 2, 1]
       101010101 =>   5, [0, 1, 2, 3, 4]
       101110111 =>   7, [0, 5, 3, 1, 6, 4, 2]
       101111111 =>   8, [0, 7, 6, 5, 4, 3, 2, 1]
      1000000000 =>   1, [0]
      1000100100 =>   3, [0, 2, 1]
      1011011011 =>   7, [0, 4, 1, 5, 2, 6, 3]
      1011111111 =>   9, [0, 8, 7, 6, 5, 4, 3, 2, 1]
     10000000000 =>   1, [0]
     10000010000 =>   2, [0, 1]
     10001000100 =>   3, [0, 1, 2]
     10010010010 =>   4, [0, 1, 2, 3]
     10010101010 =>   5, [0, 4, 3, 2, 1]
     10101010101 =>   6, [0, 1, 2, 3, 4, 5]
     10101101101 =>   7, [0, 3, 6, 2, 5, 1, 4]
     10110111011 =>   8, [0, 5, 2, 7, 4, 1, 6, 3]
     10111101111 =>   9, [0, 7, 5, 3, 1, 8, 6, 4, 2]
     10111111111 =>  10, [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    100101001010 =>   5, [0, 3, 1, 4, 2]
    101010110101 =>   7, [0, 2, 4, 6, 1, 3, 5]
    101111111111 =>  11, [0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    111111111111 =>  13, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
   1000000100000 =>   2, [0, 1]
   1000010001000 =>   3, [0, 2, 1]
   1000100100100 =>   4, [0, 3, 2, 1]
   1001001010010 =>   5, [0, 2, 4, 1, 3]
   1001010101010 =>   6, [0, 5, 4, 3, 2, 1]
   1010101010101 =>   7, [0, 1, 2, 3, 4, 5, 6]
   1010110101101 =>   8, [0, 3, 6, 1, 4, 7, 2, 5]
   1011011011011 =>   9, [0, 5, 1, 6, 2, 7, 3, 8, 4]
   1011101110111 =>  10, [0, 7, 4, 1, 8, 5, 2, 9, 6, 3]
   1011111011111 =>  11, [0, 9, 7, 5, 3, 1, 10, 8, 6, 4, 2]
   1011111111111 =>  12, [0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  10000100001000 =>   3, [0, 1, 2]
  10010010010010 =>   5, [0, 1, 2, 3, 4]
  10101101101101 =>   9, [0, 4, 8, 3, 7, 2, 6, 1, 5]
  10111011110111 =>  11, [0, 8, 5, 2, 10, 7, 4, 1, 9, 6, 3]
  10111111111111 =>  13, [0, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
 100000001000000 =>   2, [0, 1]
 100010001000100 =>   4, [0, 1, 2, 3]
 100101010101010 =>   7, [0, 6, 5, 4, 3, 2, 1]
 101010101010101 =>   8, [0, 1, 2, 3, 4, 5, 6, 7]
 101101110111011 =>  11, [0, 7, 3, 10, 6, 2, 9, 5, 1, 8, 4]
 101111110111111 =>  13, [0, 11, 9, 7, 5, 3, 1, 12, 10, 8, 6, 4, 2]
 101111111111111 =>  14, [0, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

| |
\$\endgroup\$
2
\$\begingroup\$

Finding isomorphic elementary cellular automata

An elementary cellular automaton is a one-dimensional cellular automaton with two possible states (labeled 0 and 1) and calculates the following state based on a cell and its two immediate neighbors. Each elementary cellular automaton has a rule attached to it that specifies the resulting state for each of the configurations of a cell and its immediate neighbors.

The most common scheme for numbering these rules being the Wolfram code, where we assign each rule a number from 0 to 255 which has become standard. Each possible current configuration is written in order, 111, 110, ..., 001, 000, and the resulting state for each of these configurations is written in the same order and interpreted as the binary representation of an integer. This number is taken to be the rule number of the automaton.

As an example, we look at rule 110:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      0    1    1    0    1    1    1    0

Converting 01101110 back to decimal gives us 110.

Not all rules are equal, of course. Of the 256 possible rules, many of these rules are trivially equivalent to each other up to a simple transformation of the underlying geometry. Each rule will have three isomorphic rules based on three transformations, though sometimes a rule will be isomorphic to itself under a particular transformation.

The first such transformation is reflection through a vertical axis and the result of applying this transformation to a given rule is called the mirrored rule. These rules will exhibit the same behavior up to reflection through a vertical axis, and so are equivalent in a computational sense.

For example, if the definition of rule 110 is reflected through a vertical line, the following rule (rule 124) is obtained:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      0    1    1    1    1    1    0    0

We swap only those cell configurations that are different when reflected through a vertical axis. The result of 110 is swapped with the result of 011, and the result of 100 is swapped with the result of 001. Everything else remains in place, as they are symmetrical.

The second such transformation is to exchange the roles of 0 and 1 in the definition. The result of applying this transformation to a given rule is called the complementary rule. For example, if this transformation is applied to rule 110, we get the following rule:

Cell configuration  000  001  010  011  100  101  110  111
Resulting state      1    0    0    1    0    0    0    1

and, after reordering, we discover that this is rule 137:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      1    0    0    0    1    0    0    1

Finally, the previous two transformations can be applied successively to a rule to obtain the mirrored complementary rule. For example, the mirrored complementary rule of rule 110 is rule 193.

Of the 256 elementary cellular automata, there are 88 which are inequivalent under these transformations.

The challenge

  • Your task is given an input rule number, determine which elementary cellular automata are isomorphic under these rules.
  • The output should be a list (or equivalent) that represents:
    • The smallest Wolfram rule that is isomorphic to the input,
    • Its mirrored rule,
    • Its complementary rule, and
    • Its mirrored complementary rule.
  • The output list may be reordered, though it should always be clear which rule is the smallest, the mirrored rule, and so on. Just sorting the list will not help here.
  • This is code golf. Smallest number of bytes wins.

As always, if this challenge needs clarification or correction, let me know. Good luck and good golfing!

Test cases

All of the following test cases have the format [smallest, mirrored, complementary, mirrored complementary]:

110
[110, 124, 137, 193]

232
[232, 232, 232, 232]

0
[0, 0, 255, 255]

16
[2, 16, 191, 247]

42
[42, 112, 171, 241]

144
[130, 144, 190, 246]

Sandbox questions

  • Can the specification be clearer or shorter?
  • Should I change this challenge from code golf to some other scoring system?
  • Should the input be different and challenge changed? If so, which of the following input systems should it be:
    • The input that is currently used: a single rule number, and the challenge is changed to only finding the isomorphisms.
    • The number of states of the automaton, where finding the complementary rules would be more complex (for 2 states, only two possible complements; for 3 states, six complements are possible). This would extend the definition of both the Wolfram code and the cellular automata.
    • Any other suggestions?
| |
\$\endgroup\$
  • \$\begingroup\$ Wouldn't this be a kind of kolmogorov-complexity challenge, considering the fixed output? \$\endgroup\$ – LegionMammal978 Oct 22 '16 at 12:34
  • \$\begingroup\$ @LegionMammal978 Nuts, you're right. Well, as the "Sandbox questions" section asks, what should the input be, in your opinion? \$\endgroup\$ – Sherlock9 Oct 22 '16 at 12:36
  • \$\begingroup\$ Perhaps you could input a rule number, and the program should find the smallest isomorphic rule and then output its four-element list. \$\endgroup\$ – LegionMammal978 Oct 22 '16 at 12:39
  • \$\begingroup\$ @LegionMammal978 Seems reasonable. I'd still like a challenge where you have to find the four-element list for all combinations, but perhaps that can be a sequel. I'll edit the challenge. \$\endgroup\$ – Sherlock9 Oct 22 '16 at 12:40
  • \$\begingroup\$ Surely reflection through a vertical axis is reflection horizontally, not vertically? \$\endgroup\$ – Peter Taylor Oct 22 '16 at 18:33
  • \$\begingroup\$ @PeterTaylor Thanks! Any other corrections or suggestions? \$\endgroup\$ – Sherlock9 Oct 22 '16 at 20:35
  • \$\begingroup\$ That was the only thing I noticed. \$\endgroup\$ – Peter Taylor Oct 22 '16 at 21:31
2
\$\begingroup\$

Permutation-Tolerant Hello World

Inspired by Fault-Tolerant Hello World (a.k.a. the Interview).

Task

Write a program that prints Hello World. Sounds easy, right? Ok, lets challenge up a bit : your (real) task is to maximum the number of permutations of the characters of your code that produce a code that when executed prints Hello World as well.

Hmm, I even got myself confused with that last sentence, so let's see an example :

Consider the following code (it's good enough to understand the principle, but as I'll explain later, the score of such a code will be pretty low) :
(it's Perl code, and if you don't trust me when I say it works, you can run it with perl -e 'code' in your terminal)

print+("Hello World")

When ran, it prints Hello World. Well, the following permutations of the code also print Hello World :

+(print"Hello World")
+print("Hello World")
(print+"Hello World")
()+print"Hello World"

Note that only permutations that produce a code that differs from the previous ones should be considered. For instance, the original code where the two l have been swapped isn't a valid permutation.

Scoring

The score of your solution is the number of bytes of your code divided by the number of valid permutations. Lowest score wins. In case of draw, the earliest solution wins.
For instance, my example above was 21 bytes long, and had 5 valid permutations (note that it includes the original code), so its score is 21/5 = 4.2.


For the sandbox

(1- Does it sound like a nice challenge?
2- Is it clear? )

3- I don't really what tags to add...

4- I'm not sure about the scoring method. In particular, I wonder if just adding useless stuff around the "print hello world" part of the program (no matter the language) might allow a lot of permutations to be valid with some languages.
I'd like the code where all permutations are valid and that is the longest possible to win. And I'm not sure my scoring method will produce such results.

5- Is a "print hello world" program the more relevant? Actually I think that the code could do anything : calculating oeis sequence, drawing rectangles or whatever, as long as all the permutations produces the same behavior. But then some people might play on internal behavior of languages such as "by default, this language prints 1", so every permutation of any source will print 1, or stuffs like this... Any thoughts?

6- I thought about making this challenge harder by actually changing "as much permutations as possible should be valid" to "all permutations should be valid". This will of course prevent a lot of languages to compete, but might result in creative and nice answers.

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ If I've read this challenge correctly, Unary is going to win with (astronomical number) divided by (astronomical number factorial). Of course, this could still be a good challenge in other languages regardless, but the scoring as is means that it's beneficial to pad the program as long as possible since the denominator grows factorially compared to the linear numerator - so yeah I think a different scoring method might be necessary (no good ideas off the top of my head though) \$\endgroup\$ – Sp3000 Oct 24 '16 at 23:07
  • \$\begingroup\$ @Sp3000 Thanks for your comment. I think that this sentence Note that only permutations that produce a code that differs from the previous ones should be considered (which I wrote right after the examples) will prevent Unary to win since it will have 0 valid permutations. \$\endgroup\$ – Dada Oct 25 '16 at 7:30
  • \$\begingroup\$ Oh right, jumped the gun and missed that sentence. In that case I think you can use Lenguage instead? (since it's basically Unary but you can choose the chars) \$\endgroup\$ – Sp3000 Oct 25 '16 at 10:49
  • \$\begingroup\$ Something like print"Hello World";123456789123456789 still produces a huge number of permutations. \$\endgroup\$ – xnor Oct 25 '16 at 17:16
  • \$\begingroup\$ @xnor indeed. I was worried (cf question 4 for the sandbox) that something like that could be possible, and it obviously is. So ask for all the possible permutations to be valid would be a better challenge? Or should I just drop that challenge? \$\endgroup\$ – Dada Oct 25 '16 at 17:18
  • \$\begingroup\$ If using a language with nops, [hello world program][arbitrary number of nops] will be even worse than xnors example \$\endgroup\$ – Destructible Lemon Oct 26 '16 at 23:52
2
\$\begingroup\$

Display an xkcd

xkcd is everyone's favorite webcomic, and you will be writing a program that will bring a little bit more humor to us all.
Your objective in this challenge is to write a program which will take a number as input and display that xkcd and its alt-text (mousover text).

Input

Your program will take an integer as input and display that xkcd: for example, an input of 1500 should display the comic "Upside-Down Map" at xkcd.com/1500, and then either print its alt-text to the console or display it with the image.

Due to their proximity across the channel, there's long been tension between North Korea and the United Kingdom of Great Britain and Southern Ireland. Due to their proximity across the channel, there's long been tension between North Korea and the United Kingdom of Great Britain and Southern Ireland.

Your program should also be able to function without any input, and perform the same task for the most recent xkcd found at xkcd.com, and it should always display the most recent one even when a new one goes up.

You do not have to get the image directly from xkcd.com, you can use another database as long as it is up-to-date and already existed before this challenge went up.

You may not display the entire webpage in an iframe or similar.

You can handle the case that there isn't an image for a particular comic (i.e. it is interactive or the program was passed a number greater than the amount of comics that have been released) in any reasonable way you wish, including throwing an exception, or printing out an at least single-character string, as long as it somehow signifies to the user that there isn't an image for that input.

This is a challenge, so the fewest bytes wins!

| |
\$\endgroup\$
  • \$\begingroup\$ I think this is probably a duplicate of codegolf.stackexchange.com/q/91847/194 \$\endgroup\$ – Peter Taylor Oct 25 '16 at 18:29
  • \$\begingroup\$ @PeterTaylor It's similar, however I think that it's different enough to warrant it's own question. That puzzle required the creation of a bot that will display any new xkcd that comes up, this one just displays one, but it can be any requested one. In addition, my puzzle also requires the title text to be displayed. \$\endgroup\$ – Pavel Oct 25 '16 at 19:23
2
\$\begingroup\$

Killer Sudoku Pro suggestions

Regular Sudoku is just about creating a enhanced Latin square and features no arithmetic on the digits 1-9 which are traditionally used.

Killer Sudoku goes further: the puzzle is tiled with polyominoes which are labelled with the sum of the cells which they cover. Additionally, no polyomino may cover two cells with the same digit, even though those digits would otherwise have been legal because they are not in the same row, column or square. It is therefore helpful to be aware of the inverse relationship: given a quantity of cells and a sum, calculate the possible values of the cells. This is also useful for solving Kakuro, which also features sums of distinct digits.

Killer Sudoku Pro goes one further step: rather than being the sum of the cells, any of the four basic operations may be used. The digits in the cells must then satisfy that basic operation.

Given a target, operator and number of cells, I would like you write a program or function to output sets of distinct digits that satisfy the arithmetic expression. To minimise the necessary output I only want distinct combinations of digits, rather than all the potential permutations. (Some puzzle creators will not allow all the permutations for subtraction and division, so taking that into account would unnecessarily complicate the question.)

Examples (example input format: target, operator, (number of cells); output format: answers " or "-separated, digits operator-separated in descending order):

14+(4) -> 8+3+2+1 or 7+4+2+1 or 6+5+2+1 or 6+4+3+1 or 5+4+3+2
4-(3) -> 9-4-1 or 9-3-2 or 8-3-1 or 7-2-1
24×(3) -> 8×3×1 or 6×4×1 or 4×3×2
2÷(2) -> 8÷4 or 6÷3 or 4÷2 or 2÷1

I/O may be in any reasonable format as long as it is clear what is going on, so you can't encode the operations as specific integers, although using * and / or their Unicode code points instead is OK, and answers must use a different separator to the digits in each answer.

This is , so the shortest solution in bytes wins.

| |
\$\endgroup\$
  • \$\begingroup\$ Could be worth noting that the only numbers to be considered are 1-9 (or you could add a third input for 1-N) \$\endgroup\$ – Jonathan Allan Oct 31 '16 at 11:23
  • \$\begingroup\$ @JonathanAllan I didn't realise 10 was a digit, but I guess I should specifically exclude 0. \$\endgroup\$ – Neil Oct 31 '16 at 12:57
  • 1
    \$\begingroup\$ Oh, I didn't notice "digit" :) \$\endgroup\$ – Jonathan Allan Oct 31 '16 at 12:59
  • \$\begingroup\$ I find the sentence begining "Some puzzle creators allow the digits from the polyomino to be used in any order" to be odd to the point of disruptive. It presupposes a "correct" order to the elements of the polyomino which isn't obvious, and the logical connection is weak. I suggest rewriting it along the lines of "You should only output one representative suggestion for each distinct set of digits; so e.g. one but not both of 9-4-1 and 9-1-4", possibly with a footnote to discuss variations between puzzle setters in whether order is significant. \$\endgroup\$ – Peter Taylor Oct 31 '16 at 21:48
  • \$\begingroup\$ @PeterTaylor The justification is only 9-4-1 and 9-1-4 actually evaluate to 4, so some creators will only use 4- for those two permutations, but I decided the question needed editing anyway. \$\endgroup\$ – Neil Oct 31 '16 at 22:36
  • \$\begingroup\$ My point about permutations was that if the polyomino is e.g. the X pentomino then the "natural" order of the cells is up for debate. But I think the new wording side-steps that concern. \$\endgroup\$ – Peter Taylor Nov 1 '16 at 8:03
2
\$\begingroup\$

Cryptographically secure favicon.

Create a cryptographically secure program which will take a string of up to 24 characters and create an image such that differing inputs can be "easily" distinguished visually. The goal being that the end image is visually appealling, and it is impossible to reverse engineer the string.

The challenge

  • Create a program or function which takes an input string and output an image in any desired format.

  • Pick a secret password and post an image generated with that password along with your submission code.

  • Optionally post some sample inputs and outputs.

OR

  • Try to post someone else's password (or just any existing collision with that password).

The scoring

  • Out of the posts whose password has not been cracked the post with the most upvotes after an arbitrary time period set sometime in the significant future.

Voters are encouraged to vote based on ingenuity and aesthetic appeal, but can vote for whatever posts they like.

| |
\$\endgroup\$
  • \$\begingroup\$ This is essentially the same as codegolf.stackexchange.com/q/25443/194 and codegolf.stackexchange.com/q/95836/194 \$\endgroup\$ – Peter Taylor Oct 29 '16 at 21:32
  • \$\begingroup\$ @PeterTaylor I think this challenge is fundamentally different in that the format of the output is not fixed, and the method of encoding the image should be interested. \$\endgroup\$ – Rohan Jhunjhunwala Oct 30 '16 at 4:05
  • 1
    \$\begingroup\$ To be clear, unlike those two questions, the answers of this question should usually output visually distinguishable images for different secrets, instead of \$\endgroup\$ – jimmy23013 Oct 31 '16 at 12:40
  • \$\begingroup\$ I'd call this too broad. On top of hashing, find a pleasing way to represent it is largely a question of art and aesthetics. Having different outputs be visually distinguishable happens is easy if the hash function already brings close inputs to far outputs. \$\endgroup\$ – xnor Nov 2 '16 at 3:56
  • \$\begingroup\$ I have to agree with xnor here, as stated, this is too broad. However, I think the idea is interesting, although there will always be the issue of defining what cryptography is "too good" (and thereby already disallowed). Also, it might be that the good essence of this challenge is completely covered by the links from Peter \$\endgroup\$ – Liam Nov 3 '16 at 1:00
  • \$\begingroup\$ @xnor we have had "art"challenges throughot the graphical output tag. \$\endgroup\$ – Rohan Jhunjhunwala Nov 3 '16 at 10:32
2
\$\begingroup\$

Table Math

You should which side of a table is the oldest, from ASCII art. I think the best way to explain is with an example, so here is one.

You have a table, made out of +, |, and -. Here is one.

+--+
|  |
|  |
|  |
+--+

It will alway be a rectangle, just not always square (but it can be square). There will also be people around the table, marked by the letters A-Z. There will never be too many people on a side, or less than one. Just to make it harder, the people will not always be in order, like this:

  P
 +--+
I|  |
O|  |Q
 |  |J
 +--+
   U

There will never be anybody next to a plus sign(+). You will be given input on how old each member is, separated by a newline, from the first letter that appears alphabetically (I in this example) to the last letter that appears alphabetically (U in this example), like this:

20
8
31
56
6
56

As seen here, ties are allowed. You should then output the sides with their ages separated with a space, in order from oldest to youngest, like this.

Top 56
Bottom 56
Left 51
Right 14

Note that for everything in this challenge, you can choose the capitalization of the letters, even the input. The winner is the submission with the shortest code.

| |
\$\endgroup\$
2
\$\begingroup\$

Interpret Developers

Developers is a joke language that parodies an incident at a Microsoft Developer's conference where Steve Ballmer is supposed to have chanted the word developers at least 14 times in a row. It is basically Brainfuck with a few extensions. It appeared briefly in the Wikipedia in the beginning of 2006, but it has not reappeared anywhere since its deletion. [source]

Your job today is to ressurect this beautiful language, and create an interpreter in the fewest number of bytes. You will have to implement the following commands, which contain their Brainfuck and C equivalents:

| Key            | BF Equiv | C Equiv         |
|----------------|----------|-----------------|
| "Developers"   | +        | ++*ptr;         |
| "Developers"*2 | -        | --*ptr;         |
| "Developers"*3 | >        | ++ptr;          |
| "Developers"*4 | <        | --ptr;          |
| "Developers"*5 | ,        | *ptr=getchar(): |
| "Developers"*6 | .        | putchar(*ptr);  |
| "Developers"*7 | [        | while (*ptr) {  |
| "Developers"*8 | ]        | }               |

As this is standard , the aim of the game is to create the shortest interpreter possible.

Specification

Your interpreter should behave accordingly:

  • Developers/Developerz commands are separated by any whitespace.

  • Anything that is not a valid command should be ignored.

  • There will never be any more than 8 Developers (or 3 Developerz) present in the program that are not separated by whitespace.

  • Input can be interactive or provided at runtime.

Bonus

If you would like to earn bonus points, you can also implement the following three extensions to the Developers language. These do not have a Brainfuck equivalent.

| Key            | C Equiv                          |
|----------------|----------------------------------|
| "Developerz"   | Sleep(strlen(buffer)*10);        |
| "Developerz"*2 | system("cls");||system("clear"); |
| "Developerz"*3 | *p = rand() & 0xFF;              |

If the goal of these is not clear:

  • Developerz should sleep the program for 10ms for ever character in an input string

  • DeveloperzDeveloperz should clear the screen.

  • DevelopersDeveloperzDeveloperz should assign the currently pointed to cell to a random integer between 0 and 255.

For each command you implement, you may multiply your score by 0.75. Thus, by implementing all three, your score would be 42.1875% of the byte count.

| |
\$\endgroup\$
  • \$\begingroup\$ That's a pretty big bonus for implementing the three extensions. That's probably either such a hard task no one will go for it or such a huge bonus everyone will <i>have</i> to go for it. \$\endgroup\$ – Pavel Nov 8 '16 at 3:56
  • \$\begingroup\$ @Pavel I had made it that much because I felt that these bonuses would only benefit languages that were verbose enough that they probably wouldn't beat a Jelly/Python/05AB1E answer (except for the random number functionality), and I dont think the shorter languages tend to have sleep functions or system calls available to them. \$\endgroup\$ – Kade Nov 8 '16 at 11:11
  • 5
    \$\begingroup\$ This seems like a dupe of "Interpret BF" to me. \$\endgroup\$ – Peter Taylor Nov 8 '16 at 14:34
2
\$\begingroup\$

Regex Crossword

Challenge

Write the shortest program that outputs a valid solution to a regex crossword. A regex crossword is a crossword that has regular expressions for the clues, like in this Puzzling SE puzzle: The Prognosticator.

Terminology your program needs to know (simplified from here)

Quantifiers:
x*     0 or more of x (any group instruction)
x+     1 or more of x
x?     0 or 1 of x
x{y}   Exactly y of x
x{y,}  y or more of x
x{,y}  y or less of x

Groups:
.      Any char except \n
(x|y)     Strings x or y (may be multichar), indexed from 1 from the start of clue
(xyz)     Multichar string literal, indexed from 1 from the start of clue
[xyz]     Any of characters x, y or z
[^xyz]    Not the characters x, y or z
[^x|y]    Not x or y (may be multichar)
[B-N]     Letters between B and N inclusive (any letters, caps or not)
[3-6]     Numbers between 3 and 6 inclusive (any digits)
[B-NR-Z]  Multiple ranges (could be digit ranges as well)

Escape sequences:
\7  Get the result of the bracketed instruction indexed 7 (any num)
\r  Literal r where r is a character used in an instruction above
\\  Literal backslash
\W  a-z, A-Z, 0-9, _ (underscore)
\w  Not a character in \W
\d  A digit
\D  Not a digit
\s  Space
\S  Not a space

Test Cases

Input can be any format, examples use: Width Length Top down clues from left to right Bottom down clues from left to right (if they don't exist, newline) Left across clues from top to bottom Right across clues from top to bottom (if they don't exist, newline)

Output must be the completed grid.

Sample input (from here):

Input 1:
2 2
[^SPEAK]+
(EP|IP|EF)


(HE|LL|O)+
[PLEASE]+


Output 1:
HE
LP
Input 2:
2 2
[COBRA]+
(AB|O|OR)+


(.)+\1
[^ABRC]+


Output 2:
OO
OO
Input 3:
2 2
.?.+
.+


[*]+
/+


Output 3:
**
//
Input 4:
3 4
(.)\1(.)\2
[C\sOU]+
[^PU\sH]+
[PIF]+
.*[OWE]*
(TN|LF|TF)+
.[LUH]+
(P|K)[^U]+
.*C+[TIF]
(NO|ONE|ION)*
.*(L)+
[PUF\s]*
[TIC]*
[NOI\sE]+
Output 4:
PUL
P F
ICT
ION
Input 5:
3 7
[^ro\se]*(whe|who)
[are](.)[saint]+\1(v)
.{2}[st\sel]+
[^vys]+
.(\ssai).*
(le|\st|s|or)+
(rr|fro)*
[^saint]+
[\sush]*
[a\si]+
[with]*
[hel\s]+
.*
[fr\so]+
(m\s|sm)[rose]
(s|us)+
[^aw](a).*
[^hear]+
.*[fil]
(ve|o|vo)+
Output 5:
fro
m r
uss
ia 
wit
h l
ove

This is , so the shortest answer in bytes wins!

Standard loopholes apply, and no built-ins for regex testing or matching. Your program must terminate in a reasonable amount of time.

You may assume that each input has exactly one solution.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ 1. "No built-ins" means "You may not answer this question". Every program uses built-ins except zero-byte ones in the languages which support them. "No built-ins for regex testing or matching" would, on the other hand, not be unreasonable. 2. There's currently no constraint requiring the answers to complete the test cases before the heat death of the universe. Is this intentional? \$\endgroup\$ – Peter Taylor Nov 8 '16 at 21:05
  • \$\begingroup\$ @PeterTaylor Thanks for that, I've added your suggestions in. I'm new to code golf. \$\endgroup\$ – boboquack Nov 8 '16 at 21:38
2
\$\begingroup\$

Balancing Act

Edit: Challenge Live here

A see-saw (supposedly from the French 'ci-ça', meaning 'this-that') forms a third of the holy trinity of playground equipment, along with the similarly ubiquitous slide and swing. A see-saw is in perfect balance if, and only if, the sum of the moments on each side are equivalent. A see-saw can therefore be balanced by adding a specific quantity of weight to the side with the lower moment sum; achieving this is your goal for this challenge.

Challenge

Your challenge is to take a depiction of a see-saw as input and output it again, with weight added to one end of the see-saw to balance it.

Input

Your program must take, in any reasonable format, an ASCII see-saw such as the following:

100             100
-------------------
         ^         

The first line contains two numbers, each representing weights on the see-saw. Exactly one weight is present on each side, each acting on the very end of its side of the plank. Weights are guaranteed to be integers, and always align with their corresponding end of the plank. These numbers will never overlap the fulcrum (^).

The second line represents the 'plank' of the see-saw. Each dash (-) represents an equal length to each other dash, with the sole exception of the dash directly over the fulcrum (^), which has no length.

The third line represents the fulcrum of the see-saw. This fulcrum is marked by the only character that is not a space on this line, a circumflex ('^'). The fulcrum can be positioned anywhere along the length of the plank in a valid input so long as enough space is left so that the numbers representing weights do not overlap the fulcrum in either the input or the output.

The input is guaranteed to have three lines, and have no white-space prior to or after the characters that constitute the see-saw (excepting, of course, the third line, which requires it).

Output

For output, the same see-saw depiction should be printed to stdout, but with one (and only one) of the weights replaced with a larger weight, so as to balance the see-saw. Inputs are guaranteed to make this possible using integers alone. Therefore, weights must be shown without decimal points or any other similar notations. If your language does not use stdout you should go by community / meta consensus on output. Trailing newlines are fine but any other changes to the depiction format are probably not OK.

Exemplification

Test Inputs and Corresponding Outputs

Input 1

12                22
--------------------
             ^      

Output 1

12                26
--------------------
             ^      

Input 2

42       42
-----------
     ^     

Output 2

42       42
-----------
     ^     

Input 3

3             16
----------------
        ^      

Output 3

14            16
----------------
        ^      

Input 4

1                56
-------------------
    ^              

Output 4

196              56
-------------------
    ^              

Reference Implementation - Python 3

# Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])

Rules

  • This is , so the shortest code wins counted in bytes. Check meta if counting bytes is awkward in your language.

  • Standard rules/loopholes apply.

  • Input must be taken in a reasonable format. A non-exhaustive list of appropriate formats are given as follows:

    • A single string with lines separated by newline characters
    • A list of strings, each string represented a line
    • A 2D Array or Matrix of characters

Sandbox Notes

Please comment on any parts of the spec, especially input / output requirements, that you find confusing or ambiguous. I haven't written a challenge before so I'm open to the fact that there's quite a bit I've missed. Any and all feedback welcome.

Some users in the comments have rightly pointed out similarities between this challenge and others; please weigh in as to if you think this is a dupe or a unique challenge in its own right. Thanks!

| |
\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! A pretty decent first challenge. It's pretty similar to this one, but yours is, in my opinion, different enough to not be a duplicate. It's also pretty close to this one posted in the Sandbox a few posts down. I think that all three are different enough to not be dupes, but I'll hold off on final judgment to hear what others say. \$\endgroup\$ – AdmBorkBork Nov 10 '16 at 20:57
  • \$\begingroup\$ @TimmyD thanks for the welcome! Looks like I need to up my searching game! I understand if this is deemed a duplicate but it seems to differ in a fair few ways from the others at least. \$\endgroup\$ – FourOhFour Nov 10 '16 at 21:01
  • 1
    \$\begingroup\$ Welcome! For me, a nice challenge and well explained with clear examples. I'll also hold back on the dupe side but agree with TimmyD that it may be different enough. Well done for using the Sandbox anyway. It' a shame that more contributors don't. I'm going to +1 just for that. \$\endgroup\$ – ElPedro Nov 10 '16 at 21:10
  • \$\begingroup\$ @ElPedro thanks, appreciate the feedback and the vote. \$\endgroup\$ – FourOhFour Nov 10 '16 at 21:13
  • \$\begingroup\$ Having read (again) through the examples mentioned by @TimmyD I would not say this is a dupe. Possibly mention that it is related though. \$\endgroup\$ – ElPedro Nov 10 '16 at 21:34
2
\$\begingroup\$

Find the optimal sorting network

Sorting networks are an abstract model of "wires" carrying numbers, which outputs them sorted.

A comparator in a sorting network works as follows:

https://en.wikipedia.org/wiki/File:Sorting-network-comparator-demonstration.svg

This is the optimal sorting network for 4 numbers:

https://en.wikipedia.org/wiki/File:SimpleSortingNetworkFullOperation.svg

Since there are two kinds of "optimal" sorting networks people care about, we are going for the least number of comparators (those vertical lines).


Given a non-negative integer n (so yes, 0 and 1 need to be supported), output a list of comparators which designates an optimal sorting network for n inputs. The "comparators" are a pair of indices which say which indices in the working array to compare / swap. The indices must be 0-based.

So for the example sorting network, this would be a valid output (viewing 0 as the top wire):

(0, 2), (1, 3), (0, 1), (2, 3), (1, 2)

As would this:

(0, 2), (1, 3), (2, 3), (0, 1), (1, 2)

Additionally, any whitespace is ignored (except for tokenizing), and any non-digit is considered whitespace, so this is also a valid output:

0 2 1 3 2 3 0 1 1 2

And also:

(0, 2)
(1
 3)
((2, 3, 0), 1)
(1, 2)

Furthermore, functions may simply return some iterable that - when flattened - gives the list of numbers in the correct order.

| |
\$\endgroup\$
  • \$\begingroup\$ I have an algorithm to do this; it's O((n^2)! n! n), so very very slow. It might compute size 3, but not size 4. \$\endgroup\$ – Justin Nov 19 '16 at 7:04
  • \$\begingroup\$ I think it's worth giving an example of a sorting network in action on some input. \$\endgroup\$ – xnor Nov 19 '16 at 7:12
  • \$\begingroup\$ What are the bounds on n? Obviously it doesn't make sense to have n < 0, but do answers need to handle n=0 and n=1? \$\endgroup\$ – Peter Taylor Nov 19 '16 at 13:00
  • \$\begingroup\$ @Justin are you still planning to release this challenge? I'm asking because I wanted to make a very similar challenge that would probably be considered a dupe. \$\endgroup\$ – flawr Jul 18 '19 at 6:53
  • \$\begingroup\$ @flawr No, go for it \$\endgroup\$ – Justin Jul 18 '19 at 12:16
2
\$\begingroup\$

ROT-13? More like ROT-Rand!

This challenge is to take the following list of characters (ASCII 32 to 126):

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Randomly shuffle it:

wypP+]`=3&IJ6*xAh{zi_l4Y#k~S F?-oReU;(0m,Z5'trs!aLCQ/g}OjM<u[qE2)BTVb$>19%c:HW@8."nD\Nf7dXKv^|G

Take in an input string:

ROT-Rand!

Then replace the characters in the string, with their new shuffled equivalents:

C!/*CB@by

Using this methodology on large ASCII-based/dictionary based texts would result in something that is decipherable using much trial and error and would be a decent way to encode a long message.

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
wypP+]`=3&IJ6*xAh{zi_l4Y#k~S F?-oReU;(0m,Z5'trs!aLCQ/g}OjM<u[qE2)BTVb$>19%c:HW@8."nD\Nf7dXKv^|G
 ^           ^                                    ^              ^  ^         ^^    ^
 !           -                                    R              a  d         no    t

Rules

  1. Your only input is the text to be "encrypted".
  2. Your output is the encrypted string.
  3. The ASCII list must be randomly shuffled, built-ins are allowed.
  4. , shortest in bytes wins.
| |
\$\endgroup\$
  • \$\begingroup\$ 1. I'm guessing from context that "their new shuffled equivalents" means that we're generating a random substitution cipher, but I don't see any actual definition of the equivalence. 2. If I'm correct, this is pretty boring, but could be made more interesting with the (justifiable) modification that the substitution should be a random derangement rather than just a random permutation. That will probably force most languages to do more than just apply two built-ins. \$\endgroup\$ – Peter Taylor Nov 26 '16 at 22:44
  • \$\begingroup\$ @PeterTaylor derangement? \$\endgroup\$ – Magic Octopus Urn Nov 27 '16 at 15:50
  • \$\begingroup\$ en.wikipedia.org/wiki/Derangement \$\endgroup\$ – Peter Taylor Nov 27 '16 at 16:05
2
\$\begingroup\$

Roflcopter

Your task is to print animated helicopter.

Rules

  1. Animation should contain at least two frames.

  2. Delay between frames is up to you, but rotation of airscrews should be visible.

  3. Helicopter could be very simple (simpler than standard roflcopter showed below) but it should leave no doubt what is it. All ASCII chars are allowed.

  4. No caption below needed.

  5. Printing animation to file would be hard, although all standard output destinations are allowed.

  6. This is , so etc.

roflcopter

I believe I can fly.

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ You should probably place the ASCII of each frame of the Roflcopter in the challenge. Also, is the ROFL COPTER!!! at the end necessary? \$\endgroup\$ – clismique Nov 24 '16 at 8:43
  • \$\begingroup\$ +1 For caption necessity or not, I updated question. In my opinion providing frames will make challenge too easy. \$\endgroup\$ – paldir Nov 24 '16 at 8:48
  • \$\begingroup\$ So will the design of the Roflcopter be the same for all submissions, with the same plane body, rotors and stuff? \$\endgroup\$ – clismique Nov 24 '16 at 9:09
  • \$\begingroup\$ It's up to users, how exactly it will look, but it should be helicopter-like. Ok, I think you're right, this task is too ambiguous. I will try with another question. \$\endgroup\$ – paldir Nov 24 '16 at 9:12
  • 1
    \$\begingroup\$ You can just standardise the copter itself, and it shouldn't be ambiguous... \$\endgroup\$ – clismique Nov 24 '16 at 9:18
2
\$\begingroup\$

Hexasweep: A two-part challenge

Part 1: The solver

Your task is to solve a Hexasweep puzzle.

A Hexasweep puzzle is set out on a grid of diamonds arranged in hexagonal shapes, of which the board looks like a hexagon, like so:

         _____
        /\    \
  _____/ X\____\_____
 /\    \  / XX /\    \
/X \____\/____/X \____\
\ X/ XX /\    \ X/    /
 \/____/  \____\/____/
 /\    \  / X  /\    \
/  \____\/____/  \____\
\  / XX /\    \  / XX /
 \/____/  \____\/____/
       \ X/    /
        \/____/

The above image is composed of 7 hexagons (21 diamonds), and is thus a Hexasweep puzzle of size 2. If you want to expand it, cover the current Hexasweep puzzle with more hexagons (so that there are 19 hexagons - that will make a Hexasweep puzzle of size 3).

Each diamond can contain 0, 1 or 2 "bombs", with bombs depicted as X above.

The above image would be read from top to bottom, starting from the left:

2,0,0,2,0,2,1,0,1,0,2,0,1,0,0,2,0,0,0,0,2

That is now the "condensed form" of the puzzle.

Numbers are marked on "intersection points", to show how many bombs are on the diamonds which are touching those intersection points - the intersection points of this grid are shown below using O.

         _____
        /\    \
  _____/  OO___\_____
 /\    \  OO   /\    \
/  OO___OO___OO  OO___\
\  OO   OO   OO  OO   /
 \/___OO  OO___OO____/
 /\   OO  OO   OO    \
/  OO___OO___OO  OO___\
\  OO   OO   OO  OO   /
 \/____/  OO___\/____/
       \  OO   /
        \/____/

As you can see, there are two "types" of intersection points - those with 3 diamonds touching it, and those with 6 (the one that are touching the edge of the board aren't counted):

  _____
 /\  XX\
/X OO___\
\ XOO   /
 \/____/

       /\
 _____/X \_____
 \ XX \ X/    /
  \____OO____/
  / XX OO  X \
 /____/  \____\
      \ X/
       \/

The two intersections would be marked with 4 and 8 respectively.

In the original Hexasweep puzzle above, the intersection numbers would be:

   3
4 5 4 2
 2 1 3
2 4 1 2
   1

Which would be condensed to:

3,4,5,4,2,2,1,3,2,4,1,2,1

Given an input in this "condensed form", you must output the original puzzle, in "condensed form" (see above).

Specs:

  • Any delimiter for the "condensed form" as input are allowed (it doesn't have to be , separating the numbers).
  • You may output a list, or a string with any delimiter.
  • Your program must be generalised: it must be able to solve Hexasweep puzzles of any size (at least up to size 4).
  • If there is more than 1 possible answer, your program must output the single character N.

This is , so shortest code in bytes wins!

If there is a tie, the earlier post is declared the winner.

Part 2: The maker

Your task is to generate the smallest Hexasweep puzzle with a single solution that encodes a binary number.

Because any diamond in a Hexasweep puzzle can have either 1 or 2 bombs (if the diamond has bombs), you can encode binary numbers into it. In this puzzle (condensed form):

2,0,0,2,0,2,1,0,1,0,2,0,1,0,0,2,0,0,0,0,2

The only digits that matter are the non-zero digits, so this turns into:

2,2,2,1,1,2,1,2,2

Decrement each number by 1:

111001011

Which is equal to 459.

Your task is to make a program that generates that Hexasweep puzzle in the smallest grid with a single solution.

Specs:

  • You must output the condensed form of the Hexasweep puzzle.
  • You can output either an array of numbers, or a string with any delimiter.
  • You will be tested on all positive integers from 10,000 to 15,000, and your program is expected to return a value for any integer in 10 minutes.

Your final score is the total size grid for every test integer added together (so if you get a size 3 grid for every number, your final score would be 15,000). The lowest score is declared the winner.

If there is a tie, the earlier post is declared the winner.


Meta:

  • Should this be one challenge or two? If it's one challenge, should the score just be added up for both programs?
  • Any improvements in explanation?
  • Is this a dupe?
| |
\$\endgroup\$
  • \$\begingroup\$ Can I post this abandoned proposal? \$\endgroup\$ – programmer5000 Jun 9 '17 at 12:24
2
\$\begingroup\$

Please do my Martian homework posted

For Sandbox, please note

This was originally conceived of as two related challenges; Please do my Martian homework and Please grade my Martian homework.

Though the task itself is different, the basic description of the task (that is, what is a Martian essay) is the same (though I may edit it later anyway), but just to avoid confusion:

  • Please do my Martian homework was posted
  • Please grade my Martian homework is what's left

Please Grade my Martian Homework

History

Around the turn of the 20th century, spiritualist Catherine-Elise Müller allegedly communicated with Martians. During somnambulatory trances, she would write out Martian scripts. Psychologist Théodore Flourney discovered her Martian writings were very similar to her native French, and in his book "From India to the Planet Mars", he documented Catherine's Martian alphabet. The following is loosely based on that alphabet with an extended mythos.

Problem Description

The Martian language has 21 characters, shown here next to each Latin equivalent:

enter image description here

Unfortunately, there's no Unicode for Martian (despite Mars being part of the universe), so we're stuck using Latin characters.

Whereas in English our phonemes break out into two major types (consonants/vowels) which we loosely map to letters, Martian has three letter types:

  • The vowels: a e i m n o u
  • The hard consonants: b c d g k p t
  • The soft consonants: f h l r s v z

In addition to this, the Martian language contains a single punctuation mark--the period.

A Martian word is a set of 3 to 9 letters. All Martian words have at least one vowel, one hard consonant, and one soft consonant (in any arrangement). For example, fng, cdaz, vpi, and pascal are Martian words.

A Martian sentence is a set of 3 to 9 Martian words delimited by spaces and followed by a period.

A Martian paragraph is a set of 3 to 9 Martian sentences, delimited by spaces, and followed by a newline.

A Martian essay is a collection of Martian paragraphs that contains no contiguous word repetitions.

A contiguous word repetition is any construct S S where S is a contiguous set of words. Note that this definition ignores sentence and paragraph boundaries.

Challenge

The Martian homework assignment is to write an essay between 729 and 810 words. The essay is graded on a pass/fail basis; pass simply means it's a valid Martian essay according to the above definitions, and fail means not pass.

Your challenge is to write a function or program that accepts data as input, and returns a truthy value if that data is a valid Martian essay between 729 and 810 words, or a falsey value if it is not. (Don't forget that you must fail the input if there is a contiguous repetition).

This is code golf. Shortest code in bytes wins. Standard loopholes disallowed.

TBD

Post link to examples in first challenge? Repeat examples? Should second challenge still have word counting?

| |
\$\endgroup\$
  • \$\begingroup\$ Whoops; most of the post is almost identical so I thought it was the same, but the task is indeed different. I've deleted my original comment. \$\endgroup\$ – user62131 Dec 5 '16 at 0:22
2
\$\begingroup\$

Monopoly Continued

So you've got your Monopoly board, shall we start a game?

To start with, we'll need some dice and to know where we land!

Write a program that outputs the rolls and resting places of a given number players for a given number turns.

Input

In any suitable format for your language

  • The number of players up to a maximum of 6
  • The number of turns to output up to a maximum of 250

Output

In any meaningful option for your chosen language

  • The output should be in the format: PlayerNumber, Die1, Die2, InitialOfRestingPlace
  • Each roll should be separated by a new line.

Rules

General

  • Use the US Board for the names of squares
    F K C I I B A V W M G 
    N                   P
    T                   N
    C                   C
    S                   P
    P                   S
    V                   C
    S                   P
    E                   L
    S                   B
    J C V C O R I B C M G 
  • All players start on Go (bottom right)
  • A player rolls (pseudo randomly generated) two six-sided dice, once per turn, unless they roll doubles (described below), and moves that many spaces clockwise.

Doubles

  • Rolling doubles means the player can roll again
  • Rolling three doubles in a row lands the player in jail and the players turn ends

Jail

  • Landing on the "Go To Jail" square sends the player to jail
  • While in jail, the player may not move unless they roll a double
  • Rolling a double to get out of jail ends the player's turn
  • Landing on the jail square does not mean a player is in jail

Chance/Community Chest

  • These squares currently have no effect.

Example output

Excluding comments

For input 2,3

//Turn 1
1,2,2,I   //Player lands on Income Tax, Player rolled doubles, roll again
1,2,4,J   //Player lands on Jail and turn ends
2,5,3,V   //Player lands on Vermont Avenue and turn ends

//Turn 2
1,5,5,F   //Player lands on Free Parking, doubles, roll again.
1,5,5,G   //Player lands on Go To Jail, goes to Jail, turn ends
2,3,4,P   //Player lands on Pennsylvania Railroad, and the turn ends.

//Turn 3
1,5,2,J   //No double, player remains in Jail
2,6,3,I   //Player lands on Illinois Avenue and turn ends.

Scoring

This didn't start as a challenge, but in coming up with scoring, a lot of the elements I thought of for scoring were very "golf-y" by nature, so I've changed my mind (before any answers are posted). See the edit history if the previous scoring intrigues you.


Despite first posting this on the sandbox, I'm bound to have missed something! Please feel free to point out mistakes or problems.


Concerns

  • Too complex
  • How to score?
  • Doesn't include Chance or Community Chest cards
| |
\$\endgroup\$
  • \$\begingroup\$ I am actually coding monopoly right now which is how I got the idea for the code golf, the movement isn't the most complex thing in the world but the buying and building houses etc is very much so. I am not sure if you will get many takers if it is code-gold, maybe a code-challenge? \$\endgroup\$ – jacksonecac Oct 19 '16 at 14:59
  • \$\begingroup\$ This isn't too complex. However, it is tough to make test cases, as the game is non-deterministic, and testing for edge cases (I landed on Jail, but I'm not in Jail) is tough for the reader to do. I'd still include the Monopoly board this time around. \$\endgroup\$ – Nathan Merrill Oct 19 '16 at 15:05
  • \$\begingroup\$ Incomplete. What about chance / community chest cards which send the player to a different square? \$\endgroup\$ – Peter Taylor Oct 19 '16 at 15:29
  • \$\begingroup\$ @NathanMerrill, do you propose any changes? Or just pointing out a risk? \$\endgroup\$ – James Webster Oct 19 '16 at 16:00
  • 1
    \$\begingroup\$ @PeterTaylor I did intentionally leave out chance and community chest to reduce complexity \$\endgroup\$ – James Webster Oct 19 '16 at 16:01
  • \$\begingroup\$ @jacksonecac I'm all for code challenge, but I'm unsure how the scoring would work \$\endgroup\$ – James Webster Oct 19 '16 at 16:04
  • \$\begingroup\$ Scoring could be by popularity contest. \$\endgroup\$ – jacksonecac Oct 19 '16 at 19:35
  • 2
    \$\begingroup\$ Popularity contest is a terrible idea. Code golf would be much better. \$\endgroup\$ – user45941 Oct 21 '16 at 0:23
2
\$\begingroup\$

Generate me a QFP chip!

This challenge is now live!

QFP is a type of form factor for an electrical component where pins come out the sides of a chip. Here are is a picture of a typical QFP component: enter image description here

you can see that the general formula is to have 4 sides of equal numbers of pins.

Your challenge is to create a program that takes in an integer, thich represents the number of pins on one side, and creates an ASCII QFP component with numbered pins.

Input:

a single integer which represents the number of pins on one side

Output:

An ascii QFP chip with an apropriate pinout.

Example:

input:1

  4
 ┌┴┐
1┤ ├3
 └┬┘
  2

input:2

  87
 ┌┴┴┐
1┤  ├6
2┤  ├5
 └┬┬┘
  34

input:12

   444444444333
   876543210987
  ┌┴┴┴┴┴┴┴┴┴┴┴┴┐
 1┤            ├36
 2┤            ├35
 3┤            ├34
 4┤            ├33
 5┤            ├32
 6┤            ├31
 7┤            ├30
 8┤            ├29
 9┤            ├28
10┤            ├27
11┤            ├26
12┤            ├25
  └┬┬┬┬┬┬┬┬┬┬┬┬┘
   111111122222
   345678901234

Rules:

  • all QFP chips must be enclosed and sealed as well as ascii provides. spacing is of utmost importance.
  • pin numbering must be done as in the examples (Read left to right, top to bottom, numbered counter clockwise)
  • You may start numbering at 0, but this must not affect the chip (an input of 12 still needs 12 pins per side)
  • The only valid characers in your output are 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤, spaces, and newlines.

This is a codegolf, and as such, The code with the least number of bytes wins! Good Luck!

| |
\$\endgroup\$
  • \$\begingroup\$ @Geobits thank you! fixed. \$\endgroup\$ – tuskiomi Nov 17 '16 at 20:42
  • 1
    \$\begingroup\$ Do we have to use boxdrawing characters or can we use + instead? If you use them, it means languages that don't support nonascii can't compete. Also what encodings are allowed? codepage 437? UTF-8? Include the codepoints in the question. \$\endgroup\$ – Level River St Nov 28 '16 at 22:01
  • \$\begingroup\$ @LevelRiverSt thank you for your feedback! It was my intention to keep those languages out of the challenge. \$\endgroup\$ – tuskiomi Nov 29 '16 at 15:52
  • \$\begingroup\$ Now that this has been posted you should consider editing it down to a link and deleting the answer. \$\endgroup\$ – Wheat Wizard Mar 3 '17 at 0:01
2
\$\begingroup\$

The social network

On my social network, two users are "friends" if their name share a common letter. For exemple, bob and bill are friends, as they share the letter b.

Given a list of user names:

  • display a falsy value if there exist in the list two distinct users x and y that cannot be related through a friendship chain;
  • else, display a truthy value.

Examples

abc cde efg ghi should return true, as abc is friend with cde, which is friend with efg, which is friend with ghi : all users are related.

abc cde fgh hij should return false, as for example abc and fgh cannot be related through a friendship chain.

abc should return true, as we cannot find in that list two unrelated users.

Input

  • You can read the name list in any convenient format for your language.
  • You can assume all the names are lowercase and use only the characters a-z.
  • You don't need to handle the empty list, any result (true, false, program crash) is acceptable for it.
| |
\$\endgroup\$
  • \$\begingroup\$ We've had transitive closure questions before (1, 2). This may be different enough to run, though (especially because the format increases the chance of a regex solution doing well), although it's particularly close to my second link there. I'd recommend the use of the graph-theory tag, though, as it's clearly heavily related to the other transitive closure questions. \$\endgroup\$ – user62131 Dec 31 '16 at 23:11
  • \$\begingroup\$ @ais523 yes that's almost same than codegolf.stackexchange.com/questions/8647/…... will not post then \$\endgroup\$ – Arnaud Jan 2 '17 at 3:10
2
\$\begingroup\$

Smallest integer divisible by 2..n

Given an integer n, output the smallest integer divisible by 2,3,4,...,n inclusive.

Example

2520 is divisible by every integer from 2 to 10.

Scoring

Shortest code in bytes wins.

Sandbox

  • Dup?
  • Better Wording?
  • Restrictions/Rules?
| |
\$\endgroup\$
  • \$\begingroup\$ So just lcm(2..n)? \$\endgroup\$ – FlipTack Dec 31 '16 at 12:18
  • \$\begingroup\$ you're right. would be marked as dup I guess :D \$\endgroup\$ – Seims Dec 31 '16 at 13:09
  • \$\begingroup\$ Actually, I don't think there's been challenges exactly like this before. I wouldn't call it a dupe. \$\endgroup\$ – FlipTack Dec 31 '16 at 14:41
2
\$\begingroup\$

Pseudoku Cops and Robbers King of the Hill

(I know that another user, @NathanMerrill, is proposing a similar contest. I started playing with the idea for this type of contest independently yesterday, but have since chatted with in The Nineteenth Byte. He is currently undecided on the type of puzzle to use and has some different ideas on how to evaluate participants' performance, so I feel comfortable proposing my idea as a separate challenge.)

Sudoku is a well-known logic puzzle. It is a puzzle of four nines: nine rows of cells, nine columns of cells, nine 3x3 adjacent and distinct blocks of cells, and nine values that any cell can have. A valid Sudoku arrangement or solution is one in which every row, cell, and block has all nine values exactly one time. For example, consider the following valid solution:

+-----+-----+-----+
|4 6 1|5 7 3|2 8 9|
|5 7 8|2 1 9|4 6 3|
|3 2 9|6 8 4|1 7 5|
+-----+-----+-----+
|9 8 4|7 6 2|3 5 1|
|7 5 6|3 4 1|9 2 8|
|2 1 3|9 5 8|7 4 6|
+-----+-----+-----+
|8 3 5|1 2 7|6 9 4|
|6 9 7|4 3 5|8 1 2|
|1 4 2|8 9 6|5 3 7|
+-----+-----+-----+

These are turned into puzzles by removing many of the values in the arrangement in such a way that all blanks are mirrored horizontally and vertically across the puzzle and so there is only one valid way to fill in the blanks to get a valid Sudoku solution. For the above puzzle, this might look like this:

+-----+-----+-----+
|4    |     |2 8  |
|  7  |  1  |    3|
|    9|    4|1    |
+-----+-----+-----+
|     |7 6  |3 5 1|
|     |     |     |
|2 1 3|  5 8|     |
+-----+-----+-----+
|    5|1    |6    |
|6    |  3  |  1  |
|  4 2|     |    7|
+-----+-----+-----+

Someone who wished to play this Sudoku puzzle would then use the information provided to find the original solution.

Sudoku has some interesting properties that allow it to be generalized to similar puzzles with different rules that are sometimes called "Pseudoku" (which is pronounced the same way as the actual puzzle, SOO-DOE-KOO, so please stop saying SOO-DOO-KOO). For our purposes, we will make two differences. First, it may be possible to generate harder puzzles by removing the restriction for symmetric removals. The following is a valid puzzle by Sudoku rules, so why not allow it?

+-----+-----+-----+
|4   1|  7  |2    |
|5    |2   9|     |
|3    |  8  |     |
+-----+-----+-----+
|  8 4|7   2|    1|
|     |3   1|  2  |
|     |     |     |
+-----+-----+-----+
|     |     |6    |
|  9 7|     |     |
|1    |     |5 3  |
+-----+-----+-----+

Second, Sudoku's properties allow us to define games with different sizes. You can define a Pseudoku game with a parameter N where the resulting board has N^2 rows, N^2 columns, N^2 blocks of size NxN, and N^2 values for each cell. Standard Sudoku would be a Pseudoku variant with N=3. So the following would be a valid Pseudoku(2) game:

+---+---+
|1  |   |
|   |  3|
+---+---+
|  1|4  |
|4  |   |
+---+---+

and an example Pseudoku(4) game:

+-----------+-----------+-----------+-----------+
|11         |      10  4| 1     9   | 2       16|
| 6     5   |   15  1   |    3     2|12  8      |
|10    13 14|         12| 5       15| 4     7   |
| 2  3      |    6    13|       8 11|    5    10|
+-----------+-----------+-----------+-----------+
| 7 11 12  9|14        2|16  1  4   |           |
|           |   10  4   |          3|13    16 11|
| 4       10|   16    15|   12      |          6|
| 1 16  2   |11  3      |   10     8|           |
+-----------+-----------+-----------+-----------+
| 3        2|       6   |13         | 5 14     1|
|    7      |          5|           |           |
|   13 14  4|12    16   |           | 8  9      |
|    5 16   |13     9   | 4     2  1|           |
+-----------+-----------+-----------+-----------+
|14 12     7|           |   15     4|11     6   |
|    9      | 6         |11 16      |       3   |
|      11   | 8 13     1| 3 14      |    7      |
|13     8   | 7    11   | 2         |      15   |
+-----------+-----------+-----------+-----------+

Since Sudoku is NP-complete, so is Pseudoku. That means that it gets more difficult to solve a Pseudoku puzzle the larger N gets. However, it can take more time to generate Pseudoku puzzles than it does to solve them, since the naive algorithm for generating a puzzle requires solving the puzzle each time a value is removed! Solving Pseudoku puzzles is fun, but if it takes longer to generate them than it does to solve them, it becomes more work than play.

So help me out! I propose a Cops and Robbers style King of the Hill. The Cops will compete by writing programs to generate lots of Pseudoku puzzles to consume as much time as possible for solving, while the Robbers will compete by writing programs to solve Pseudoku puzzles to consume as little as time possible solving these puzzles.

I need some help ironing out the format, but here is what I have so far:

  1. I will provide a Java framework for running the contest. This framework will connect to clients by TCP/IP so contestants can choose whatever language they want to write their Cops and Robbers (so long as I can run them on my system). I will also provide a basic Cop and Robber for these users to try out to see what sorts of times they take. I will publish the times they generate on my system so contestants can estimate how their entries will run on my system.

  2. I will give each Cop ten minutes to generate as many Pseudoku(N>= 3) puzzles as they can, but they should be able to generate at least Pseudoku(N=4) puzzles. They can choose what sizes they want the puzzles to be, but they have to be valid with exactly one solution. My server will naively check each one to guarantee their validity; any Cop that generates an invalid puzzle is disqualified. I recommend configuring the Cop programs to be parameterized externally so that Robbers can test their code against basic Cop configurations, but then the Cops can send me secret, optimized configurations before the contest completes for their actual execution. I will provide a couple days after the deadline ends for conferring with the Cop programmers if their settings do not work as expected on my system. Cops should generate different puzzles every time with reasonable expectations; that means no spamming with the same puzzle repeatedly or reading pregenerated puzzles from a file system, Internet source, or internal cache. In addition, I don't want to see a Cop that uses the same removal pattern for every puzzle (that may not guarantee valid puzzles, anyway).

  3. Each Robber will be tested against each puzzle generated by the Cops. The Robber will have to generate the correct solution for each puzzle as quickly as possible. I will probably need to see some timings before I make a final decision, but each Robber will be capped with some amount of time to solve a puzzle (maybe an hour?) before the time-to-completion defaults to twice that cap. These Robbers will be permitted to use any technique for solving the puzzles that my system supports except for packet sniffing. I am on the fence as to whether the Robbers will be on an honor code to not study Cop code since I plan to have secret parameterizations anyway.

  4. All the times for all the puzzles will be sorted from least to greatest and then assigned an index as one would in a Mann-Whitney U test. Each Cop and Robber will be scored using the sum of the indices of their contributions: Cops for the times the Robbers spent solving their puzzzles, and Robbers for the times they spent solving puzzles. The winning Cop will have the highest sum and the winning Robber the lowest. Cop ties will be broken first by the average time required to solve one of its problems (more is better), then by the number of puzzles generated (more is better), then by the name I deem cooler (here's hoping that doesn't happen). Robber ties will be broken first by the average time spent solving puzzles, then by the sum of the time, then by the standard deviation, then by the cooler name.

  5. This scoring scheme poses an interesting challenge to Cops: balancing the size of the problems (and the likely amount of time needed to solve them) against the number of problems generated. A Cop that generates only one puzzle that no Robber can solve in the time limit is likely to lose to another Cop that generates many moderate problems. Similarly, a Cop that spams many small problems is likely to be beaten by another Cop that generates fewer problems of larger sizes. Since the official contest configurations should be kept secret until the contest starts, other Cops can study the other programs to try to determine what their opponents are likely to do and plan accordingly.

I am interested in any and all feedback that the community might have about this challenge.

| |
\$\endgroup\$
  • \$\begingroup\$ I pronounce Pseudoku as SOO-do-ku and Sudoku as soo-DO-ku, to align with the pronunciation of Pseudo. \$\endgroup\$ – Pavel Jan 6 '17 at 0:22
  • \$\begingroup\$ I don't know if you'll get a lot of submissions. Sudoku is a bit difficult to program. Also, TCP-IP is not something people are used to using for their submissions. \$\endgroup\$ – mbomb007 Jan 6 '17 at 16:25
  • \$\begingroup\$ It is? Well, part of what I am looking for is whether people would participate. I would need at a minimum two Cops and two Robbers or there is no point. Could people comment saying whether they would play and whether they would play as a Cop, a Robber, or both? \$\endgroup\$ – sadakatsu Jan 6 '17 at 17:17
  • \$\begingroup\$ The scoring system you've chosen adds a large incentive to submit a huge number of programs that are almost identical to your own submission but slightly worse. This means that if some opposing programs generate some puzzles that are harder than yours and some puzzles that are easier (which is likely), you'll push the easy ones right down the leaderboard, making your programs look better in comparison. \$\endgroup\$ – user62131 Jan 6 '17 at 17:47
  • \$\begingroup\$ Good point. This can be resolved by a "one-submission-per-category" rule. \$\endgroup\$ – sadakatsu Jan 6 '17 at 18:07
  • \$\begingroup\$ If you want, I have some code that can help you communicate with submissions (over standard in/out). However, I think the best solution is to run the cops' submission and kill it after 10 minutes. They should write each sudoku puzzle as a file, which you would then read.. I also wouldn't worry about automated checking to see if the puzzles are valid. I generally assume good faith in these types of challenges, unless it becomes an issue. \$\endgroup\$ – Nathan Merrill Jan 6 '17 at 18:33
  • \$\begingroup\$ Re: validation... there's a problem here. For it to make any sense, I would need to have at least as good a solver as the best Robber entry, in which case someone would just copy mine in a faster language than Java. I think I would still require a unit testing protocol where I pass solutions to the Cops, the Cops return problems, and then I validate that they sent unique puzzles. \$\endgroup\$ – sadakatsu Jan 6 '17 at 18:45
  • \$\begingroup\$ Re: standard input/output versus sockets... I don't get the aversion to network programming. I used TCP in my Speed Clue contest a couple years ago, and it worked great (though I admittedly had few entries). So long as I guarantee an environment for the contest (probably Linux), even C/C++ developers can write code with platform-specific libraries if they wish. Using networking also allows a good method for timing responses: I start the clock once I get the ACK after sending a command, and I stop the clock after I ACK that I received a response. File dumping makes timing Cops difficult. \$\endgroup\$ – sadakatsu Jan 6 '17 at 18:50
  • \$\begingroup\$ 1. I don't think you've taken account of how badly things scale. It's easy to spit out valid pseudokus for N=100; validating them in a reasonable time requires supporting every rule which the cop knows. 2. The stuff about secret parameterisations doesn't really make sense to me. Taken to extremes, that could mean that we make the actual generation code the "parameterisation" and the cop "program" is just an eval. 3. The cop/robber setup means there's inherently a submission deadline. That's generally a bad thing, but even more so with something which can get extremely complicated. \$\endgroup\$ – Peter Taylor Jan 10 '17 at 15:49
2
\$\begingroup\$

broken keyboard workaround

|nspired by BASTA´s song and memories from earlier work:

Your keyboard is broken but there is some urgent work you have to complete; you have no back^up hardware - and the shops are closed so you can´t buy a new keyboard!

All you have left to work with is your mouse.

6iven two texts as input (the one you have and the one you want to have), create a program or function that tells you the cut, copy&paste actions that will turn the one text into the other.

Using the mouse is strenuous, so you don´t want too many cut/copy/paste actions. Keep your output as short as possible.

Remember: Your keyboard is broken = you can´t use any characters in your code that you don't have ~ you must get alon9 with those that are provided in th1s {["te%t"]}. For7unately your keyboard 7ook qu17e a wh1le 7o bre4k down c0mpletely 4nd y0u used numb3rs 4nd sp3c*4l ch@r$ t0 r3pl@c3 br0k3n l3773r$; $0 y0u $h0uld h@v3 m0$7 0f 7h3m @v@*l@bl3.

Also, you don´t want to do too much C&P to cre8 your code, so keep that as short as possible, too.


  • You can assume that the second text contains no characters that are not present in the first text.
  • You can pick any input format and method that is convenient for you; but the output format should match that. (e.g. if you take input from files, output should also go to a file).

NOTES

Note that the challenge description contains all letters and digits except j and z. If you absolutely need them: they are hidden in the YouTube link. (I didn´t check for upper/lower case though.)

Curlys, brackets, braces, single and double quotes and all operators I could think of are there, so the challenge should be fine for most languages that use printable ASCII.

Still trying to find a more fluent way to include curlys, brackets, double quotes and circumflex, though.

I thought there was a tag [string-manipulation]; but couldn´t find it in the list.

I think about dropping the "output method should match input method" restriction.

| |
\$\endgroup\$
  • \$\begingroup\$ Try [tag:code-golf] and [tag:restricted-source] \$\endgroup\$ – TrojanByAccident Jan 9 '17 at 16:49
  • \$\begingroup\$ The part of your question with weird characters in it is a bit hard to read. Maybe tone it down a bit. Also, some examples would be helpful for understanding the challenge. \$\endgroup\$ – mbomb007 Feb 1 '17 at 4:51
2
\$\begingroup\$

Find B1nar0 Solutions

B1nar0 puzzle is a paper and pencil game with 0 and 1. The goal is to fill the grid accoring to 3 rules :

  1. No more than 2 consecutive 0s or 1s
  2. Each row/column has half 0s and half 1s
  3. No identical row/columns

Example :

[1]

  • A is 0 according to rule 1
  • B is 1 according to rule 1
  • C is 0 according to rule 2
  • D is 1 according to rule 2
  • etc.

Edit : Grids are square grids of even size (4, 6, 8, 10, 12 or 16 are usual sizes).

Input : Any binary grid (array or string) with 0,1 and any other character you want for empty cells.

Output : Same format as input but filled with a correct grid.

Test case (see GIF)

0 11
  0 
 0  
1 1 
| |
\$\endgroup\$
  • \$\begingroup\$ Are the grid dimensions always 4x4 ? \$\endgroup\$ – Arnaud Jan 17 '17 at 8:14
  • \$\begingroup\$ Non, any even number should fit, generally 4-6-8-10-12 or 16 games. \$\endgroup\$ – Crypto Jan 17 '17 at 8:16
  • \$\begingroup\$ Nice challenge, but I suggest you add some test cases for the larger grid sizes too. Also, may we assume that we will get input that makes it possible to solve the puzzle? For instance not: [[1,1,1, ],[ , , , ],[ , , , ],[ , , , ]]. Can we assume that there will only be one valid solution? For instance, not an empty grid. \$\endgroup\$ – Stewie Griffin Mar 9 '17 at 14:22
  • \$\begingroup\$ Also, the 6x6 test case is a lot harder than the 4x4. The 4x4 can be solved going through the matrix checking the different rules one after the other. To solve the 6x6 grid you need an algorithm that's a lot more sophisticated. Do you require that the program should be able to solve any input, regardless of the difficulty. Even if it requires brute-forcing the solution (which may take a loong time for a 16x16 matrix \$\endgroup\$ – Stewie Griffin Mar 9 '17 at 14:22
  • \$\begingroup\$ Then you should add a few 10x10, 12x12 and 16x16 test cases (with solutions). Requiring that submissions can solve all possible boards regardless of difficulty makes this a really hard challenge. You should also impose a time limit. Otherwise I can just write a script that checks all possible combinations and claim that it will eventually find the right solution \$\endgroup\$ – Stewie Griffin Mar 9 '17 at 14:22
  • \$\begingroup\$ I added the comments I had on the post when it was on main. Some of them are a bit out of context now, but I guess you remember what they're about. :) \$\endgroup\$ – Stewie Griffin Mar 9 '17 at 14:23
  • \$\begingroup\$ Nice challenge, but I suggest you add some test cases for the larger grid sizes too. Also, may we assume that we will get input that makes it possible to solve the puzzle? For instance not: [[1,1,1, ],[ , , , ],[ , , , ],[ , , , ]]. Can we assume that there will only be one valid solution? For instance, not an empty grid \$\endgroup\$ – Stewie Griffin Mar 9 '17 at 14:23
1
16 17
18
19 20
100

You must log in to answer this question.

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