571
\$\begingroup\$

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

\$\endgroup\$
0

4629 Answers 4629

1
61 62
63
64 65
155
1
\$\begingroup\$

An order of primeness

Introduction

In a recent question the concepts of super-primes were explored. A super-prime is a prime whose index is also a prime.

  • 2 is not a super-prime, its index is 1
  • 3 is a super-prime, its index is 2
  • 5 is a super-prime, its index is 3
  • 7 is not a super-prime, its index is 4
  • ...

The first few of these super-primes are 3, 5, 11, 17, 31, 41, 59, ...

Let us call these primes of at least order 2, because they are more prime than regular primes (which are only of order 1).

Primes of order of 3 or greater can be defined similar. A prime is of order 3 if its index is a prime of order 2.

The first few of the primes at least of order 3 are 5, 11, 31, 41, 59, 127, 179, 277, ...

This is sequence A049076. It was defined by Neil Fernandez in 1999. More information can be found in his Exploring Primeness Project.

Task

Given a prime, return its order.
More formally

  • INPUT: A single integer which is guaranteed to be a prime
  • OUTPUT: A single integer which is the order of the input.
  • You can either return or print the result.

This is , so shortest code wins.

Testcases

           2 ->  1
           3 ->  2
           5 ->  3
           7 ->  1
       52711 ->  9
435748987787 -> 11 (happens to be the 11. Prime of order 11)

Sandbox Questions

  1. Does it need any more clarification?
  2. Should I define order 0 (not a prime) and allow any number as input, or would that over-complicate the challenge?
  3. Primes of higher order tend to get big very fast. Should I somehow specify that a language only has to work for test-cases it can actually handle or is their a consensus already?
  4. Is the introduction too big?
\$\endgroup\$
3
  • \$\begingroup\$ This is just a loop round the linked question, and as such qualifies as a duplicate for the purposes of this site. \$\endgroup\$ Jul 10, 2017 at 14:04
  • 1
    \$\begingroup\$ I think this might be an interesting question. \$\endgroup\$ Jul 10, 2017 at 22:14
  • \$\begingroup\$ Last test case -> 10 (or all the other cases ->+1) \$\endgroup\$
    – ZaMoC
    Jul 10, 2017 at 23:24
1
\$\begingroup\$

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and memory.

The input will always be two positive decimal integers in any reasonable format (string, list of digits..)

The output should be (exclusively, apart from any whitespace) the exact decimal product of these integers.

  • If integer magnitude is unbounded in your language, you must set an own limit

  • The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number

  • Note that properties like .length can exceed the integer limit. You can't e.g. ordinarily loop over the digits in a 'for' loop

  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

Sandbox

Is this different enough from this challenge?

Would this be better suited for ?

\$\endgroup\$
8
  • \$\begingroup\$ The solutions to this will be very interesting. Looking forward to it. \$\endgroup\$
    – Gryphon
    Jul 10, 2017 at 0:01
  • \$\begingroup\$ I don't quite understand your first bullet point... is it disallowing using the * operator in languages with unbounded ints? Would it disallow java's BigInteger::multiply? (Java is perhaps a special case, as int and BigInteger are separated. Furthermore, BigInteger is not a "native" implementation). If you want to disallow builtin solutions, say so... but as it stands I think that java.math.BigInteger::multiply would be a perfectly valid solution... no? \$\endgroup\$ Jul 10, 2017 at 16:18
  • \$\begingroup\$ @socraticPhoenix Good point, I've edited the post. Is it clearer now? \$\endgroup\$
    – Oki
    Jul 10, 2017 at 18:21
  • \$\begingroup\$ "Note that properties like .length are also bounded numbers, and the input can have infinitely many digits". What I'm getting is that no-one should bother attempting to answer, because properties like pointers to memory are also finite and so no program will be able to read the input. \$\endgroup\$ Jul 11, 2017 at 7:35
  • \$\begingroup\$ Note also that long multiplication has been done \$\endgroup\$ Jul 11, 2017 at 11:47
  • \$\begingroup\$ @peter You're right. I made an edit, does it make sense now? Basically it should implement multiplication to the highest magnitude possible for each language. Since memory isn't limited, pointers can always be incremented until input end. \$\endgroup\$
    – Oki
    Jul 11, 2017 at 13:39
  • \$\begingroup\$ No, it doesn't make sense now, and I don't think there's any way of writing it which would make sense. Either you have loops which don't bother with an index (i.e. most golfing languages), in which case limitations on length are both nonsensical and irrelevant; or you need to index into the data structure, in which case your index is subject to the same limitations as length and it's completely impossible. I also think that "reasonable format" directly contradicts limits on length. \$\endgroup\$ Jul 11, 2017 at 14:04
  • \$\begingroup\$ @peter The limitation is not imposed by me. If the program can multiply integers whose length (number of digits) is larger than the INT_MAX (or whatever limit is set), it goes. \$\endgroup\$
    – Oki
    Jul 11, 2017 at 15:36
1
\$\begingroup\$

Stitch the Genome

Introduction

As you probably know DNA (deoxyribonucleic acid) is made up of bases, often denoted as A T C and G. One of the coolest things we can do with DNA is sequence it, or figure out what sequence of base pairs make up the molecule. Sequencing small molecules of DNA is easy, but it is hard to sequence long strands without error. Instead, the long strands are copied many times, then cut up into many little pieces. Those pieces are then fed through the sequencer. What we end up getting are many, many sets of pieces of the strand. In each set, we are near-guaranteed to get every base in the strand, but they aren't in any order. The solution, then, is to compare all of the different sets of strand pieces we have, and try and figure out how to put them together.

Challenge

Your challenge is, given a set of strand pieces, output a possible sequence of the original strand. To simplify real life a bit, you can expect that each set will always contain the entire strand sequence (not in order, mind you), and that there will be at least one possible sequence. Observe a simple example:

Input:
 - [ATC, G]
 - [CG, AT]
Output: ATCG

From the first input, we deduce two possibilities: ATCG and GATC. From the second input, we deduce another two possibilities: CGAT and ATCG. As you can see, the only common possibility is ATCG, and thus that is our answer. Let's look at another example:

Input:
 - [AT, G, C]
 - [A, TG, C]
Output: ATGC or CATG

Here, we deduce six possibilities from the first input: ATGC, ATCG, GATC, GCAT, CATG and CGAT. Then, from the second input, we deduce another six possibilities: ATGC, ACTG, TGAC, TGCA, CTGA and CATG. Since there are two common possibilities, ATGC and CATG, we can output either one.

Essentially, this problem can be reduced to: find a common permutation of the input.

Specifics

  • You may write a program or function
  • You may input in any acceptable format (array of arrays, list of lists, separated string, etc.). Furthermore, you may substitute A T C and G in your input with any other unique values, as long as you're consistent
  • You may output in any acceptable format
  • Standard loopholes apply

Test Cases

Format:

Input:
 - Pieces 1
 - Pieces 2
 - Etc.
Possible Outputs: [Possible output 1, possible output 2, etc.]

Input: 
 - [G, A, C, C, T, A, G]
 - [GAC, C, TAG]
 - [G, AC, CT, AG]
 - [GA, CC, T, A, G]
Possible Outputs: [GACCTAG]

Input: 
 - [G, C, G, C]
 - [G, C, GC]
 - [G, CG, C]
Possible Outputs: [GCCG, CGCG, GCGC, CGGC]

Input: 
 - [TA, A]
 - [TA, A]
 - [T, AA]
Possible Outputs: [TAA]

Input: 
 - [CC, T, A]
 - [CC, T, A]
 - [C, CT, A]
Possible Outputs: [CCTA, ACCT]

Input: 
 - [GAG, C, T, C]
 - [GA, G, C, TC]
 - [GA, G, C, T, C]
 - [G, A, G, C, T, C]
 - [G, AGC, TC]
Possible Outputs: [GAGCTC, TCGAGC]

Input: 
 - [AG, A, C, A, T, G]
 - [AG, A, C, A, T, G]
 - [AGAC, A, TG]
 - [AGA, CA, T, G]
 - [A, G, AC, A, T, G]
 - [A, G, A, C, ATG]
Possible Outputs: [AGACATG]

Input: 
 - [C, A, A, C, T]
 - [CA, A, C, T]
 - [CA, A, C, T]
 - [C, A, AC, T]
 - [C, A, A, C, T]
 - [C, AA, C, T]
Possible Outputs: [CAACT, TCAAC]

Input: 
 - [CA, G, C]
 - [CAG, C]
Possible Outputs: [CAGC, CCAG]

Input: 
 - [A, GT]
 - [A, G, T]
 - [AG, T]
Possible Outputs: [AGT]

There is a set of 100 random test cases here, or you can check out the java program that generated them.

\$\endgroup\$
4
  • \$\begingroup\$ Too much intro, IMHO. \$\endgroup\$
    – Adám
    Jul 12, 2017 at 17:50
  • \$\begingroup\$ @Adám that was fast! I'll look into cutting down at that! Got to go do a thing now though, so it may be a while.... \$\endgroup\$ Jul 12, 2017 at 17:51
  • \$\begingroup\$ any other unique characters or numbers? \$\endgroup\$
    – Adám
    Jul 12, 2017 at 17:53
  • \$\begingroup\$ @Adám hmm... unique values i guess... I'll update it now \$\endgroup\$ Jul 12, 2017 at 18:31
1
\$\begingroup\$

These are two separate challenges.


Convert to mixed-radix ZYX…432.234…XYZ

Related: Convert from mixed-radix ZYX…432.234…XYZ and Convert to and from the factorial number system.

Given a non-negative real number (no greater than 1×1040 or the biggest your language can comfortably accommodate, whichever is less) convert it to mixed-radix ZYX…432.234…XYZ using the base-36 digits [0-9A-Z] or [0-9a-z] with no leading zeros (except for values smaller than 1). Any reasonable rounding is fine.

Examples

00 (0 × !1)
11 (1 × !1)
210 (1 × !2 + 0 × !1)
311 (1 × !2 + 1 × !1)
420 (2 × !2 + 0 × !1)
421300 (1 × !4 + 3 × !3 + 0 × !2 + 0 ×!1)
1004020 (4 × !4 + 0 × !3 + 2 × !2 + 0 ×!1)
123452304111
42949672958B6570020211
1000000000017A5726651220
184467440737095516157BC43F35350835000211
0.50.1
0.3333333333333333330.02
0.250.112
0.10.0022
5.12521.003
2.7182818284590452351.111111111111111111
0.0013888888888888890.00001


Convert from mixed-radix ZYX…432.234…XYZ

Related: Convert to mixed-radix ZYX…432.234…XYZ and Convert to and from the factorial number system.

Given a string (no longer than 71 characters or the maximum that gives a result your language can comfortably accommodate, whichever is less) convert it from mixed-base mixed-radix ZYX…432.234…XYZ using the base-36 digits [0-9A-Z] or [0-9a-z]. Any reasonable rounding is fine.

Examples

0 (0 × !1) → 0
1 (1 × !1) → 1
10 (1 × !2 + 0 × !1) → 2
11 (1 × !2 + 1 × !1) → 3
20 (2 × !2 + 0 × !1) → 4
1300 (1 × !4 + 3 × !3 + 0 × !2 + 0 ×!1) → 42
4020 (4 × !4 + 0 × !3 + 2 × !2 + 0 ×!1) → 100
230411112345
8B65700202114294967295
17A572665122010000000000
7BC43F3535083500021118446744073709551615
0.10.5
0.020.333333333333333333
0.1120.25
0.00220.1
21.0035.125
1.1111111111111111112.718281828459045235
0.000010.001388888888888889


\$\endgroup\$
21
  • \$\begingroup\$ I think this is ready. \$\endgroup\$
    – Adalynn
    Jul 11, 2017 at 21:56
  • \$\begingroup\$ I'd like this more with a list of digits 0-35 in the factorial base rather than including letters. \$\endgroup\$
    – xnor
    Jul 13, 2017 at 8:16
  • \$\begingroup\$ @xnor Interesting. In that case, there should be no specific upper limit, right? \$\endgroup\$
    – Adám
    Jul 13, 2017 at 8:17
  • \$\begingroup\$ @Adám That's right, unless you want a limit for the sake of languages' number bounds. \$\endgroup\$
    – xnor
    Jul 13, 2017 at 8:18
  • \$\begingroup\$ @xnor I assume that's covered by default rules. This simplifies the challenge text, so I'll make the change. Thanks \$\endgroup\$
    – Adám
    Jul 13, 2017 at 8:18
  • \$\begingroup\$ @xnor How is this? \$\endgroup\$
    – Adám
    Jul 13, 2017 at 8:24
  • \$\begingroup\$ @Adám Looks good to me. Is your plan to post a challenge for just one direction? \$\endgroup\$
    – xnor
    Jul 13, 2017 at 8:32
  • \$\begingroup\$ @xnor Uh, did you read the post? \$\endgroup\$
    – Adám
    Jul 13, 2017 at 8:33
  • \$\begingroup\$ @Adám Yes, and I'm not sure if your plan is to post two challenges, or just whichever direction is more interesting. \$\endgroup\$
    – xnor
    Jul 13, 2017 at 8:51
  • \$\begingroup\$ @xnor Two challenges. However, I just noticed that factoradic can easily represent floats too, so should I extend/modify the challenges to that? It would certainly make them different from the existing one. \$\endgroup\$
    – Adám
    Jul 13, 2017 at 8:53
  • \$\begingroup\$ Yes, you should do that so built-ins won't be useful (cough Jelly cough) in addition to distinguishing this from the existing challenge. \$\endgroup\$
    – Adalynn
    Jul 13, 2017 at 19:57
  • 1
    \$\begingroup\$ The original challenge with letters was way better... \$\endgroup\$
    – ZaMoC
    Jul 14, 2017 at 6:25
  • \$\begingroup\$ I actually agree with @Jenny_mathy because languages like Jelly naturally output different bases in a list format, rather than a string of letters. \$\endgroup\$
    – Adalynn
    Jul 14, 2017 at 13:17
  • \$\begingroup\$ @Jenny_mathy Like this? \$\endgroup\$
    – Adám
    Jul 14, 2017 at 14:22
  • \$\begingroup\$ @Zacharý Ping ^ \$\endgroup\$
    – Adám
    Jul 14, 2017 at 14:22
1
\$\begingroup\$

Minimize my cube

Introduction

Using my 6x6 as cubes of smaller size

I have a rubiks cube. It has 6 layers and is great fun to solve. But it takes quite some time, and sometimes I wish I could just solve a cube of smaller size. But theres hope, because every cube with even number of layers can emulate every cube with less layers by only moving certain layers at the same time. Now I need your help to provide the numbers.

Let's get mathematical

Consider this definiton: For every even integer n and a positive integer i <= n there exists a sequence of i positive integers, so that

x_1 + x_2 + ... + x_i = n
x_1 = x_i
x_2 = x_(i-1)
x_3 = x_(i-2)
...

(See test cases for a clearer example). Then such a sequence tells me exactly which layers to combine.

The challenge

For an input n write a program that outputs one of the existing sequences for every positive integer i < n.

Test cases

For n = 6:

[6]
[3, 3]
[2, 2, 2]
[1, 2, 2, 1]
[1, 1, 2, 1, 1]
[1, 1, 1, 1, 1, 1]

For n = 4:

[4]
[2, 2]
[1, 2, 1]
[1, 1, 1, 1]

Scoring and Rules

Lowest number of bytes wins. Standard Loopholes apply.

Sandbox quesions

  • Formatting?
  • Can I make the definition clearer?
  • Should I put more restrictions?
  • Where is my english broken beyond repair?
\$\endgroup\$
5
  • \$\begingroup\$ Tell me if I'm understanding it wrong, but could we output, for the fourth line when n=6 : [2, 1, 1, 2]? or even [2, 1, 2, 1]? or even any permutation of [1, 1, 2, 2]? \$\endgroup\$ Jul 19, 2017 at 16:39
  • \$\begingroup\$ Another thing (that's why separate comment) : you don't explicitly require an input format. So here, could I for example output a string containing : 4\n22\n121\n1111\n (with \n=newline)? Am I allowed to have this trailing newline? Are the commas mandatory? etc. \$\endgroup\$ Jul 19, 2017 at 16:42
  • \$\begingroup\$ About my first comment : if you want, you can even ask for outputting every or any permutation, or a symmetric permutation, or an increasing-ordered one. \$\endgroup\$ Jul 19, 2017 at 16:46
  • \$\begingroup\$ @V.Courtois: I meant it to be symmetric, like [2,1,1,2] and [1, 2, 2, 1] are both symmetric, but [2, 1, 2, 1] is not. Alas, need to better the explanation, I guess. \$\endgroup\$
    – Seims
    Jul 20, 2017 at 5:49
  • \$\begingroup\$ you do need, it's a fact :) And what about saying what output format you want (sorry for the input mistake in 2nd comment) ? \$\endgroup\$ Jul 20, 2017 at 6:40
1
\$\begingroup\$

KOTH: Thirty-One

Challenge

Built a bot that plays Thirty-One against other bots!

Game Rules

Thirty-one is a card game using the standard 52-card deck (the French deck). The objective in each round is to have a hand better than at least one of your opponents'.

At the beginning of the game, each player has a set number of "lives" - for this challenge, each player will get 3 lives. Once you run out of lives, you have lost the game. No matter how many players there are, there is exactly one winner per game.

The player to go first in the first round is chosen arbitrarily. After that, the player to go first rotates clockwise around the "table". The players' order does not change between rounds (except for when players get knocked out).

At the beginning of each round, each player is dealt 3 cards. On each player's turn, they have the option to:

  1. Draw a card from the deck and discard a card
  2. Draw the last card that was discarded and discard a card
  3. Knock if no other player has knocked yet

Knocking

If a player knocks, each other player gets one more turn. Then, the players compare hands. Whoever has the lowest score loses a life, and the round ends.

Scoring

Each player's score is calculated by adding the face values of all their same-suit cards and taking the best score. Two cards of different suits don't contribute to the same score.

The face values for each card are:

Ace: 11
King, Queen, Jack: 10
2-10: their value

For example, consider you hold the cards:

Ace of Spades
Four of Spades
Two of Spades

Your score would be 11 + 4 + 2 = 17.

If you hold the cards:

Queen of Diamonds
Four of Clubs
Nine of Clubs

Your possible scores are 10 and 4 + 9 = 13, so your score is 13, the best of the two.

Finally, if you have:

Six of Hearts
Six of Spades
Three of Diamonds

Your possible scores are 6, 6, and 3, so your score is 6, the best of the three.

The highest possible score you can reach is 31, by holding the Ace and two 10-point cards of the same suit.

Special Cases

  • If the player who would go first knocks immediately on their first turn, the other players don't get a turn - they compare hands right away

  • If a player reaches a score of 31, they should knock immediately and everyone else loses a life

  • If the deck runs out of cards, the round ends and all players compare hands

Input/Output

Your bot will be a subclass of the base class I provide. You need not implement every method, but there will be a minimal amount of functionality required in order to make the turns go forward.

Scoring

I will create a tournament-style bracket that will determine the winning bot. Your bot is allowed keep track of all the information available to it, including between games. The details of the bracket will depend on the number of bots written.


Meta

  • I could use some input on writing the controller and base class. What has worked well in the past? What hasn't worked that I should avoid?

  • Are the rules for the game clear enough? I adapted them from my own knowledge of the game and this website.

  • Obviously this isn't ready for posting yet since I haven't written the base class, but is there anything else unclear or missing?

  • Is there anything I can do to make this more fun or more challenging?

\$\endgroup\$
6
  • \$\begingroup\$ 1. The key thing for the controller is to maintain a persistent connection, because if you have to keep forking processes that becomes a bottleneck. 2. There are a couple of minor points to clarify. "Whoever has the lowest score loses a life": presumably in case of ties everyone with the lowest score loses one. "standard 52-card deck": the French deck, to distinguish it from other standards. Although on the basis of KISS I'd use a deck of four suits and card values 0 to 9 (with three 8s per suit). \$\endgroup\$ Jul 18, 2017 at 13:51
  • \$\begingroup\$ "Draw a card from the deck and discard a card" is presumably followed by shuffling all but the discarded card if the draw deck runs out. "I will run 100 games using everyone's bots" will break badly if there are 17 bots. \$\endgroup\$ Jul 18, 2017 at 13:52
  • \$\begingroup\$ @PeterTaylor Thank you so much for the feedback! 1. Thank you for the advice, I didn't plan on making the program multi-processed, I planned on having the controller simply keep a list of the bots and passing control to each one in turn. 2. Yes the tying rule is correct, I'll add that in. Although that would be a good way to simplify the deck I think I'll keep it 2-11 with four 10s per suit, because I don't want to change the name of the game. 3. Yes, all but the top card would be shuffled back in, I'll add that as well. 4. Why would that break badly? Just because of computation time? \$\endgroup\$ Jul 18, 2017 at 14:05
  • \$\begingroup\$ 3 cards each times 17 players leaves 1 card in the deck. \$\endgroup\$ Jul 18, 2017 at 14:09
  • \$\begingroup\$ Ah, good point...if there are that many participants, I'll have to break it into multiple smaller games and set up a tournament bracket \$\endgroup\$ Jul 18, 2017 at 14:17
  • \$\begingroup\$ I've changed my mind on one thing - the round ends when the deck runs out of cards. Each game will consist of 4 players, and I'll release more information about the gameplay once I see how many bots are written \$\endgroup\$ Jul 18, 2017 at 17:46
1
\$\begingroup\$

KotH: Atom Bomb Chess

(Draft. I'll flesh it out some more later. It will probably be implemented in JavaScript or maybe C++.)

Atom Bomb Chess is a variant of chess played much the same as regular chess. The only differences are:

  1. The game ends when one or both players have no pieces, or if 50 moves have been made without a piece being captured.
  2. When a piece is captured, all pieces a king's move away are also "captured", and the piece doing the capturing is also "captured".

For example, let's look at a 4x4:

pbbr
....
....
RBBP

Where r/R is a rook, b/B is a bishop, and p/P is a pawn. Suppose R moves forward 3 spaces. Then, it captures the p and "explodes":

..br
....
....
.BBP

The idea of this KotH is to make a program that plays Atom Bomb Chess. I will have a few programs to test your submissions against.

\$\endgroup\$
7
  • \$\begingroup\$ This is a really cool idea! Obviously you'll need to flesh out the rules a bit more, but this is a great start. I would also suggest fixing the board size (you seem to suggest it can be played on any size board, but I think it would be easiest to set it as a constant ahead of time). \$\endgroup\$ Jul 23, 2017 at 22:31
  • \$\begingroup\$ @musicman523 Yeah, it'd probably be played on an 8x8 \$\endgroup\$ Jul 23, 2017 at 22:35
  • 1
    \$\begingroup\$ you forgot that pawns are partially nuke proof \$\endgroup\$ Jul 23, 2017 at 23:15
  • \$\begingroup\$ @DestructibleLemon Please elaborate ? I wasn't aware there was some standard rulebook. \$\endgroup\$ Jul 24, 2017 at 1:45
  • 2
    \$\begingroup\$ I'm not entirely sure where it is, but I remember that pawns, while still being eliminated if they are capturing, or are captured, will not get removed if they are adjacent to a capture. maybe use lichess? \$\endgroup\$ Jul 24, 2017 at 2:51
  • \$\begingroup\$ @DestructibleLemon I remember playing it when I was younger with no such restriction, perhaps there are multiple variants. Why suggest lichess? Does it have that mode? \$\endgroup\$ Jul 24, 2017 at 18:02
  • \$\begingroup\$ Apart from pawns being nuke proof, the game ends as soon as you nuke the enemy king, if you play on lichess. There are videos on YouTube which include an explanation of the rules and basic "opening theory". \$\endgroup\$
    – Sleafar
    Jul 28, 2017 at 18:17
1
\$\begingroup\$

How good is my mahjong hand?

Your goal is to calculate the shanten (minimal number of tiles needed for your hand to be a "waiting hand") of a Riichi mahjong hand.

What is Japanese Mahjong (or Riichi)

The goal of the game is to build a 14 tiles valid hand. Your hand is 13 tiles long, and each turn, you draw a 14th. If it doesn't make you win, you discard a tile. The tiles are grouped by colors : man, numbers, let's call them m; pin, circles, p; sou, bamboos, s; and honor tiles, z.

For p,m, and s : tiles are numbered from 1 to 9, with 4 examples each (1m 1m 1m 1m 2m 2m 2m 2m 3m 3m 3m 3m... 9m 9m 9m 9m).
z contains winds : ton for east, e; nan for south, s; sha or xia for west, w; and pei for north, n.
z contains dragons too : chun for red, r; haku for white, h; and hatsu for green, g.
Same rule, 4 examples each.
Honor tiles cannot be sequenced in a chii, they can only combine with themselves, by matching for a pair or for a pon. Don't worry, I will define terms pon and chii in the next part.

So a random hand can look like 1s 1s 1s 2s 2s 2s 3s 9p 9p 4m ez ez nz.

What is a "waiting hand"

What is called a tenpai hand, or hand that is one tile left before winning, is a hand respecting a winning shape. In general, a winning hand is composed of 4 sets of 3 sequenced (chii, like 1s 2s 3s) or matching (pon, like 1s 1s 1s) tiles, plus a pair (like 1p 1p). An example of a winning hand (14 tiles) can be : 1s 2s 3s 4s 5s 6s 6s 7s 8s 3p 3p 3p ez ez
So a "waiting hand" can be : 1s 2s 3s 4s 5s 6s 6s 7s 8s 3p 3p 3p ez where you need only ezto win.

The goal

To output a positive integer (between 0 and 7, inclusive) representing the shanten as defined above. For instance, a hand like 1s 1s 1s 2s 2s 2s 3s 9p 9p 4m ez ez nz is 2 shanten, because :
- you have a set of three 1s (a pon)
- you have a pon of 2s
- you have a pair of 9p (your pair)
- you have another pair of ez (that needs a third one to become a pon)
- you have 3 "isolated" tiles, 3s,4m,nz.

So drawing ez, and creating the pon of ez, makes you discard nz for example. Then let's imagine you draw 2s : you discard 4m, and you are now with a "waiting hand", with :
1s 1s 1s 2s 2s 2s 2s 3s 9p 9p ez ez ez, waiting on 1s or 4s. You drew two "useful tiles" to come to this hand, so you were 2 shanten.

@Sandbox : Is it on-purpose to put two detailed examples? (pro : clarifies what you have to do / con : challenge's wall of text is even bigger)

Another example

Let's see your hand looks like 4p 5p 7p 1m 1m 1m 2s 4s 6s ez sz hz hz.
- you have a pon of 1m
- you have 4p and 5p sequenced, requiring 3p or 6p to be a chii
- you have 2s 4s 6s, requiring 3s or 5s to create a chii
- you have a pair of hz
- you have 3 "isolated" tiles, 7p, ez and sz.

So, as for the first example, we have 3 isolated tiles. But are we 2 shanten? No, because 2s 4s 6s is not complete. So in fact, we have 4 useless tiles, the 4th being 2s or 6s depending on what we draw.
Proof : if we draw 3p, 3s and hz, our hand looks like that :
3p 4p 5p 1m 1m 1m 2s 3s 4s sz hz hz hz
and is waiting on the second sz to form the pair and win. We drew 3 useful tiles, so we were 3 shanten.

Test cases

3m 6m 9m 3p 5p 8p 1s 5s 8s ez sz nz gz -> 7 shanten
3m 6m 9m 3p 4p 5p 8p 1s 5s 8s ez sz nz -> 6 shanten
3m 6m 9m 3p 4p 5p 8p 1s 5s 8s ez nz nz -> 5 shanten
3m 6m 9m 3p 4p 5p 8p 8p 5s 8s ez nz nz -> 4 shanten
3m 5m 6m 9m 3p 4p 5p 8p 8p 5s 8s nz nz -> 4 shanten
3m 4m 5m 6m 3p 4p 5p 8p 8p 5s 8s nz nz -> 3 shanten
3m 4m 5m 6m 3p 4p 5p 8p 8p 5s 5s nz nz -> 2 shanten
3m 4m 5m 6m 7m 3p 4p 5p 8p 5s 5s nz nz -> 1 shanten
3m 4m 5m 6m 7m 3p 4p 5p 5s 5s nz nz nz -> 0 shanten
6s 7s 8s 1p 1p 1p 3p 4p 5p 6p 7p 7p 7p -> 0 shanten
3s 4s 5s 6s 7s 2p 4p 6p ez nz nz hz gz -> 3 shanten
3s 4s 5s 6s 7s 7s 1p 2p 4p 6p nz nz hz -> 2 shanten
3s 3s 4s 5s 6s 7s 7s 2p 4p sz sz nz nz -> 2 shanten
3s 3s 4s 5s 5s 6s 7s 7s 4p nz nz sz sz -> 2 shanten
3s 3s 3s 4s 5s 5s 7s 8s 2p 3p 4p 6p 6p -> 1 shanten
1m 1m 1m 2s 7s 7s 1p 3p 4p 9p sz hz cz -> 4 shanten
3m 6m 9m 3p 8p 1s 5s 8s ez sz nz gz cz -> 8 shanten

Protip

Calculating shanten can be complex, so here is a link that can help you doing so. You can refer to this site if you need any other information on riichi mahjong. Good luck!

Scoring and extra rules

This is code-golf, so shortest answer in bytes wins for its language. Standard loopholes apply.

NB : If you know mahjong, or were curious and dug deeper into the rules, don't mind with specific shapes like seven pairs or thirteen orphans.

tags :
@Sandbox : should I create some sort of in a pastebin or something?
Related
Related too
Something that can help if you speak japanese <- you can copypaste in the field the output from this program :)
Another protip

SANDBOX

Feel free to comment and tell me if this is on-purpose in PPCG, if there is any way to improve the way I say things, if I'm unclear anywhere ...

\$\endgroup\$
8
  • \$\begingroup\$ If you downvote, please explain why (by commenting or suggesting edit) so I can improve. If you don't, then don't downvote, this makes just the post less visible for no reason. \$\endgroup\$ Jul 24, 2017 at 6:17
  • \$\begingroup\$ Didn't downvote this, nor have I read through it yet. But that may be the reason it just appears to be a wall of text. Maybe try splitting it up into multiple posts or breaking the text down into easier read chunks. Or even take bits out that might not be needed. \$\endgroup\$ Jul 24, 2017 at 8:28
  • \$\begingroup\$ @TheLethalCoder in fact I'd like to explain clearly what is mahjong (to put some context in the challenge). Though you're right, it is a wall of text, that's what it looks like to me too. And I can't really "split it" into multiple posts, because it is what the challenge will look like in the end. TL;DR I want to be as clear as possible since this challenge is gonna be hard. \$\endgroup\$ Jul 24, 2017 at 8:32
  • 1
    \$\begingroup\$ I think you should be able to make it clearer by tidying the post up and formatting it more. The problem is a lot of people will open the question see all the text and move on without giving it a chance \$\endgroup\$ Jul 24, 2017 at 8:45
  • \$\begingroup\$ @TheLethalCoder I do know about this. How do you think I can make it tidier without removing content? \$\endgroup\$ Jul 24, 2017 at 8:46
  • \$\begingroup\$ To be honest I have no clue, if I knew more on the subject I'd be able to help more \$\endgroup\$ Jul 24, 2017 at 8:49
  • \$\begingroup\$ @TheLethalCoder mmh okay. Japanese mahjong is a well documented topic (I already linked some docs in the post). So maybe I shouldn't define the rules myself and let a link do the job? \$\endgroup\$ Jul 24, 2017 at 8:52
  • 1
    \$\begingroup\$ Well you'd want the important information in the post so it is self contained. Maybe the "fluff" can be trimmed down. \$\endgroup\$ Jul 24, 2017 at 8:53
1
\$\begingroup\$

Who Won the Chess Game?

Bear with me, this is incredibly bare-bones at the moment; I'll work on this over-time, just wanted to gauge interest on the over-all idea.


Given an input list of moves l, output who won the chess game given that white always goes first, alternating moves from there. Using the following convention for naming the chess squares:

enter image description here

Where the pieces are:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

The first assumption you will make is that the list of moves passed is a VALID chess game, to completion. The following would be an example input:

[[A2,A4],[A7,A6],...]

The first two moves given would result in:

rnbqkbnr
pppppppp
........
........
P.......
........
.PPPPPPP
RNBQKBNR

Which is white's first move, followed by black's move:

rnbqkbnr
.ppppppp
p.......
........
P.......
........
.PPPPPPP
RNBQKBNR

Then, you would continue parsing moves until a king disappears. Whichever king is left should be declared the winner.


Waiting to Gauge Interest Before Wasting Time on Full Testcase

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

Nested list unpacking

In Python 3.5+, the * operator can unpack a list within a list.

[1,*[2,3,4],5] == [1,2,3,4,5]

The unpacked elements are placed directly into the outer list without increasing the list depth. Note that this is different from the nested three-element list

[1,[2,3,4],5]

Your goal is to simplify a nested list expression by resolving all instances of unpacking. So, the output will simply be a nested list without any *.

Specifically, the input will be an expression that consists of

  • A non-empty list of expressions [..]
  • An non-empty unpacked list of expressions *[..].
  • A digit 1 through 9

The outermost layer will always be a non-empty list. The output is such an expression without any unpacking.

Input: A string of characters [],*123456789

Output: Its unpacked analogue. This can be a string or list structure.

This challenge can be done in any language. Python and other languages with the same unpacking format may not use eval or exec or equivalents.

TODO: I/O details, test cases

\$\endgroup\$
1
  • \$\begingroup\$ This is similar to least Levenshtein distance to a balanced list (replace *[ with { and then remove unbalanced ]). \$\endgroup\$ Jul 25, 2017 at 7:20
1
\$\begingroup\$

Title: Visualizing Euclid's Algorithm

Problem

We wish to visualize Euclid's algorithm for computing the greatest common divisor of two numbers as a 2-dimensional tiling, such as this one:

euclid

This interactive version may also be helpful in understanding the visualization.

Input

Two positive integers a and b, where a > b. You may take them in any order and in any convenient form: a list, two function args, etc.

Output

An ascii version of the above visualization shown above. This is best illustrated with a few examples:

input = 20, 8

.....................
.       .       .   .
.       .       .   .
.       .       .   .
.       .       .....
.       .       .   .
.       .       .   .
.       .       .   .
.....................

8 goes into 20 2 times, so we have two 8x8 squares, and remainder of 4 (20 - 8*2 = 4). 4 goes into 8 2 times with no remainder, so the remaining rectangle is broken into to 2 4x4 squares and we're done.

input = 5, 3

......
.  ...
.  . .
......

Note: There is an implied connection between any two adjacent dots, so that the above ascii should be interpreted as follows:

connected nodes

input = 7, 3

........
.  .  ..
.  .  ..
........

flexibility

You may choose whichever border characters are prettiest to you, or use combinations of different characters.

.....................   *********************   +-------+-------+---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .....   *       *       *****   |       |       +---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.....................   *********************   +-------+-------+---+

Rotations are also allowed: Any of the above may be rotated 90, -90, or 180 degrees.

Rules

This is , standard loophole rules, etc.

\$\endgroup\$
3
  • \$\begingroup\$ Nice challenge! But I would add a test cases like 8,5 and 21,13 where the recursion goes a bit deeper. \$\endgroup\$ Jul 26, 2017 at 8:16
  • \$\begingroup\$ @BruceForte thanks. unfortunately since posting it I found this, which I fear is too similar: codegolf.stackexchange.com/questions/119714/… \$\endgroup\$
    – Jonah
    Jul 26, 2017 at 17:06
  • \$\begingroup\$ Yeah you're right, didn't know these existed. \$\endgroup\$ Jul 26, 2017 at 17:11
1
\$\begingroup\$

NB: work in progress

Convert MADBACE to DECIMAL

MADBACE is a mixed Roman-hexdecimal system. Hexadecimal digits (0-F) take their normal positional values, while Roman numerals (IVXLCDM) have their normal values (1 5 10 50 100 500 1000). The main parts of the challenge is to determine when to subtract and when C and D are Roman versus hexadecimal.

Rules

  1. C and D will be Roman if possible.

  2. There can never be more than one subtractive symbol to the left of any symbol.

  3. A subtractive symbol must be less than half the symbol it subtracts from

Examples

CM900

MC1100

MD1500

DM792 1000-13×161

LD450

CD400

XD40

ID49 13×160-1

3C52 100-3×161

4C76 4×161+12×160

MADBACE701590 (10×165-1000)+(11×163-500)+10×162+100+14×160

DECIMAL233571513 13×166+14×165+12×164+(1000-1)+10×161+50

\$\endgroup\$
3
  • \$\begingroup\$ Maybe make explicit mention that a smaller symbol to the left of a larger symbol is always subtracted if both are Roman. And if one is Roman? What if neither are? Actually if neither are then the position based value ensures the symbol to the left is always larger. \$\endgroup\$ Jul 25, 2017 at 23:01
  • \$\begingroup\$ If only a single symbol can be to the left for subtraction, how are ambiguous cases like IXL resolved? \$\endgroup\$ Jul 25, 2017 at 23:02
  • \$\begingroup\$ Are all possible inputs from the symbol alphabet to be dealt with, or just some subset? I mean, does the spec resolve all ambiguities or will the challenge specify "only valid inputs will be used"? \$\endgroup\$ Jul 25, 2017 at 23:03
1
\$\begingroup\$

Calculate the maximum possible number of "living" cells on a given grid size for Conway's Game Of Life.

Conway's Game Of Life

Game Rules:

  1. Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
  2. Any live cell with two or three live neighbours lives on to the next generation.
  3. Any live cell with more than three live neighbours dies, as if by overpopulation.
  4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Challenge: For a given grid size (ex 5x5) is it possible to calculate the maximum potential living cells after at least 5 generations with any given starting pattern?

 O O X O O
 O O X O O
 X X X X X
 O O X O O
 O O X O O

In the above example, there are 16 living cells. I am not proposing that this is the maximum, just providing a starting point.

The reason for the 5th generation requirement is because the first generation could technically be 25 (100%) I suppose.

\$\endgroup\$
1
  • 3
    \$\begingroup\$ To me, this is a very interesting challenge because brute-forcing it would be difficult (5x5 board has 2^25=32 million possibilities for starting). That being said, this should be marked as code-golf or fastest-code as a winning criterion (read the code-challenge description). Also, the rules should specify that all eight surrounding cell are included in the count. Is the board toroidal (i.e. edge wrapping) or flat? Are there any limits on the grid size? Importantly, this needs test cases to be a good challenge. If a 5x5 example is too big, do a 3x3 example. \$\endgroup\$ Jul 26, 2017 at 18:37
1
\$\begingroup\$

Can you compete with a supercomputer?

The challenge is to write super fast code for computing the permanent of a matrix of complex numbers.

In a paper from 2016 a team of coders managed to compute the permanent of a 40 by 40 complex matrix on 8192 nodes of what was at the time the world's fastest computer in about 14 seconds. Your challenge is to see how close you can get to this on my desktop.

The permanent of an n-by-n matrix A = (ai,j) is defined as

enter image description here

Here S_n represents the set of all permutations of [1, n].

As an example (from the wiki):

enter image description here

In this question matrices are all square.

Examples (these need updating to have complex entries)

Input:

[[ 1 -1 -1  1]
 [-1 -1 -1  1]
 [-1  1 -1  1]
 [ 1 -1 -1  1]]

Permanent:

-4

Input:

[[-1 -1 -1 -1]
 [-1  1 -1 -1]
 [ 1 -1 -1 -1]
 [ 1 -1  1 -1]]

Permanent:

0

Input:

[[ 1 -1  1 -1 -1 -1 -1 -1]
 [-1 -1  1  1 -1  1  1 -1]
 [ 1 -1 -1 -1 -1  1  1  1]
 [-1 -1 -1  1 -1  1  1  1]
 [ 1 -1 -1  1  1  1  1 -1]
 [-1  1 -1  1 -1  1  1 -1]
 [ 1 -1  1 -1  1 -1  1 -1]
 [-1 -1  1 -1  1  1  1  1]]

Permanent:

192

Input:

[[1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1],
 [1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1],
 [-1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1],
 [-1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1],
 [-1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1],
 [1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1],
 [1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1],
 [1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
 [1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1],
 [-1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1],
 [-1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1],
 [1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
 [-1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1],
 [1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1],
 [1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
 [1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1],
 [-1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1],
 [1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1],
 [1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1],
 [-1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1]]

Permanent:

1021509632

Add the 40 by 40 matrix here

The task

You should write code that, given an n by n complex matrix, outputs its permanent.

To make testing simpler, I will provide a single 40 by 40 complex matrix which you can hardcode into your code in any format of your choosing. Clearly, you are not allowed to precompute the answer however!

Scores and ties

I will test your code on the sample 40 by 40 complex matrix. Your score is your time in seconds divided by 14.

If two people are within 1 second of each other then the winner is the one posted first.

Languages and libraries

You can use any available language and libraries you like but no pre-existing function to compute the permanent. I will run your code under OS X so please give full instructions for how to compile and run it.

Reference implementations

There is already a codegolf question question with lots of code in different languages for computing the permanent for small matrices. There was also a related challenge on computing the permanent of matrices with only +-1 entries. The coding issues when you have complex entries and want things to run fast and multi-core are quite different however.

My Machine

The timings will be run on my Mac desktop. The CPU is Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz.

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Remember #asdfjkl; and ##asdfjkl;, not **asdfjkl;**, for headings. \$\endgroup\$
    – wizzwizz4
    Jul 28, 2017 at 19:07
  • \$\begingroup\$ Why divide the score by 14? I know it ties in with the story, but surely it primarily adds to confusion. Also, will all the input matrices only contain +/-1? \$\endgroup\$ Jul 28, 2017 at 19:34
  • \$\begingroup\$ @FryAmTheEggman No the matrices will have complex entries. I need to change the examples. Dividing by 14 was just for fun to compare with the supercomputer. I can remove that if you think it's better. \$\endgroup\$
    – user9206
    Jul 28, 2017 at 19:35
1
\$\begingroup\$

Survival Island

Work in Progress, mainly trying to get the idea out and see if anyone is interested. Also make sure it hasn't been done already. Ideas taken from The Hunger Game and Player Unknown Battleground

The Board

The game will be played on a square 2-dimensional array with the size of x + ny where n is the number of players, and x and y are to be determined. No wrap

Objects

All objects can be destroyed while on the map, hence their hp. Once they are picked up, they cannot be destroyed unless the player dies.

1.Wall: Denoted by the character 'W'

HP: 10
Object Type: Wall

2.Reinforced Wall: Denoted by the character 'R'. When a wall is upgraded to reinforced wall by the player, 10 hp is added to the remaining hp on the wall.

HP: 20
Object Type: Wall

3.Crossbow: Denoted by the character 'C'. Allow the player to have ranged attack with a distance of 2. The damage dealt will be the player's damage minus 1.

HP: 1
Weight: 1
Upgrade #1: damage + 1
Upgrade #2: attacking distance + 1, damage + 1
Object Type: Item(Equipment)

4.Dagger: Denoted by the character 'D'. If the player is attacking with a distance of 1, it does 1 extra damage.

HP: 1
Weight: 1
Upgrade #1: damage + 1
Upgrade #2: damage + 2
Object Type: Item(Equipment)

5.Binocular: Denoted by the character 'B'. Increase the player's line of sight by 1.

HP: 1
Weight: 1
Upgrade #1: line of sight + 1
Upgrade #2: line of sight + 1
Object Type: Item(Equipment)

6.Shield: Denoted by the character 'S'. Increases the player's block by 1

HP: 2
Weight: 1
Upgrade #1: nothing
Upgrade #2: block + 1
Object Type: Item(Equipment)

7.Armor: Denoted by the character 'A'. negates 1 damage from any incoming damage to the player.

HP: 2
Weight: 2
Upgrade #1: nothing
Upgrade #2: incoming damage - 1
Object Type: Item(Equipment)

8.MedicKit: Denoted by the character 'M'. When used, heal the player's health by 5.

HP: 1
Weight: 0.5
Upgrade #1: hp restored + 3
Upgrade #2: hp restored + 5
Object Type: Item(Consumable)

9.EnergyDrink: Denoted by the character 'E'. When used, increase STR, AGI, and VIT by 1 for 5 turns. (If the player has already drank an energy drink, it will override previous effect).

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 3 turns
Upgrade #2: all attribute + 1
Object Type: Item(Consumable)

10.PoisonedEnergyDrink: Denoted by the character 'E'. When used, decrease STR, AGI, and VIT by 1 for 3 turns.

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 2 turns
Upgrade #2: all attribute - 1
Object Type: Item(Consumable)

11.UpgradeKit: Denoted by the character "U". Used to upgrades other items. All item can be upgraded twice. 1 upgrade kit is used to upgrade an item once.

HP: 1
Weight: 1
Upgrade #1: nothing
Upgrade #2: nothing
Object Type: Item(Special)

12.Player - Denoted by the character 'P'. This is the actual player on the board. See next section for more details.

HP: determined by the player
Object Type: Player

E.g. In the following map, the player have a line of sight of 1.

-------------
|   | A |   | 
-------------
| R | P |   |
-------------
|   |   |   |
-------------

In particular. There's a reinforced wall on the left, and a piece of armor on the top. the player is at the center. This can be represented as [{0,1,A},{1,0,R},{1,1,P}]

The player

Each player have the following 3 attributes:

  • STR: affects damage and carrying capacity of the player. +1 damage for each 2 STR and +1 capacity for each 1 STR

  • AGI: affects player's movement range and line of sight. +1 movement for each 5 AGI, and +1 line of sight for each 3 AGI

  • VIT: affects player's health and block. +3 health for each 1 VIT, and +1 block for each 3 VIT

You are free to assign 0 to 10 attribute points to the above 3 attributes when creating your character. Any character with more than 10 attributes assigned at the start of the game is disqualified.

Each player will start off with the following stats (without attribute bonus):

  • health: 20
  • damage: 1
  • carrying capacity: 3
  • movement: 1
  • line of sight : 2
  • block: 0

Game play

Each turn, the player will perform a move and an action.

Movement phase

Movement can either be '^' for up, 'v' for down, '<' for left, '>' right or '.' for stay.

If you can move 2 or more tiles, you can provide all movements in the order you want them to executed (e.g. "^>" will move up then right, and ">^" will move right then up).

If the first movement fails(due to object being there), the subsequent movements are dropped.

The movement phase is performed by every player performing their first movement, then every player performing their second movement if available, etc.

If 2 or more players attempt to move to the same square, then the player with the highest agility wins. If they have the same agility, then it's determined by a dice roll.

Action phase

Each player can perform the following actions during the action phase

  1. Attack : Denoted by "A ". Performs an attack to the coordinate x,y If the coordinate is out of reach, then do nothing. x and y should be relevant to the player, e.g. 0,-1 is attacking down adjacent to the player.

  2. Block: Denote by "B". Performs an block on each incoming attacks with the chance of block/10. If the block succeeds, negate all damage from that attack.

  3. Pickup : Denoted by "P ". Tries to pick up an object at that direction adjacent to the player. If the tile is empty, or if picking up the item exceeds your carrying capacity, then do nothing.

  4. Drop : Denoted by "D ". Tries to drop an item at that direction adjacent to the player. If the tile is already occupied, or the item does not exist. then do nothing.

  5. Build Wall : Denoted by "W ". Tries to build a wall at that direction adjacent to the player. If the tile is already occupied, then do nothing.

  6. Reinforce wall : Denoted by "R ". Tries to upgrade a wall at that direction adjacent to the player. If the tile is not a wall or player do not have UpgradeKit, then do nothing.

  7. Consume : Denoted by "C ". Consumes an item in your inventory. If the item does not exist, then do nothing.

  8. Upgrade : Denoted by "U ". Upgrades an item in your inventory. If the item does not exist, or if you have no UpgradeKit, or if the item already maxed out upgrades. Then do nothing

  9. Equip : Denoted by "E ". Equips an item. If the item does not exist, then it does nothing, If you have already equipped an item. then put that item in the inventory.

  10. Sleep: Denoted by "S". Increase health by 3. increases all incoming damage by 1. increase movement, damage, and block next turn by 1. Last one turn.

  11. Gaze into the sky: Denoted by "G". Looks up into the sky and ponder about life (Do nothing).

If 2 players try to perform an action at the same tile, It is first determined by the order of actions. If the players uses the same action, then the highest agility player wins. if they have the same agility, then it's determined by a dice roll who should succeed.

Order of actions that is Sleep > Block > Consume > Equip > Upgrade > Gaze > Reinforce Wall > Pickup > Drop > Build Wall > Attack

example: Given an empty tile x. if player a performs pickup at tile x, player b performs drop on tile x, player c performs build on tile x, and player d performs attack on tile x. Then player a does nothing, player b drops an item on tile x. player c does nothing, and player d attacks that item

Input/Output

Each round, the following is output to each player for movement and again for action: round #, phase, player inventory, player equipment, player buffs, player capacity, attack, block, movement, los, player hp, player line of sight, possibly more?

e.g. 14,M,AEEMM,B,P2E3,6,5,1,1,3,19,[{0,1,A},{1,0,R},{1,1,P}]

indicates:

  • round 14
  • currently it's movement phase.
  • player is carrying Armor, 2 * Poisoned? Energy Drink, 2 * Medic Kit
  • player is equipping Binocular
  • player current have a buff of poisoned energy drink with 2 turns remaining, and energy drink with 3 turns remaining
  • player has a maximum of 6 carrying capacity
  • player has an attack of 5
  • player has a block of 1
  • player has a movement of 1
  • player has a line of sight of 3
  • player has a hp of 19
  • player sees the map as shown before

Each round, 2 inputs will be read from the players

Movement phase

use '^','<','v','>' to indicate movement direction and '.' for stay, if you can move 3 times, output 3 characters.

e.g. "<.<" indicates you move left, wait then left again

Action phase

output one of the actions listed in game play

e.g. - "E 1" equips the 1st item in your inventory if possible - "A 1 2" attacks 1 tile to the right and 2 tile above you if possible.

Determine winner

a game ends if only 1 bot is alive or it is played to 1000 turns.

each each live bot gets 1/<# of bots alive> points

x games will be played and the points will be totaled to determine the winner.

Additional Information

  • Damage is calculated by attack - armor defense. If the defending player used Block, then there is block/10 chance to completely negate all damage.

  • All distance are Manhattan distance

  • More items spawn near the center than border (if I can find a way to do this efficiently)

  • Player can pick roughly where they spawn such as near border or near center (if I can find a way to do this efficiently)

Questions/To-Do list

  • Figure out what's a good map size

  • Too many/little actions/objects?

  • Balance items and stats?

  • Is the game clear enough?

  • Is output and input sufficient for the gameplay?

  • Any suggestions or comments?

  • Format question so it looks nicer. Make important information stand out. Fix grammer

  • Catchy title?

  • Figure out how many games to play to get winner

  • Make it shorter? wall of text is not fun D:

  • Figure out how many of each object to spawn

  • When player die, randomly drop an item, drop equipped item, drop nothing?

  • Find time to write the controller

  • Figure out how to use the site

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

Proposed Question

Triskaidekaphobic Primes

It is known that a certain number, which lies between 12 and 14, brings bad luck. The Church of Triskaidekaphobia (CoTDP) asserts that the key to salvation is avoiding this number in all situations, such as numbering floors, license plates, space shuttle missions and more.

The IT department of CoTDP is looking for talented developers. Candidates must prove their ability to program in accordance with Triskaidekaphobic dogma. Can you get this prestigious job?

Your Mission

Write a program that prints all prime numbers below 1000, excluding the unlucky one. the program must obey the CoTDP programming rules.

Rules

  1. Numbers whose absolute value is greater than 12 and smaller than 14 are considered unlucky and must be avoided.
  2. Unlucky numbers must not be used in the program:
    • Must not appear in the program, in any representation/base.
    • Must not be the value of an expression or calculation (e.g. 5 + 8).
    • Must not be an intermediate value in an expression (e.g. 5 + 8 + 3, 35 % 22 == 0).
    • Must not be stored in a variable, register, memory etc (e.g. for i in xrange(20):).
    • Must not be passed to a function or returned from one.
    • The above applies to any complex type which contains an unlucky number (e.g. range(20) in Python 2).
    • The above applies to all expressions, not just constant expressions (e.g. x+1 is invalid if x happens to be 12).
  3. No calculation, or intermediate value of a calculation, may yield an unlucky number. For example, and for i in xrange(20): are forbidden.
  4. Output lines bust be separated by line-feed only (no carriage return).
  5. You must find primes using basic mathematical operations. If your language provides tools to find primes or test primality, you must not use them.
  6. Standard Loopholes apply.

Scoring

This is code-golf, the shortest solution (in bytes) wins.

Questions for Meta

  • Do the limitations make sense for all sorts of languages? I think they cover languages such as C/Python/Java that use expressions, and also languages such as BrainFuck that manipulate memory (I think it's obvious that you must not write 13 in a memory cell).
  • Is there a trivial solution that makes it uninteresting?
  • Would it be better as a popularity contest?
  • Or maybe, accept the shortest, but give a bounty for the most interesting/creative answer?
  • Can the expression "Church of Triskaidekaphobia" be considered offensive to followers of some churches?
\$\endgroup\$
8
  • \$\begingroup\$ Should we treat numbers such as 39 (13 * 3) as prime, or not prime for the sake of this calculation? If 13 is not a prime, then 39 is, but it's up to you. (I did something kind of similar to this here) \$\endgroup\$
    – Stephen
    Jul 29, 2017 at 19:15
  • \$\begingroup\$ @StepHen, IMO, an unlucky divisor is still a divisor. I think asking for "primes below 1000, excluding the unlucky one" makes it clear. Your interpretation might make it more challenging, but I'm not sure how it would work - 39 is a multiple of 3 (though you shouldn't actually do this division), so how can it be prime? Maybe 169. \$\endgroup\$
    – ugoren
    Jul 29, 2017 at 19:23
  • \$\begingroup\$ Related: we are not allowed to store 13, right? \$\endgroup\$
    – Stephen
    Jul 29, 2017 at 19:37
  • \$\begingroup\$ @StepHen, I'm not sure what you mean by "store". My intention is that 13 won't be used in any way. I write that it can't be used in the program and can't be derived by calculation, so how can it be stored? \$\endgroup\$
    – ugoren
    Jul 29, 2017 at 20:12
  • \$\begingroup\$ Well you could store it with x = ord("\r"), although if you can't use it there's not much point. \$\endgroup\$
    – Stephen
    Jul 29, 2017 at 20:25
  • \$\begingroup\$ ord("\r") is an expression that yields 13, and is therefore invalid. But it's worth clarifying. \$\endgroup\$
    – ugoren
    Jul 29, 2017 at 20:27
  • \$\begingroup\$ Your post (as it stands) says no calculation, not no expression. \$\endgroup\$
    – Stephen
    Jul 29, 2017 at 20:28
  • 1
    \$\begingroup\$ Numbers whose absolute value is greater than 12 and smaller than 14 are considered unlucky and must be avoided. is 12.5 allowed? \$\endgroup\$
    – l4m2
    Apr 2, 2018 at 19:09
1
\$\begingroup\$

Encrypt/Decrypt a Decimal in Binary

Given either a positive integer a or two positive integers b and c, either encrypt or decrypt the integer(s).


Encryption

Given a=33344492, for example:

  1. Split a into consecutive runs: [333,444,9,2].
  2. Replace all runs with alternating 1's and 0's starting with 1: [111,000,1,0].
  3. Place back into binary: 11100010
  4. Convert to decimal: 226
  5. Calculate decryption key: 3492
    • This key is the unique characters from each distinct run.
  6. Return [226, 3492] as the answer, these represent [b, c] respectively.

Decryption

Given b=226 and c=3492:

  1. Convert b into binary: 11100010
  2. Use c to "replace" in each character.
    • 11100010 -> 33300010 -> 33344410 -> 33344490 -> 33344492
  3. Print the single integer answer, a=33344492.

More Examples (For Decryption, Reverse Examples)

12349149
[170,12349149]

99922211100
[1820,9210]

2
[1,2]

9
[1,9]

10
[2,10]

100
[4,10]

0
[1,0]

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
[10141204801825835211973625643007,1]

111222333444555666777888999000
[954437176,1234567890]

10101010101010
[10922, 10101010101010]
\$\endgroup\$
8
  • \$\begingroup\$ I'm not sure if this should be one or two challenges myself. \$\endgroup\$ Jul 31, 2017 at 14:24
  • \$\begingroup\$ @TheLethalCoder based on the number of inputs, you perform a different function. It's one challenge, though it'd be equally viable as two; but it's not interesting enough for 2 challenges. \$\endgroup\$ Jul 31, 2017 at 14:25
  • \$\begingroup\$ Yeah that's why I wasn't sure. Just commenting in case you hadn't thought of splitting it up. \$\endgroup\$ Jul 31, 2017 at 14:26
  • \$\begingroup\$ The decryption stage might be clearer if you use a number that doesn't contain 0s and 1s. \$\endgroup\$ Jul 31, 2017 at 14:27
  • \$\begingroup\$ @TheLethalCoder fixed. \$\endgroup\$ Jul 31, 2017 at 14:29
  • \$\begingroup\$ For your first test case you show a walkthrough. I'd either move it to an actual walkthrough place or remove the steps. \$\endgroup\$ Jul 31, 2017 at 14:33
  • \$\begingroup\$ The first time you talk about the decryption key you say it's 1092. Shouldn't it be 3492? \$\endgroup\$
    – Charlie
    Jul 31, 2017 at 14:49
  • \$\begingroup\$ @CarlosAlejo it used to be 11100092 but I changed it to 33344492, nice catch; missed that. \$\endgroup\$ Jul 31, 2017 at 14:52
1
\$\begingroup\$

Generate a Spiral Matrix

Given N, generate one out of all the spiral matrices with dimensions N x N using the values [0, 1, ..., n-1].

For example, if N = 5, there are 16 ways to generate a spiral matrix

 0  1  2  3  4    12 13 14 15  0     8  9 10 11 12     4  5  6  7  8
15 16 17 18  5    11 22 23 16  1     7 20 21 22 13     3 18 19 20  9
14 23 24 19  6    10 21 24 17  2     6 19 24 23 14     2 17 24 21 10
13 22 21 20  7     9 20 19 18  3     5 18 17 16 15     1 16 23 22 11
12 11 10  9  8     8  7  6  5  4     4  3  2  1  0     0 15 14 13 12

 0 15 14 13 12     4  3  2  1  0     8  7  6  5  4    12 11 10  9  8
 1 16 23 22 11     5 18 17 16 15     9 20 19 18  3    13 22 21 20  7
 2 17 24 21 10     6 19 24 23 14    10 21 24 17  2    14 23 24 19  6
 3 18 19 20  9     7 20 21 22 13    11 22 23 16  1    15 16 17 18  5
 4  5  6  7  8     8  9 10 11 12    12 13 14 15  0     0  1  2  3  4

24 23 22 21 20    12 11 10  9 24    16 15 14 13 12    20 19 18 17 16
 9  8  7  6 19    13  2  1  8 23    17  4  3  2 11    21  6  5  4 15
10  1  0  5 18    14  3  0  7 22    18  5  0  1 10    22  7  0  3 14
11  2  3  4 17    15  4  5  6 21    19  6  7  8  9    23  8  1  2 13
12 13 14 15 16    16 17 18 19 20    20 21 22 23 24    24  9 10 11 12

24  9 10 11 12    20 21 22 23 24    16 17 18 19 20    12 13 14 15 16
23  8  1  2 13    19  6  7  8  9    15  4  5  6 21    11  2  3  4 17
22  7  0  3 14    18  5  0  1 10    14  3  0  7 22    10  1  0  5 18
21  6  5  4 15    17  4  3  2 11    13  2  1  8 23     9  8  7  6 19
20 19 18 17 16    16 15 14 13 12    12 11 10  9 24    24 23 22 21 20

You are allowed to use a parameter P to determine which out of the 16 spiral matrices you will generate.

Rules

  • This is so make your code as short as possible.
  • N >= 1
  • The parameter P should be a value such as a number, character, or any other reasonably simple value.
  • You may output the spiral matrix as a 2d array of numbers or characters, a formatted string, or any other easily understandable format.
\$\endgroup\$
2
  • \$\begingroup\$ Alternatively, the challenge might be to ignore P and just generate all 16 spiral matrices. \$\endgroup\$
    – miles
    Jul 31, 2017 at 22:05
  • \$\begingroup\$ Also related \$\endgroup\$
    – Luis Mendo
    Jul 31, 2017 at 22:27
1
\$\begingroup\$

Interpret a Maximal Number of Brainf*** Variants

A while ago in chat, I had an idea:

enter image description here

It was prompty shot down as impossible. Because of that, I'm making it a challenge!

Valid Languages

The only valid brainfuck variants you can use are the languages appearing on this link and this link (along with regular brainfuck, of course). Those two links are July 3rd, 2017 captures of the esolangs.org pages for brainfuck derivatives and brainfuck equivalents.

The Task

Your task is to create one program that, when fed code from any variant of brainfuck you say you can interpret, along with input for that program, will execute that code according to the spec of that variant. You cannot tell the interpreter beforehand what variant it is supposed to interpret.

There is one very important note: in brainfuck, for example, all characters not used are ignored as comments. Any program that is entered will not contain comments. All input will only contain characters that are not ignored by the spec.

Knowing this, if two variants of brainfuck overlap enough that you cannot differentiate between two valid, however short, programs in them, and if each language wants a different result, you can only include one of those languages.

Scoring

The most important part of this challenge is maximizing the number of variants you can support. However, you also don't want to make it too long. Therefore, the following is your score:

(variantsSupported * 300) - interpreterBytes

Highest score wins.

\$\endgroup\$
2
  • \$\begingroup\$ yeah the problem is that ignored characters are not well defined. that is, any string of characters, excluding [ and ] (they might be misbalanced) is a valid bf program. that's a part of the spec pretty much \$\endgroup\$ Aug 2, 2017 at 23:25
  • \$\begingroup\$ @DestructibleLemon I'm (trying) to remove that from the spec - if part of the spec is that some chars are no-ops, your interpreter does not have to handle them \$\endgroup\$
    – Stephen
    Aug 2, 2017 at 23:35
1
\$\begingroup\$

Is this 2048 board valid?

Some 2048 boards are impossible to get into. For example,

2 _ _ 2
_ _ _ _
_ _ _ _
2 _ _ 2

will never occur in a 2048 game. Additionally, these are all impossible:

8 _ _ 8    8 _ _ _    2 2 2 2
_ _ _ _    _ 8 _ _    2 2 _ _
_ _ _ _    _ _ _ _    _ _ _ _
8 _ _ _    _ _ _ _    _ _ _ _

Your program needs to accept a 2048 board, and return a truthy value if the board is reachable, else falsy.

//Explanation of 2048 goes here.

I've listed 4 different boards that cover major test cases. Are there any others I'm missing?

\$\endgroup\$
3
  • \$\begingroup\$ hehe, don't forget [tag:sliding-puzzle] \$\endgroup\$
    – Stephen
    Aug 1, 2017 at 19:56
  • \$\begingroup\$ As you've stated yourself the main thing missing here is the bulk of the challenge. \$\endgroup\$ Aug 2, 2017 at 9:14
  • \$\begingroup\$ I wonder if it suffices to look one step back, or if you need to check if the previous position can itself be produced. \$\endgroup\$
    – xnor
    Aug 4, 2017 at 7:35
1
\$\begingroup\$

I've got a challenge, but I'm not quite sure how to implement it in a way that's on-topic. It's possible this type of question just doesn't mesh with PPCG, but that's what the SandBox is for, right?

The gist is that I want a sort implemented lazily. So lazily that you don't actually write one, you steal someone else's. Your code should take an input, find/scrape an existing sorting algorithm off StackExchange (just PPCG?), run it, and output the sorted list.

Here's what I've got so far:

The Laziest Sort

I need a program that sorts a list, but man am I lazy. I don't mean "I'll just write a bubble sort and call it a day" lazy, but "I don't even want to write any sort at all" lazy. In fact, I don't even want to look at a sorting algorithm.

Given a list of numbers, I want you to return to me a sorted list. But like I said, I don't want to look a sorting algorithm. Instead, I want you to go find an existing sorting algorithm, run it, and tell me what it said.

The rules (This is part of where I need the SandBox)

  • You may not use any native sorting algorithms (like Collections.sort()).
  • You may use any sorting algorithm you can find, so long as it is from StackExchange.
  • You may import the code from the algorithm you use and run it from your answer, so long as the actual algorithm isn't in your source code.
  • Anything other requirement this challenge needs? I feel like this describes the problem I have in mind, but I've only made a few questions and they're typically math/array based.

Scoring

seems an odd tag here, but seems to be frowned upon. Especially since I don't have a great question formed yet, but I feel like I've got a reasonable idea here. Any tips on how to get this question presentable enough to actually post?

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Yeah, we have a tag for this. It's called duct-tape-coding \$\endgroup\$
    – geokavel
    Aug 5, 2017 at 4:41
  • \$\begingroup\$ I would use code-golf for this personally. \$\endgroup\$
    – Gryphon
    Aug 8, 2017 at 2:42
  • \$\begingroup\$ You mean, implement Stacksort? :) (not exactly the same, but very similar) \$\endgroup\$
    – Sanchises
    Aug 8, 2017 at 11:27
1
\$\begingroup\$

Ah, Polish notation is always so confusing... [ABANDONED]

...so I order you to show me just how it works!That is, if you accept the challenge of course. For example, I can't even determine if xyz01 is supposed to do x(y(z(0)),1) or x(y(z(0),1)), if I don't know the arities. And, even if I know the arities, I can't understand what 20121012100 does in first glance (I have to think much to realize it's 2(0,1(2(1(0),1(2(1(0),0)))))). So, please, make my life easier.


Your challenge is, given a string, to "aritify" it. Here's how you do it:

First, you get a string (expression) containing up to 3 distinct chars, representing operators/functions with specific arities 0, 1 and 2.

Then, you convert the string to function-call representation, separating arguments with ,s and enclosing them in ()s (e.g. 212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))). This is the string you will return.

Rules

  • You are guaranteed that you are only given one expression (e.g. never something like 120010 -> 1(2(0,0))1(0) which contains more than one expression as a whole). Also, the input will never be empty.
  • There will not be missing trailing arguments, so something like 20 -> 2(0,the heck?) will never occur.
  • You may choose any 3 chars for the arities (e.g. n for 0, m for 1, d for 2), but you must specify them in your answer. You can't use any of ()[]<>{},; or space.
  • For the brackets, you may choose any one of (), [], <> or {}.
  • For the argument separator, you may choose ,, ; or (space). Also, the separator may have a trailing space, or both a trailing and a leading space, if it isn't a space. You must use a separator, it makes my life easier (how am I supposed to be able to read 211012101200 as 2(1(1(0))1(2(1(0)1(2(00))))) instead of 2(1(1(0)),1(2(1(0),1(2(0,0)))))? It's not properly organized.)
  • Chars defining arities must be outside the brackets, to the left, so something like 1200 -> ((0,02)1) or ((0,0)2)1 is disallowed instead of 1(2(0,0)). I want to know what operator it is before I start reading the arguments.
  • The 0-arity operator must not have appended brackets (e.g. 210110 -> 2(1(0),1(1(0))), not 2(1(0()),1(1(0())))), it's just useless cluttering that reduces simplicity, since you can always treat them as literals.
  • You may not omit the operator names (e.g. 221010121100 -> (((),()),(((()),))) is disallowed, 2(2(1(0),1(0)),1(2(1(1(0)),0))) is correct).
  • The chars used for input must be the same as those used for output.

Test cases

Most of these test cases are already in this post, I've just summed them up here and added some more. I used 012 as arities, ()s as brackets and , as separator here.

Input        -> Output

20121012100  -> 2(0,1(2(1(0),1(2(1(0),0)))))
212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))
211012101200 -> 2(1(1(0)),1(2(1(0),1(2(0,0)))))
1200         -> 1(2(0,0))
210110       -> 2(1(0),1(1(0)))
221010121100 -> 2(2(1(0),1(0)),1(2(1(1(0)),0)))
10           -> 1(0)
0            -> 0

Sandbox

  • Please comment if there's any error in the test-cases.
  • How could I make this challenge better?
  • Bumps: 3
\$\endgroup\$
2
  • \$\begingroup\$ Can I adopt and post this abandoned proposal? \$\endgroup\$
    – user58826
    Jun 9, 2017 at 1:38
  • \$\begingroup\$ @programmer5000 Not entirely abandoned yet. \$\endgroup\$ Jun 9, 2017 at 7:53
1
\$\begingroup\$

The Mode of an Image

Given an image as input, output it's mode; that is the colour that appears most in it. However, I am on a tight schedule and so need this code to compute as fast as possible.

Input

Input can be in any reasonable format for your program i.e. filename or image object. However, the input image must have at least 3 channels i.e. r, g, b or 24bpp.

Output

Output can be by any reasonable means i.e. return of a method or print to STDOUT.

Test Cases

//TODO: add them

Scoring

As this is the winner is the answer which scores the lowest total time over all of the test cases. For example, if there are two test cases then the score = timeForTestCase1 + timeForTestCase2.

In the even that more than one winning answer scores the same more test cases will be added. The winning answers will be notified and should be updated accordingly.

Sandbox

  • Test case suggestions?
  • Better scoring mechanism? i.e. average of the time for each test case
\$\endgroup\$
2
  • \$\begingroup\$ Will all input images be of the same dimensions? \$\endgroup\$
    – user41805
    Aug 10, 2017 at 15:11
  • \$\begingroup\$ @Cowsquack No they will vary \$\endgroup\$ Aug 10, 2017 at 15:12
1
\$\begingroup\$

Left or Right?

You have a carousel of images, and you know the index of the image you wish to view.

The carousel shows a few images per page, so you need to be able to calculate if you need to move at all.

Also, the carousel wraps - so you can click 'right' on the last page to go to the first page, and 'left' on the first to go to the last.

The first image on the first page is at index 0 - and the last page may not, depending on the amount of images, always be full. If you prefer, you may start your indexing at 1 instead, but remember that the indexes in all of the example inputs will need to have 1 added to them.

Input

4 numbers, in whatever format is suitable for your language;

  • Total - The amount of images in the carousel (1 or greater)
  • PageSize - The amount of images per section in the carousel
  • CurrentIndex - The index of the image you are currently looking at (0 to Total-1)
  • DestinationIndex - The index of the image you wish to look at.

Output

The desired direction to scroll (if at all). This should be the fastest direction (ie least amount of clicks), desiring right in the case of a tie.

Either;

  • L - Click the left button (ie, go backwards)
  • R - Click the right button (ie, go forwards)
  • N - No movement required - output this if the image you seek is on the same page as your current image.

If you prefer, you may specify 3 other distinct outputs, such as -1 0 and 1 for example.

Examples

Say we have 5 3 0 4, so 5 total images, a page size of 3, we're currently at image index 0, aiming for 4. Our carousel would look something like this:

< [0 1 2] >

Pressing either left or right (there are only 2 pages) would lead us to this:

< [ 3 4 ] >

On this page, we can see image 4 which we are aiming for, so in this example, you would be expected to return R. Although L is the same length, in this exercise we are to favour going right in the case of a tie. Also note that you are expected to return just the direction you would need to go, so if you would have to click R 3 times, still only return one R.

Here are some more test cases;

5 2 0 2 -> R
10 5 1 4 -> N
10 3 8 1 -> R
10 3 8 4 -> L
\$\endgroup\$
9
  • \$\begingroup\$ I think this is kind of easy for this is site. One suggestion I have is to make the carousel "broken", such that it moves by n pages per click, instead of 1. Then a fourth output would be "X", saying that it's impossible to reach a certain image. \$\endgroup\$
    – geokavel
    Aug 9, 2017 at 2:45
  • \$\begingroup\$ You should allow 1-indexing and not force everyone to use 0-indexing. Also the first test case is returning L or R allowed or should you prefer to return R over L always? \$\endgroup\$ Aug 9, 2017 at 10:35
  • \$\begingroup\$ @geokavel I don't think that's necessary, easy challenges are still good challenges. \$\endgroup\$ Aug 9, 2017 at 10:35
  • \$\begingroup\$ Guess it's ok as is. \$\endgroup\$
    – geokavel
    Aug 9, 2017 at 16:49
  • \$\begingroup\$ TheLethalCoder good point, I did mean to do that, but forgot to mention it. Also I did mention that in the first paragraph of the output section, but I'll reiterate it in the example paragraph you refer to. geokavel - Thanks for your input - but I personally would like to see a few more easier challenges on this site to encourage newbies (like myself) \$\endgroup\$
    – Shadow
    Aug 9, 2017 at 23:39
  • \$\begingroup\$ @TheLethalCoder - actually, using 1 based indexes would change the input as well. Do we still generally allow that when the input is going to change? \$\endgroup\$
    – Shadow
    Aug 9, 2017 at 23:42
  • \$\begingroup\$ @shadow Yes we usually allow people to use 0 or 1 indexing irrespective of whether the input changes or not. \$\endgroup\$ Aug 10, 2017 at 7:52
  • \$\begingroup\$ Could we output, for example, 1, -1, and 0 instead of R, L, and N? \$\endgroup\$
    – Stephen
    Aug 10, 2017 at 19:23
  • \$\begingroup\$ @StepHen - I don't see why not. \$\endgroup\$
    – Shadow
    Aug 10, 2017 at 23:06
1
\$\begingroup\$

Archer Battle

Your challenge is to simulate a battle between two armies of archers.

Each army has a population and an accuracy. Each round, every archer will let fly an arrow at the enemy army. The archers are trained each to shoot at different targets. Any archer hit by an enemy arrow is eliminated, and is does not participate in the next round. The battle is over when all archers in one or both armies have been eliminated.

The accuracy of the archers is almost exact. That is, ceil(population * accuracy) arrows will hit their targets. (No need to use random number generation.)

Input

Take 4 inputs in any reasonable manner:

  • Army 1 population (positive integer)
  • Army 2 population (positive integer)
  • Army 1 accuracy (nonnegative float)
  • Army 2 accuracy (nonnegative float)

Output

Output the population of the winning army at the end of the battle.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ What if there are more archers than targets, and so they can't all shoot at different targets? \$\endgroup\$
    – isaacg
    Aug 12, 2017 at 11:39
  • \$\begingroup\$ @isaacg Good point. I suppose "every archer selecting a different target" doesn't match the model perfectly. Perhaps "The archers distribute their targets among the opposing army as evenly as possible." and "`ceil(population * accuracy) enemies will be struck by arrows (capped at the remaining population of the opposing army, of course)." Any suggestions on improving the wording? And would a sample program help? \$\endgroup\$
    – Matt
    Aug 12, 2017 at 23:31
1
\$\begingroup\$

Smooth Usage [On hold while alternative scoring is considered]

We've all seen CPU usage graphs like this one:

CPU Usage example

Doesn't that look ugly? It would look much nicer as a lovely smooth sine wave...


Challenge

Write a program in the language of your choice that will infinitely produce a regular sine wave in Task Manager's (or Activity Monitor's if that's your thing) CPU usage graph.

You may assume:

  • Background CPU usage is constant
  • Only a single core must display the pattern
  • The system has sufficient cooling to prevent thermal throttling
  • Features such as Intel TurboBoost are disabled

This is tagged as to encourage short answers, but ultimately will be a as I suspect perfect solutions will be hard to come by.

\$\endgroup\$
5
  • \$\begingroup\$ Related: stackoverflow.com/questions/551494/… \$\endgroup\$
    – MTCoster
    Aug 11, 2017 at 15:14
  • \$\begingroup\$ code-golf and popularity-contest don't mix together. You have to choose one or the other, but making it strictly code-golf would be difficult because you'd have to define what is a good enough sine wave, but on the other hand popularity contests are very risky to do. \$\endgroup\$
    – dzaima
    Aug 11, 2017 at 15:16
  • \$\begingroup\$ @dzaima That was exactly my dilemma - which would you suggest fits the challenge best? \$\endgroup\$
    – MTCoster
    Aug 11, 2017 at 15:17
  • \$\begingroup\$ I'd say a scoring algorithm of some sort would be best for this, no idea how you'd do it. Like the related one was objective. If you could read the word, it was valid. With this, is a bumpy sin-wave a sin-wave? \$\endgroup\$ Aug 11, 2017 at 20:39
  • \$\begingroup\$ @MTCoster If you're not sure whether popularity-contest fits, then you can be sure that it does not. It is quite difficult to make an well received one. Go with code-golf or make a code-challenge if you can come up with a good own winning criterion. \$\endgroup\$
    – flawr
    Aug 11, 2017 at 20:53
1
\$\begingroup\$

Reverse Cycling with Rubik's

In Cycling with Rubik's, you were asked to find the period of a given sequence of turns - or, in Geobits' words:

Given a sequence of turns, [find] the fewest number of times it must be performed to return the cube to its original state.

Today, I'm asking you to do the opposite.

Terms you might not know:

  • "algorithm": a sequence of moves on the faces of a Rubik's cube
  • "period": the minimum number of times an algorithm must be repeated before a solved cube returns to the solved state

Input

The input will be the period of a Rubik's cube algorithm. This is an integer between 1 and 1260, as any algorithm can be performed 0 times, and the highest possible period for any given algorithm is 1260.

Output

The output will be any algorithm that has a period equal to the input. Algorithms should use standard notation, namely:

R - Turn the right face clockwise 90°
L - Turn the left face clockwise 90°
U - Turn the up (top) face clockwise 90°
D - Turn the down (bottom) face clockwise 90°
F - Turn the front face clockwise 90°
B - Turn the back face clockwise 90°

Adding the prime mark ' to the end of any move changes it from a clockwise rotation to a counterclockwise one, so F' turns the front face counterclockwise, and F F' would return it to the original state right away.

If you're still confused about face turns, you can check out this.

Examples

Input -> Output
1     -> FF'
4     -> R
4     -> UD
6     -> RUR'U'
12    -> LLUUFFUURRUU
56    -> LUFFRDRBF
105   -> LF
120   -> UFFR'DBBRL'
315   -> FRBL
1260  -> U1R3U1F3D2

Winner

As with , the answer with the least bytes wins! As this is very difficult (it might be impossible), I will give a +50 bounty to the first answer, or +100 if it's under 100 bytes. Good luck!

\$\endgroup\$
5
  • 1
    \$\begingroup\$ The order of the Rubik's cube group is 2²⁷ 3¹⁴ 5³ 7² 11, so by Lagrange's theorem there's no algorithm of order 13. \$\endgroup\$ Aug 17, 2017 at 8:41
  • \$\begingroup\$ @PeterTaylor Is the same true for any other prime? \$\endgroup\$
    – H.PWiz
    Aug 17, 2017 at 15:24
  • \$\begingroup\$ @H.PWiz, the same is true for any other number which isn't a factor of the order of the group. I'm not sure whether subgroups exist for all factors smaller than the largest order of an element. Certainly they do for all prime factors, by Sylow's theorems. \$\endgroup\$ Aug 17, 2017 at 15:28
  • \$\begingroup\$ @PeterTaylor I don't know any group theory, but thanks anyway. \$\endgroup\$
    – H.PWiz
    Aug 17, 2017 at 15:32
  • \$\begingroup\$ Hmm.. unlike the Cyling with Rubik's challenge, this one can only be solved by bruteforce if I understand correctly? Also, what's with the R3 and F3 in the 1260 test case? These can just be R' or F'. Or if you are allowing 3 instead of ' as output, I would mention it somewhere in the challenge. Off-topic: But it's funny that my Rubik's cube logo is almost next to your challenge title, since I posted the previous sandbox answer. ;p \$\endgroup\$ Aug 18, 2017 at 6:49
1
\$\begingroup\$

Time bomb ping pong


Challenge - Both teams

All users are divided into two teams based on their PPCG ID. For example, my ID can be found here, from which you can see that my ID is 34388. To check on which team you are, run the following snippet:

function update_team(){var e=document.getElementById("user-id").value,t=(document.getElementById("team-result"),"");t=e.match(/^\d+$/)||0===e.length?-1!==even_top_50.indexOf(parseInt(e))?"You are in team: ALPHA":-1!==odd_top_50.indexOf(parseInt(e))?"You are in team: BETA":0==e.length?"":"You are in team: "+(parseInt(e)%2==0?"ALPHA":"BETA"):"ID must be numeric",document.getElementById("team-result").innerHTML=t}var even_top_50=[12012,20260,17602,11259,26997,194,31716,20080,58563,47066,1426,4098,30688,56656,41723,3967,1490,31516,40695,29577,43319,15599,32686,3191,4020,67,34718,41024,7311,39328,16766,7110,31625,2867,59107,52210,16120,6710,68942,10740,9365,84,1147,15,199,7162,1308,3103,26600,59487],odd_top_50=[8478,36398,21487,3808,42545,3852,53748,48934,34388,21348,4162,34531,25180,31414,24877,31957,20469,31343,7416,45941,32014,39242,42963,11006,6828,9498,9288,14215,4198,3544,30164,33208,4372,95,41805,56178,668,47120,30525,55735,51507,57100,6699,737,39022,46855,51939,32700,59376,7209];
.main-header,.main-input,.result{font-family:Montserrat,sans-serif;text-align:center}.main-header{font-size:24px}.main-input{display:block;margin:12px auto auto}.result{margin-top:24px}
<br><div><div class="main-header"> Enter your PPCG ID </div><input class="main-input" maxlength="6" onkeyup="update_team()" id="user-id"> <div class="result" id="team-result"> </div></div>

Each user has two options:

  • Start a new bomb
  • Perform a counterattack

These actions are discussed here:


Start a new bomb

To set up a new bomb, you need to do the following:

  • Create a full program in any free language which has the output X.
  • Create a custom list of characters with a maximum of 10 characters.
  • Select one or more characters from the character list and insert them into your program, which will be having the exact same output X. This ensures that there is at least one crack for your submission.
  • Only reveal the full original program and the character list. Keep the modified program secret. Also keep track of the iteration index, which in this case is 1 (since it's the start of a new bomb).

This is an example of a new bomb submission:


Python 2, 9 bytes (index = 1)

Outputs the number 30.

print 5*6

With as character set 13579/. Try it online!.



Perform a counterattack

To perform a counterattack, you need to do the following:

  • Create a new full program with at least one character inserted from the list given by the opponent, which will have the exact same output X.
  • Create a custom list of characters with a maximum of 10 characters.
  • Select one or more characters from the character list and insert them into your program, which will be having the exact same output X. This ensures that there is at least one crack for your submission.
  • Only reveal the full original program and the character list. Keep the modified program secret. Also keep track of the iteration index, which in this case is the increment of the previous index.

This is an example of a counterattack (using the previous submission):


Python 2, 12 bytes (index = 2)

Defuses Python 2, 9 bytes, Adnan.

Inserts 1, / and 3. Outputs 30:

print 15*6/3

With as character set: +-~58. Try it online!



Scoring system

Every bomb that has not been defused for 7 days gives the team 'index' points. If the index was 4, your team gets 4 points. You are only able to collect the points after you have revealed your own solution. Note that if you do not reveal your solution after the 7 days, it is still vulnerable to cracks.

As for the individual winner of the team, the person with the most cracks of the winning team gets the check mark.


Sandbox notes

  • Note that this is more of an experimental challenge. Unlike the conventional 1 vs 1 cops-and-robbers challenges, this is an attempt on an n vs n-challenge, so I have no idea whether this is a good idea or not.

  • The scoring system is a bit tricky, but I think that when a bomb has 'exploded', the opponent's team gets (index) points. The team with the most points at the end wins. The problem here is that the byte count might make things worse, since a larger program would make cracking the submission harder.

  • A problem I'm finding here is the fact that the cop can create an arbitrarily large program, which makes it almost impossible to crack. I'm not sure whether this actually is a problem, since the 'exact same output'-rule should theoretically take care of this.

  • Perhaps add a third option for the user, where the user defuses a bomb. This would consist of cracking the submission, but does not create a counterattack (for cases when this is impossible, or trivial (like adding comments)).

  • I'm also not entirely sure about the 'choose your own output'-idea. Would this leave too much options for abusement?

  • Is the maximum of 10 character too much / too little? Should this also be taken in account with the scoring?

Thanks in advance!

\$\endgroup\$
8
  • \$\begingroup\$ Maybe try the wording "one or more" instead of "at least one"? It took me a while to realise that was what you meant. For more meaningful feedback about diffusions/maximums I think you'd have to decide on a scoring mechanism first. Since both teams use the same bombs to advance their score I don't think the byte count think is that big of a problem? \$\endgroup\$ May 27, 2017 at 0:38
  • \$\begingroup\$ @FryAmTheEggman Thank you for your response. I have decided that the score is just simply the sum of all index numbers of the bombs that aren't diffused after three days. This encourages counterattacks more, since the score will increment after each counterattack. \$\endgroup\$
    – Adnan
    May 27, 2017 at 9:34
  • \$\begingroup\$ Nice. A never-ending hot potato game. \$\endgroup\$ May 29, 2017 at 12:27
  • \$\begingroup\$ @SIGSEGV Yeah, that's what it's supposed to be. I should probably set a time limit somewhere, otherwise there will be no winner at all :p. \$\endgroup\$
    – Adnan
    May 29, 2017 at 13:07
  • \$\begingroup\$ I'm worried that this could very easily turn into "stay online more than your opposition does", if an answer is given in a language that's very easy to crack. \$\endgroup\$
    – user62131
    May 31, 2017 at 22:47
  • 3
    \$\begingroup\$ 1. Defuse, not diffuse. 2. Three days is not much. A carefully timed post at the start of the weekend could slip through the net. 3. Unless I missed it, there's nothing to prevent the usual CnR-killer crypto answer. Are you absolutely certain that they won't break the challenge? \$\endgroup\$ Aug 21, 2017 at 12:51
  • \$\begingroup\$ @PeterTaylor Thanks for your response. I have changed the time limit to 7 days. The main problem would indeed still be cryptographic submissions. I tried to decrease the severity of this problem by making sure that the output would remain exactly the same before and after modifying the submission, but I need to experiment a bit with this to see how this would end up. Hashing would almost certainly not be possible, unless a hashing algorithm is cracked (but I'm not 100% certain about this). \$\endgroup\$
    – Adnan
    Aug 21, 2017 at 13:06
  • \$\begingroup\$ As for the hashing, this worked for me: "Please, don't "implement RSA" or anything mean to the robbers. Use obscure languages and features, not boring encryption and hashing. I can't enforce this with rules, but you can expect torrential downvotes if all you do is sha(input) === "abcd1234"." \$\endgroup\$
    – user58826
    Aug 24, 2017 at 14:33
1
\$\begingroup\$

Conversion: 2 dice from 3


This fascinating video from Matt Parker's standupmaths poses a challenge:

Given the result of rolling 3 indistinguishable (unordered) dice, simulate the result of rolling 2 indistinguishable (unordered) dice.

For the purposes of this challenge, simply returning the sum of 2 dice is not sufficient. Returning 2 ordered dice is acceptable, as the order can be ignored so this still fulfils the requirement.

Input

Either 3 unordered values from 1 to 6, or 3 ordered values from 1 to 6. If the values are ordered, then the output must be independent of the input order. For example, the input 1, 2, 3 should give the same output as the input 2, 1, 3.

These are standard dice. Your code may not assume the values will be from 0 to 5 instead of 1 to 6.

Output

Either 2 unordered values from 1 to 6, or 2 ordered values from 1 to 6. If the values are ordered, then different orderings will be considered equivalent. For example, output 1, 2 is equivalent to output 2, 1.

Given input that matches the probability distribution of rolling 3 dice, the probability distribution of the output must match that of rolling 2 dice.

You can choose to calculate the outputs however you wish, provided that they are deterministic (the same input in any order gives equivalent output). That is, different answers may use different mappings. So for input 1, 2, 3, one answer may give output 4, 5, while another answer may give output 5, 6. Provided all outputs occur in the correct proportions, both answers are valid.

The output must also use standard dice. Your code may not output values from 0 to 5 instead of 1 to 6.

Checking for correctness

One simple but laborious way of checking that the outputs occur in the correct proportions is to consider all 216 possible ordered triples as inputs. This automatically accounts for the fact that the unordered triple 1, 2, 3 is 6 times more likely to come up that the unordered triple 1, 1, 1, since it will occur as 6 different ordered triples (the 6 different ways of arranging 1, 2, and 3).

A valid answer will give the same output (apart from order) regardless of the order of the input, and will give any given double such as 1, 1 for exactly 6 of the ordered inputs, and any given distinct pair such as 1, 2 (equivalently 2, 1) for exactly 12 of the ordered inputs.

Scoring

The original puzzle was asking for an easy way for humans to calculate this in their heads during playing a game. This challenge is instead , so the score is the number of bytes in your code, and the lowest score in a given language wins.

Prior work

This was also posted on puzzling.SE and there are a number of approaches there. Although they are aimed at being human usable, there may be some insights there that are relevant to writing short code.

Test cases

As every answer may use a different mapping, there is no way to generate meaningful test cases for this challenge. The simplest way I can think to test is as described above under "Checking for correctness".


Sandbox questions

  • I've just discovered this previous challenge which is based on the same video. It asks only for the sum of 2 dice, rather than an unordered pair, so is not identical. Is this a sufficient difference to avoid this being a duplicate, and would it be different enough to be worthwhile posting?
\$\endgroup\$
2
  • \$\begingroup\$ Even if it's not officially a dupe I'd still like feedback on whether it's different enough to be interesting. \$\endgroup\$ Aug 23, 2017 at 15:45
  • \$\begingroup\$ Looking at the Jelly answer, I think the change required for this question is to remove the final character. So yes, it does fail the dupe test. \$\endgroup\$ Aug 23, 2017 at 21:35
1
\$\begingroup\$

Just a relative

Summary

Produce a piece of golfed code that will take a spreadsheet formula and a translation vector and adjust any cell references in the formula by the translation vector.

Rules

What you need to create is a program that takes 2 inputs. A string formula and a representation of the transformation the formula is to undergo (i.e: 1 1 (column, row)).

Invalid inputs include, but are not limited too, inputs with invalid cell references, translations that produce invalid references (see definitions) and formulas formulas that don't start with an equals sign.

The output should be the formula with its' cell references transformed as per the rules above. Input types are flexible, but the output should be a string with no leading/trailing whitespace.

Definitions

Cell Reference

An alphanumeric string that within spreadsheet software, indicates the cells position on a 2D grid. They consist of two parts, an alphabetic segment a numeric segment.

The alphabetic segment represents the column position of the cell. It can be of any length, with each character belonging to the 26 letter English alphabet and is case insensitive. A numerical mapping of the column position can be attained using 26-adic bijective numeration.

The numeric segment represents the row position of the cell, and must be a positive non-zero integer.

It is also valid for the dollar $ symbol to appear in a cell reference. A single one is valid preceding both the alphabetic and numeric segments either independently or simultaneously. A dollar preceding the alphabetic segment indicates an invariant column under transformation, and a dollar preceding the numeric segment indicates an invariant row under transformation.

Function

An arbitrarily named reference to some set of instructions.

For the purpose of this challenge, these are defined as a case insensitive alphanumeric string followed by an open and closed set of rounded brackets. Within these brackets, arbitrary arguments can be present including other functions, arbitrary values and cell references. Arguments are comma seperated.

Example: CALCULATEBYTES('mycodegolfanswer', A1)

Formula

A calculation composed of arbitrary numeric operators, functions, values, cell references etc.

A formula must be started with an equals = sign and can then be followed by anything except for a numeric operator.

Examples

=SUMIFS(A1, "=2") 1 1
>>=SUMIFS(B2, "=2")

=SUMIFA1(GL93) 1 2
>>=SUMIFA1(GM95)

=ARBITRARY($A$1)+CRAZY(G$3) 3 3
>>=ARBITRARY($A$1)+CRAZY(J$3)

=$A3+B$2+$C$1 4 -2
>>=$A1+F$2+$C$1

Hope this all makes sense!

Winner is the shortest code in bytes, but bonus kudos if anyone posts a golfed answer in punch card Fortran!

Happy golfing!

\$\endgroup\$
2
  • \$\begingroup\$ 1. The post is a bit "wall of text"-ey. Maybe separate out all the description of what references are from the main challenge a little? 2. You talk about using $ for absolute referencing but don't mention them in the challenge or give any test cases for them. 3. It's normal in code-golf to assume input will be valid or (almost equivalently) allow any behaviour upon receiving invalid input (I'd suggest one of these). If you do keep an actual "error requirement" you should state if it should be the string "error" or an actual error and probably add a reason for the error to the test case(s). \$\endgroup\$ Aug 24, 2017 at 21:07
  • 1
    \$\begingroup\$ @JonathanAllan Thanks for the feedback. Amended based on what you said \$\endgroup\$
    – dbr
    Aug 25, 2017 at 21:59
1
61 62
63
64 65
155

You must log in to answer this question.

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