535
\$\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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

3497 Answers 3497

1
43 44
45
46 47
117
1
\$\begingroup\$

I would like to ask this challenge:

The objective of this programming puzzle is to reproduce the following gif. enter image description here

However, I do not know the specs for the making of such an animation.

How can I make this a standard/allowed puzzle with this limitation?

Any inputs will be appreciated.

\$\endgroup\$
5
  • \$\begingroup\$ I'm afraid it's rather unlikely there is any way for this to become an acceptable challenge without you specifying the gif very precisely. You don't really need to know how to make an animation to do that, but you need to be able to accurately describe the shapes involved. You'd also probably need to describe framerate as a minimum, and probably a min/max speed of the dots. \$\endgroup\$ Jun 9 '17 at 14:37
  • \$\begingroup\$ Seems like a very interesting challenge, but needs quite a few things, including an objective winning criterion and an actual description of the required output. \$\endgroup\$
    – MD XF
    Jun 9 '17 at 16:42
  • \$\begingroup\$ @FryAmTheEggman How would determine the speed of the dots? i.e., what unit should I use? What framerate would advise? \$\endgroup\$ Jun 9 '17 at 17:39
  • \$\begingroup\$ @MDXF Would smallest answer be a good criterion? \$\endgroup\$ Jun 9 '17 at 17:39
  • \$\begingroup\$ I'm afraid I'm not certain how to approach making the animation smooth by specifying these. However, I do think code-golf is a suitable winning criterion. \$\endgroup\$ Jun 9 '17 at 17:44
1
\$\begingroup\$

Write a brute-forcer for the 3-byte input 'emoticon numbers' challenge

The Emoticon numbers! challenge asks you to identify the 3-byte snippet which evaluates to the highest numeric value in your language, and which also has the bytes in the form ABA (where the outer two are identical and the middle one is different), and which generates an output that is only digits.

I trust your claim that you have identified the best possible one is honestly intended, but as a casual scripter I'm not totally convinced, and can't be reassured by unfamiliar language specification references - since there are only 256^2 possible values, can you convince me with brute force instead?

Write a program or function which:

  1. takes no input
  2. generates all the possible 3-byte sequences matching the pattern ABA and evaluates them in the same language. (No using one language to generate the best pattern for a different language).
  3. Processes all the ones which evaluate to digits-only (output text matches the regex ^[0-9]+$, with or without trailing newline).
  4. Outputs just the ABA sequence which evaluated to the highest value, and an optional trailing newline. No errors or stderr output from failed evaluations.

Clarifications:

  • There's no limit on runtime, but your program must at least plausibly finish if run for long enough. Particularly, if evaluating one of the byte sequences would get stuck prompting for keyboard input, or go into an infinite loop, or quit the interpreter, you must avoid or handle that.
  • If you are able to usefully reduce the search space (and explain why it's valid for your language) to avoid searching 256^2 options, that's OK. Especially if you need to do so to get past an infinite loop, etc.

Show off your brute-force strength by forcing your brute-forcer into the smallest possible space. Fewest bytes wins.

Tag:

\$\endgroup\$
5
  • 2
    \$\begingroup\$ The whole challenge seems really brute-force :)) \$\endgroup\$
    – Mr. Xcoder
    Jun 9 '17 at 17:17
  • 1
    \$\begingroup\$ I actually did that to prove that 9E9 is the optimal JS solution. \$\endgroup\$
    – user58826
    Jun 9 '17 at 17:33
  • \$\begingroup\$ -100 points if your brute forcer fits ABA :D \$\endgroup\$ Jun 9 '17 at 18:47
  • \$\begingroup\$ Now I'm wondering if there are languages for which some program of the form ABA neither halts nor obviously doesn't halt. It's likely too short, but who knows. \$\endgroup\$
    – user62131
    Jun 10 '17 at 3:55
  • \$\begingroup\$ [With no downvotes or critique it's not too badly formed, but with only +1 upvotes it's not popular either so I am not going to post it] \$\endgroup\$ Jun 28 '17 at 0:31
1
\$\begingroup\$

Heapify a list

META:

As a few people just pointed out, if you sort the list, this also produces a correct heap. I'm now trying to come up with a more interesting application of heaps.

Given a list of integers, heapify this list and return it. The sumission must have a worst case time complexity in O(n).

Details

  • Your implementation can produce min- or max-heaps, whatever is more convenient.
  • Sorting the list would solve the problem, but since the worst case complexity must be in O(n) where n is the length of the list, known sorting algorithms like quicksort fail to meet this requirement.

Definition

A min-heap is a complete binary tree where the values stored in the children of a any node are greater or equal than the ones stored in the node itself. (In a max heap it is the same just with condition less or equal).

A heap can be easily represented using a list L (here using 1 based indexing) where the children of the node at L[k] are L[2*k] (the left child) and L[2*k+1] (the right child).

A list L (lets say one based indexing is used) is (min)-heapified if

 L[k] >= L[2*k] and L[k] >= L[2*k+1] for all k

For a max heap we just replace >= with <=.

Examples

Following image represents a max heap:

The corresponding list representation is

[100, 19, 36, 17, 3, 25, 1, 2, 7]

The following image represents a min heap:

The corresponding list representation is

[1, 2, 3, 17, 19, 36, 7, 25, 100]
\$\endgroup\$
5
  • \$\begingroup\$ CJam, 1 char using the "sort" builtin \$\endgroup\$ Apr 13 '17 at 11:05
  • \$\begingroup\$ @PeterTaylor Thanks, that totally defeats this challenge of course=) \$\endgroup\$
    – flawr
    Apr 13 '17 at 11:54
  • \$\begingroup\$ I recommend giving a specific algorithm for heap construction, and then asking for the program to return the input list in the order that that algorithm would produce. (So you aren't quite forcing the use of the algorithm, but simply sorting won't work.) \$\endgroup\$
    – user62131
    Apr 13 '17 at 12:45
  • 2
    \$\begingroup\$ @ais523 As an alternative to explicitly rule out some results I think we could just restrict the worst case runtime to O(n), that way just sorting would not be possible anymore. \$\endgroup\$
    – flawr
    Apr 13 '17 at 13:05
  • 1
    \$\begingroup\$ In which case you would add the restricted-complexity tag. \$\endgroup\$
    – mbomb007
    Apr 13 '17 at 15:35
1
\$\begingroup\$

Irreducible Polynomials over a Finite Field

Given a polynomial whose coefficients are in a finite field, deduce whether or not it is irreducible, without using any related built-ins (you can use a built-in that represents polynomials, but you cannot use built-ins for factoring or otherwise finding information about the polynomial).

A polynomial in F[x] (where F is a field) is considered irreducible if it cannot be factored into the product of non-constant polynomials.

I/O:

Your program/function will take two inputs:

  • a prime number for the order of the Finite Field
  • some representation for the polynomial

Output a truthy value if the polynomial is irreducible, and a falsy value otherwise.

Test Cases

Your program must run in a reasonable time for this (i.e. 1 hour is definitely too long):

>>> F = 2, f(x) = x^3 + x^2 + x + 1
false
>>> F = 5, f(x) = x^4 + 4x^3 + 4x^2 + x
false
>>> F = 2, f(x) = x^4 + x + 1
true
>>> F = 5, f(x) = x^3 + x + 1
true
>>> F = 5, f(x) = x^6 + 2x^4 + 2x^3 + x^2 + 2x + 1
false
>>> F = 2, f(x) = x^6 + x^2 + 1
false
>>> F = 5, f(x) = 4x^4
false

Meta Note:

These are all really related:

The first especially. This challenge is very similar to the first, except that the first is for irreducible polynomials over Z (the integers), whereas this is for irreducible polynomials over finite fields. Although the challenges are similar, I feel this is different enough to warrant a new challenge

\$\endgroup\$
5
  • \$\begingroup\$ Is the polynomial guaranteed to be monic? Is the zero polynomial irreducible? Also, are you OK with brute-force solutions that take huge amounts of time? \$\endgroup\$
    – xnor
    Oct 18 '14 at 5:20
  • \$\begingroup\$ @xnor No, the polynomial is not guaranteed to be monic, yes brute-force is okay if it runs in reasonable time for the test cases - I wrote a program that took <20 min for all but the 2nd last test case, which would take 2 days. Regarding zero polynomial, I need to do a bit of research first. \$\endgroup\$
    – Justin
    Oct 27 '14 at 5:56
  • 1
    \$\begingroup\$ Now that I almost have an answer to the polynomial factoring question I can say that the test cases can be handled by brute force in a slow language in a few seconds. It's the case over Z that allows tough performance requirements with simple test cases. \$\endgroup\$ Oct 28 '14 at 7:54
  • \$\begingroup\$ @programmer5000 No, I would still like to use this. I had forgotten about it, and I will improve it and post it to main. Thank you for reminding me about this post \$\endgroup\$
    – Justin
    Jun 11 '17 at 6:59
  • \$\begingroup\$ I feel like many people will not know what a finite field is. I think you should explain it in the post to allow people to answer without google. \$\endgroup\$ Jun 11 '17 at 19:19
1
\$\begingroup\$

stdin FPS

Count the input FPS ("F"s per second)

Task:

Read a potentially infinite text stream. While you do, display (at least once per second) your FPS, i.e. the amount the characters "f" or "F" appeared.

The FPS has to be accumulated over a time frame of five seconds, meaning you can't just print the number of Fs you've seen this second every second.

Rules:

  • Standard loopholes are banned
  • Read one character (or byte) at a time. If (and only if) your language doesn't have the ability to read characters as they appear in the input, you may read the input one line at a time.
  • The FPS display may be in any reasonable format, for example 3.54fps or 0.9224
  • You may round the resulting numbers to 2 (or more) digits after the decimal point, but no less. Displaying only integers is not allowed.
  • To display a new value, you may either:
    • clear the screen before printing a new value,
    • overwrite the existing value,
    • or seperate the values by newline characters
  • Be case-insensitive
  • In the first second, you don't have to display anything, and if you do, your value doesn't have to be accurate or meaningful.
  • Before five seconds have elapsed, you have to average over the total elapsed time since execution started.

Sandbox questions:

  • Dupes? (I don't know what to search for)
\$\endgroup\$
5
  • \$\begingroup\$ "In the first second, you don't have to display anything" and "The FPS has to be accumulated over a time frame of at least 5 seconds" are kind of conflicting. As I understand, we don't have to display anything in the first five seconds... \$\endgroup\$
    – Mr. Xcoder
    Jun 11 '17 at 11:57
  • \$\begingroup\$ @Mr.Xcoder I will clarify. What I mean is that in the first second you don't have to display anything, after the first second the amount of Fs in the first second, after the second second the average amount of Fs in the last two seconds and so on, until you reach the fifth second, after which you may choose to average only over the last five seconds. \$\endgroup\$
    – L3viathan
    Jun 11 '17 at 11:58
  • \$\begingroup\$ Also, before posting, I advice you to clarify "potentially infinite text stream"... the community will react if you do not specify how the input is specifically taken \$\endgroup\$
    – Mr. Xcoder
    Jun 11 '17 at 12:01
  • \$\begingroup\$ @Mr.Xcoder Clarified (and changed) the five seconds rule. What do you suggest regarding the "potentially infinite text stream"? Adding exceptions for memory limits, etc.? Or clarifying again that output has to occur "live"? \$\endgroup\$
    – L3viathan
    Jun 11 '17 at 12:06
  • \$\begingroup\$ Add both the specs, and wait to see if there are any other suggestion here \$\endgroup\$
    – Mr. Xcoder
    Jun 11 '17 at 12:15
1
\$\begingroup\$

Print all matching leaves

In Natural Language Processing, we sometimes interpret sentences as being context-free languages, and therefore as having a certain tree structure, also called constituency trees, or parse trees. These trees are sometimes written down in a notation that (as far as I know) stems from the Penn Treebank project:

A tree is either of:

  • (a b1 b2 b3...), with a being the tree's label (typically something like NP for "noun phrase") and bn being the same representation of it's sub-trees (all being non-terminals)

  • (a c), which a being the tree's label and c being the label of a single terminal child (a word).

Valid trees:

  • (S Hi) (Simple tree containing only one word, "Hi")
  • (A (B (C D))) (Nested tree containing only one word, "D")
  • (A (B C) (D (E F)) (G H)) (Tree containing the words "C", "F", and "H")

Invalid trees:

  • Hi (a terminal is not a tree)
  • (A B C) (terminals have no siblings)
  • ((A (B C))) (extra parantheses)
  • (A (B C))) (unbalanced parantheses)

For understanding this format better I recommend this online tool I wrote ages ago. For example, this is a visualization of the first example case:

Task:

Given a Penn-Treebank-style tree representation and a non-terminal, output the space-seperated concatenation of all leaves for every instance of this non-terminal.

Rules:

  • You may take the two inputs (tree representation and non-terminal symbol) in any of the standard ways, but always as strings. You may take them in any order.
  • The output can be a list of strings (["The dog", "a cat"]), some other kind of sequence, a (e.g.) comma-seperated string, and anything else that's reasonable
  • Both inputs are guaranteed to never be empty.
  • The tree representation input is guaranteed to contain at least one terminal symbol.
  • Single spaces may or may not exist for formatting (both the first and the second example are equally valid and both have to be accounted for), but there will always be a single space between a terminal symbol and its immediate parent (e.g. between Det and the in the first example)
  • In case you don't find any matching terminals, you may either raise an error, not output anything, or output some kind of empty sequence.
  • All node labels (terminal or not) will match /[A-Za-z0-9_-]+/.
  • Specify which output format you use
  • The shortest code (per language) wins

I/O examples

input 1                                                input 2  output
(S(NP(Det The)(N dog))(VP(V likes)(NP(Det a)(N(cat))))), NP -> "The dog", "a cat"
(NP (Det A) (AP (Adj fancy) (N car))),                   V  -> an empty sequence
(N cat),                                                 N  -> "cat"

Output format examples

  • List of strings: ["The dog", "a cat"]
  • CSV: "The dog, a cat"
  • CSV without spaces: "The dog,a cat"
\$\endgroup\$
2
  • \$\begingroup\$ I might be confused, but you state the input will be a non-terminal; is N not a terminal in the last example? Did you mean input would just be a label, non-terminal or otherwise? Would you mind qualify (nothing), and clarify the output rules: the first example is effectively a list of list, is that the expected output, or should it be a list of strings (space-delimited tokens)? \$\endgroup\$ Jun 9 '17 at 9:50
  • 1
    \$\begingroup\$ @VisualMelon N is not a terminal, cat is. (nothing) is supposed to mean "no or empty output", but I should clarify that and the output rules: Either a list of strings (["The dog", "a cat"]) or a something-seperated string ("The dog, a cat"). (nothing) would mean empty string, empty list, ... \$\endgroup\$
    – L3viathan
    Jun 9 '17 at 10:52
1
\$\begingroup\$

Least Picky Language

For this challenge, you will create a programming language that is not picky at all. That is, for any program of any length consisting of any characters in the ASCII range [32..126] and any input consisting of any characters in the same range, your program must do something without any errors. The program only has to hypothetically work for any length; that is, StackOverflowException and the like are acceptable if the input or program is too long for your new language to handle (however, I require it to work for program size up to 1024 bytes and input up to 1024 bytes).

In your programming language, no character or combination of characters can be useless (to prevent everything from being a no-op). That means that every character in the program must affect the function somehow, even if the overall function does not change. No two characters can have the same specification either.

For example, it is not allowed to have - and N both compute the negative of a number.

Note that <space> is a valid character in the program and must do something even if it is leading or trailing. Also note that you do not have to handle tabs or newlines in the program or the input.

The most upvoted answer at the end of 2017 Calendar Year (UTC December 31 23:59:59) will be accepted, and I will award a +50 bounty to my personal favorite language.

Meta

  • Duplicate?
  • Clear enough validity criteria?
\$\endgroup\$
6
  • 1
    \$\begingroup\$ I'm not sure what you expect from this... my first thought (since I only usually code-golf) is to just sum the ascii values of the input (i.e. define each char/token as adding the ascii value of the char). There is a very large space of programs that meet these criteria, and I think perhaps this is just too broad. \$\endgroup\$ Jun 14 '17 at 17:19
  • \$\begingroup\$ @VisualMelon Yes, there are many valid submissions. It's a popularity-contest so the one people like most wins. The thing you described would be valid but I doubt people would like it. \$\endgroup\$
    – user42649
    Jun 14 '17 at 17:22
  • \$\begingroup\$ Rather, but I'm wondering what we might expect people to like... there is scope to do virtually anything here (you can even define something that is picky, and just define an output for when it fails). It feels like less of a challenge to achieve something given constraints, and more a challenge to find something amusing, and wrap it up with these constraints. \$\endgroup\$ Jun 14 '17 at 17:43
  • 1
    \$\begingroup\$ @VisualMelon That is largely the challenge; popcons are hard to make nowadays so I expect this to be sandboxed for quite a while. Do you have any ideas for how I could improve the scope of valid submissions? I was thinking requiring Turing Completeness. \$\endgroup\$
    – user42649
    Jun 14 '17 at 17:46
  • \$\begingroup\$ Even if you enforce Turing completeness, someone can make a BF variant, and then define the remaining characters as 'add ascii value to output'. I'm afraid I don't really have any ideas to tighten it up, but I'll keep it in mind. \$\endgroup\$ Jun 14 '17 at 18:10
  • \$\begingroup\$ @VisualMelon I'll ask in TNB but thanks for noticing the potential issues to be fixed. \$\endgroup\$
    – user42649
    Jun 14 '17 at 18:22
1
\$\begingroup\$

Lots of Pi(e)!

For Meta:

Any tags other than , and ?

Dupe?

Any errors?

Clear enough?

Your Task:

Because everyone likes more pi, we're going to give them 999 decimal digits of it. Your program should output pi truncated (not rounded off) at 999 decimal places. For reference, here it is:

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019

Input:

None, your program may not take any input at all.

Output:

Pi truncated at 999 decimal digits.

Scoring:

This is , lowest byte count wins!

Good Luck!

\$\endgroup\$
3
  • \$\begingroup\$ Closest I could find was this, but this challenge doesn't have the slightly odd restrictions that one does. I don't think I would close it, but I would understand if someone disagreed. \$\endgroup\$ Jun 15 '17 at 0:18
  • \$\begingroup\$ Usually, we make it so that programs can assume the input is empty, not that we cannot take input. Some esolangs read all the input there is before starting execution. \$\endgroup\$
    – Okx
    Jun 15 '17 at 10:20
  • \$\begingroup\$ yes but this you are not allowed any input \$\endgroup\$
    – Foxy
    Jun 15 '17 at 10:22
1
\$\begingroup\$

Randomly capitalise half of a string

Given string s of even length as input, randomly capitalise exactly half of the letters.

  • You can assume the input will always be a positive, even length
  • You can assume the input will consist of only lowercase letters ([a-z])
  • There must be an equal probability of each letter being capitalised
  • Exactly half of the letters should be capitalised in the output.

Scoring

This is so fewest bytes in each language wins!

\$\endgroup\$
2
  • \$\begingroup\$ Will a string of length 0 ever be an input? \$\endgroup\$
    – dzaima
    Jun 15 '17 at 12:26
  • \$\begingroup\$ @dzaima no, clarified by saying length will always be positive \$\endgroup\$
    – Skidsdev
    Jun 15 '17 at 13:57
1
\$\begingroup\$

Sample the Sierpinski traingle

Inspired by this video..

Task

Your task is to implement the following method to sample a Sierpinski triangle and plot all the intermediate steps.

Method

Given three points a,b,c and some starting point x_0, for each iteration you sample one of the three points a,b,c with equal probability. You then place x_{i+1} in the middle of the edge between x_i and the sampled point. Repeating this draws the Sierpinski triangle.

Input

You'll receive the coordinates of the three starting positions through any default accepted input method. The exact format can be flexible: a matrix, a list per point [xa,ya],[xb,yb],[xc,yc], a list for x and y [xa,xb,xc],[ya,yb,yc], a flat list [xa,ya,xb,yb,xc,yc] are all allowed.

The starting point x_0 is [0,0]. You can assume [0,0] would fall within the overall shape.

Output

For each iteration, including the initial, draw a plot of all the points up to that point. There should at least be a 100ms delay between two plots. If your language does not support graphical displays, you can also write your images to a file.

Since the triangle is an infinite fractal, the program should loop forever (given infinite memory and all that jazz).

Criteria

Shortest code wins!

Example code (R)

Sierpinski <- function(p, q) {
  x11()
  par(mar = rep(0, 4))
  plot(p, q, col= "red", pch = 15, cex = 1, axes = FALSE)

  x <- 0
  y <- 0

  repeat {
    Sys.sleep(0.1)
    n <- sample(1:3, 1)
    x <- floor(x + (p[n] - x) / 2)
    y <- floor(y + (q[n] - y) / 2)
    points(x, y, pch = 15, cex = 0.5)
  }
}

enter image description here

Meta

  • Duplicate? There are a couple 'draw a sierpinski triangle' challenges, but I couldn't find any that use this method of drawing them.
  • Is the specification of the algorithm clear enough or should I add pseudocode?
  • Is the 100ms delay between iterations reasonable?
\$\endgroup\$
1
1
\$\begingroup\$

Cops & Robbers, the ultimate 1-up.

This is a cops and robbers game.

Cops

Hello, cops. you've just solved a Code Golf challenge on the stack exchange website. How wonderful. You go to post your answer, and soon after a robber comes and beats you by 1! How infuriating!

Your task:

Produce two programs.

The first program can be in any language, of any length, and cannot use default loopholes. it does one thing: Prints out a number.

The second program must use the same language as the first, must use less bytes than the first, and CAN use forbidden loopholes. The second program must print out a number which is equal to 1+ the output of your first program

post your first program and wait 7 days. If someone cracks your program within those seven days by robbing you, please edit your answer to include [cracked] in the header. If your program is not cracked, you can edit [safe] in the header.

Robbers

Hello, robbers. You're sneaky and looking for ways to win a golf, even if it's underhanded. You see that a cop has posted a golf for a decent score, and decide to take the lead from them.

Your task is to take a cop's answer, and beat it. Your program must use less bytes than the cop's answer and print out a number equal to only 1+ the cop's answer. You're program must also be in the same language as the cop's answer. You may use underhanded tricks and loopholes to solve the challenge. Once you complete this, you may post your solution and let the cop know they've been beat.

Example I Os

cop: 16
robber: 17
Correct: Yes!

cop: 16
robber: 16+1
Correct: Yes!

cop: 16
robber: 16.1
correct: NO! (alternative symbols for '+' are not allowed)

cop: 16
robber: 18-1
correct: Yes! (evals to 17)

cop: 16
robber: [234,32,54,17,45,23]
correct: NO! (output must be exact).

cop: 16
robber: "1+ the cop's answer" [OR] "a number equal to only 1+ the cop's answer"
correct: NO! (smartassery is not a loophole)

cop: 16.001
robber: 17
correct: NO! (16.001+1 <> 17)

EXCLUSIONS: you may use any underhanded trick / loophole you want, BUT your output must match the description exactly. no new line. no trailing space.

The following loopholes are still forbidden:

\$\endgroup\$
8
  • 3
    \$\begingroup\$ Open season on loopholes is a bad idea. E.g. for languages with short builtins for HTTP GET it becomes a search for the shortest URL shortener rather than a code golf. \$\endgroup\$ May 23 '17 at 7:33
  • \$\begingroup\$ @PeterTaylor howso? the robbers must use the same language as the cops, so if you don't want to have yours cracked, use a language that doesn't support GET requests (or atleast not simply). \$\endgroup\$
    – tuskiomi
    May 23 '17 at 18:34
  • 3
    \$\begingroup\$ You need to explain cops-and-robbers rules here, in case people haven't seen them before. In particular, I'm assuming that the cop posts are required to be crackable, in which case you need to mention that the cop must keep the second program secret, but reveal it when marking the post as safe. \$\endgroup\$
    – user62131
    May 24 '17 at 2:39
  • \$\begingroup\$ The Your Task bit isn't clear, I think you mean the end result of a cracked submission will have two programs but it kinda reads like the cops have to write two programs. \$\endgroup\$ May 25 '17 at 9:18
  • 4
    \$\begingroup\$ "no new line. no trailing space." Why ban trailing newlines? \$\endgroup\$ May 31 '17 at 15:09
  • \$\begingroup\$ As a robber, can output the string a number equal to only 1+ the cop's answer? \$\endgroup\$
    – user58826
    Jun 15 '17 at 15:37
  • \$\begingroup\$ @programmer5000 no, smartassery is not a loophole. \$\endgroup\$
    – tuskiomi
    Jun 15 '17 at 15:38
  • 1
    \$\begingroup\$ @tuskiomi actually, it's the most voted of them all \$\endgroup\$
    – user58826
    Jun 15 '17 at 15:50
1
\$\begingroup\$

Beat the turing test

Both you and your bot have to connect to a speed dating chatroom (details below) where you will either be paired up with another bot, or with another human. You get 30 seconds to converse with your partner before you are disconnected, and are presented with the choise of wether you think the person you spoke with is a human or not.

This process will be repeated in a round robin fashion for a maximum of 10 minutes, or until everyone has spoken with everyone. You will not be paired with your own bot.

You will be given an equal number of votes for human/robot, as you will be facing an equal number of each. Both you and your bot will be given the option to change these after the conversations.


Scoring

Robots get 2 point for fooling a robot, and 5 points for fooling a human. Humans are not awarded any points for correct guesses, but lose 2 points if they are wrong.


Rules

  • Bots may the internet aswell as external datafiles
  • Gentleman's rule: Please do not pretend to be a robot. If every human said nothing but Beep beep, I am a robot it would ruin the challenge for everyone.

Meta

This will be a one-time event on a specific date. There will be a webapp for humans and an API for bots. Until the final date there will be a sandbox site online for testing purposes. I am still undecided on the specifics of the API, and on how long the timespan between posting the challenge and running it should be.

I can also run (some) bots locally, communicating on stdin/stdout

\$\endgroup\$
5
  • 2
    \$\begingroup\$ Can't a human just accuse everyone of being a robot, thus preventing points from being gained? \$\endgroup\$
    – Neil A.
    Jun 22 '17 at 21:49
  • 1
    \$\begingroup\$ I suspect that participation in this will be very low (as it's a highly difficult task), which is a problem for a challenge that inherently has a deadline. Stack Exchange might not be the best place to run this. \$\endgroup\$
    – user62131
    Jun 23 '17 at 2:47
  • \$\begingroup\$ @NeilA. You are absolutely right. I think my new scoring system fixes that, but ultimately I rely on participants being honest to make this a fun challenge, which is why I think Stack Exchange is a good place to do this \$\endgroup\$
    – BlackCap
    Jun 23 '17 at 18:04
  • 1
    \$\begingroup\$ 1. Timezones are an issue. 2. You need to clarify the sequence. Do I have to call bot/human immediately after the conversation, or do I have all the conversations first and then call? 3. I suspect that even the recently raised 60k character limit to answers could be a problem for writing a sophisticated bot. Can answers use additional data files stored somewhere public such as github? \$\endgroup\$ Jun 23 '17 at 21:26
  • \$\begingroup\$ @PeterTaylor I think allowing you to change votes at the end would make programming bots more fun because you can compare the conversations against each other to determine humaness. Nice point \$\endgroup\$
    – BlackCap
    Jun 23 '17 at 21:55
1
\$\begingroup\$

Repetitive Primes

A repunit in any base B is a number consisting solely of 1s in that base.

Your task is to figure out if a repunit of length f N in base B is a prime number.

Rules

  • N >= 2
  • B >= 1
  • N and B may be taken in any order and in any reasonable method.
  • Output a consistent value to indicate primeness and a different consistent value to indicate compositeness.
  • Programs and functions are acceptable.
  • This is code golf, shortest code in bytes wins.
  • Standard loopholes apply

Test cases

B, N => Result

2, 7 => prime
1, 97 => prime
10, 19 => prime

9, 11 => composite
20, 10 => composite
7, 23 => composite

Meta questions

  • Dupe? Unclear? Too broad? etc.
  • Would this be a better question with a different winning criterion such as ?
  • Should I change the title?
  • Any other constructive criticisms?
\$\endgroup\$
5
  • \$\begingroup\$ I don't think fastest-code would be a good fit, code-golf should work just fine. You can also add base-conversion and decision-problem. I suggest appending "Primes" to the title. \$\endgroup\$
    – Laikoni
    Jun 23 '17 at 13:20
  • \$\begingroup\$ 1. "repunit consisting of N in base B" feels to me as though it's missing 1s, although perhaps a better phrasing would be "repunit of length N in base B". 2. Although it's easy to show that N must be 1 (which is not valid input) or prime, the test cases should still include at least one where N is composite. \$\endgroup\$ Jun 23 '17 at 17:48
  • \$\begingroup\$ @Laikoni: I agree it might be an interesting code-golf question, but I also want to see people use cool optimizations such as the length must be prime, or base 9 doesn't have any repunit primes, etc. as opposed to everyone using a base conversion followed by slow trial division. \$\endgroup\$
    – Neil A.
    Jun 23 '17 at 22:40
  • \$\begingroup\$ Slow trial division? Golfing languages will use the isPrime builtin, which probably uses BPSW or Miller-Rabin with carefully selected bases. \$\endgroup\$ Jun 24 '17 at 22:52
  • \$\begingroup\$ This is actually relatively simple to solve. You just need to check whether ((N + 1) % B) == 0 \$\endgroup\$
    – Okx
    Jun 26 '17 at 16:16
1
\$\begingroup\$

Mutation-hardening quine

Your task is to make a program that prints out its own output.

"Hey, we already have this challenge, and tons of variations of it! Why are you making another one?" you may ask, but this one is going to be one of the most difficult ones.

Your quine must be "mutation-hardened", which means the quine still must work, even after any one of its characters is duplicated in place.

For example, if you have a program:

abcd

These programs must all output abcd:

aabcd
abbcd
abccd
abcdd

(In each of those programs, a, b, c and d are each duplicated in-place, which means the duplicated character was placed directly after the original character.)

Rules:

  • Standard quine rules apply.

This is , so shortest code in bytes wins!

Meta:

  • Is this challenge too hard?
  • What other rules should I put up?
\$\endgroup\$
3
  • 2
    \$\begingroup\$ Is this even possible? \$\endgroup\$
    – Shelvacu
    Jul 1 '17 at 22:57
  • \$\begingroup\$ For hard problems, try to find at least one solution. \$\endgroup\$
    – NieDzejkob
    Jul 2 '17 at 17:50
  • 1
    \$\begingroup\$ @Shelvacu It doesn't have to be \$\endgroup\$ Jul 14 '17 at 17:21
1
\$\begingroup\$

Make a Quiz Parser

Your task is to create a program that will take an input of multiple 4-choice questions (A, B, C, D) in the format shown below, display each question (format also shown below) and its 4 answer choices, get the user's answer to each question, and, at the end of the quiz, output their score as a percentage.


The Format

Questions in input

Q<space><Insert question here>:<Insert letter of correct answer here>
<indent 1 space>A<space><answer choice text>
<indent 1 space>B<space><answer choice text>
<indent 1 space>C<space><answer choice text>
<indent 1 space>D<space><answer choice text>
<you can add a newline between questions if it makes things easier>

How to output questions

<question number>. <question>
  A. <answer choice A>
  B. <answer choice B>
  C. <answer choice C>
  D. <answer choice D>
<2 spaces before each answer letter>

How to output scores

Your score is: <score here>%

Test Case

Q What is the average airspeed velocity of an unladen swallow?:B
 A African or European?
 B 22 mph
 C I don't know that!
 D What?

If this were question number 42, it would output like this:

42. What is the average airspeed velocity of an unladen swallow?
  A. African or European?
  B. 22 mph
  C. I don't know that!
  D. What?

As usual, standard loopholes are strictly forbidden.


This is , so may the shortest code win and the best programmer prosper...

\$\endgroup\$
2
  • \$\begingroup\$ I like this challenge, but I think it could use a complete test case \$\endgroup\$ Jul 5 '17 at 18:41
  • \$\begingroup\$ @musicman523 Ok. I will use an output from fotoforensics for example. \$\endgroup\$
    – ckjbgames
    Jul 5 '17 at 18:53
1
\$\begingroup\$

The task

Your code should take in an integer 0 < x < 1965593254291461501637330902918203684832716283083 and output the smallest integer m such that x^m mod 1965593254291461501637330902918203684832716283083 = 1. This long number is the next prime after 2^100 so can be encoded efficiently.

You may take the input in any format that is convenient and output in any convenient form too.

Your code should take less then one minute to run on a standard desktop no matter what the input.

Examples

2, 4235851503548771316711413838489497242205033676
3, 16943406014195085266845655353957988968820134704
169434060141950852668456553539579889688, 16943406014195085266845655353957988968820134704

Those with python or similar can check the answers with e.g. pow(3,16943406014195085266845655353957988968820134704, 1965593254291461501637330902918203684832716283083) which equals 1.

You may not use any builtin or library function which solves this problem for you.

\$\endgroup\$
10
  • \$\begingroup\$ Is there a reason you picked that specific number? \$\endgroup\$
    – Pavel
    Jul 6 '17 at 20:07
  • \$\begingroup\$ I think that unless there's a simple formula that gets that number, hardcoding that value would take more bytes than the rest of the code. \$\endgroup\$
    – Pavel
    Jul 6 '17 at 20:07
  • \$\begingroup\$ @Phoenix I added a simple formula. \$\endgroup\$
    – user9206
    Jul 6 '17 at 20:13
  • \$\begingroup\$ I don't think it's a great idea to use nubmers that are so large that many languages require special constructs to represent them, it gives an unfair advantage to languages with arbitrary precision integers, which already tend to be shorter. \$\endgroup\$
    – Pavel
    Jul 6 '17 at 20:19
  • \$\begingroup\$ @Phoenix I take your point but the point of this challenge is to devise efficient code for large inputs. Languages with builtin large number support tend to be quite slow (e.g. python) compared to e.g. C. I would like to leave it like this. \$\endgroup\$
    – user9206
    Jul 6 '17 at 20:22
  • \$\begingroup\$ Is there an efficient way to find the multiplicative order modulo a prime of a number, short of factoring p-1? \$\endgroup\$
    – xnor
    Jul 7 '17 at 4:59
  • \$\begingroup\$ @xnor, none known. \$\endgroup\$ Jul 7 '17 at 7:35
  • \$\begingroup\$ @PeterTaylor Is 100 bits too big to factorize without calling library code to do it for you? Or could the question allow you to factorize the number beforehand? (Wolfram alpha will do that for free for example for the number in my question minus 1.) \$\endgroup\$
    – user9206
    Jul 7 '17 at 7:52
  • \$\begingroup\$ @PeterTaylor I am just wondering how much I need to reduce the number by. Currently it is 160 bits. \$\endgroup\$
    – user9206
    Jul 7 '17 at 8:37
  • \$\begingroup\$ @PeterTaylor Actually even the command line tool factor can handle the 160 bit number it turns out \$\endgroup\$
    – user9206
    Jul 7 '17 at 8:52
1
\$\begingroup\$

ASCII Art Turtle

As you know, the LOGO programming language allows you to manoeuvre a turtle and draw lines in a graphical way. It occurs to me that we can do this for .

A minimal set of commands to produce would be the R(otate right), F(orward) and P(en) commands. For example, the string FPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPF would produce the following output:

\|/
- -
/|\

However that AAT code is rather inconvenient so I have chosen the following slightly more compact instruction set:

  • F Move one cell in the current direction. Initially the current direction is east. If the pen is down, the cell just vacated is set to one of -/|\ appropriately.
  • B Move one cell in the reverse direction. (Initially this would be west, of course.) The cell vacated is set in the same way as for F (since the output characters are all symmetric).
  • R Rotate right 45°. Only the current direction changes; nothing is drawn and the current position does not move.
  • L Rotate left 45°. Otherwise as per R.
  • D Lower the pen. Note that the pen starts lowered.
  • U Raise the pen.

The above image could therefore be drawn using the command string BULFDBULFDBULFDBULFDBULFDBULFDBULFDB, while the string LFFUBRFDFFFFFFFFFFFFFFFFFRFFRFBRRFFFFFFFFFFFFFFFFFFFFFUBLLFDFFBLLFFFFFFFFFFFFFFFFFFFFFUBRRFDFRRFFFFFFFFFFFFFFFFFFFFFURBDBBUFLBDBBBBBBBBBLLFFFURBDBBBUFRBDBBBLBB should hopefully produce this somewhat familiar picture:

 /-----------------\ 
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\                   /
 \---------|  /----/ 
           | /       
           |/        

Your function or program must take input as a string, or whatever the nearest equivalent is in your language, and output a newline-delimited or newline-terminated string. (For those of you used to using TIO it should be possible to paste the raw string into the ▼ Input field and show the output directly in the ▼ Output field.) Extra blank rows or columns are not allowed, but you are allowed to pad all the lines to the length of the longest non-blank line. You can take input in lower or mixed case if you prefer. You can assume that the input will only use those six letters. You can further assume that U and D commands alternate. You can also assume that you will never write in the same place twice.

This is , so the shortest program that breaks no standard loopholes wins!

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

Escape the Labyrinth!


Introduction

You are stuck in a labyrinth. You only have your brain and a map. Now you need to find a way out, of course your brain doesn't have much memory (or else you wouldn't be stuck!) so you need to optimize your mental code for size. Of course we can't trivially program in the brain-language, so your brain will also accept any other language.

Specification

Input

Your input will be a Matrix. You may encode it however serves your language best as long as the format doesn't encode additional information. For the purpose of this challenge I will use a list of lists for representation and explanation.

Said matrix will contain four distinct values:

  • 0: This marks a spot you can move onto
  • 1: This marks a wall
  • 2: This marks the starting point
  • 3: This marks the target point

It is guaranteed that there will be exactly one occurence of type-3 and type-2. You may also change the above values / data-types to your liking as long as you don't encode additional information.

It is guaranteed that you will get an input that has a solution. If the input doesn't have a valid solution, the behavior is left undefined. Your program may not terminate, it may error out, it may simply return nothing, it may blow up, it may become a political activist or it may do something else.

You may assume that the input labyrinth is walled-off, that is you can't actually "leave" the labyrinth.

Output

Your output will be sequence of four different values:

  1. L: Stands for left
  2. R: Stands for right
  3. U: Stands for Up
  4. D: Stands for Down

You may change the values and data types of the above constants to your liking, as long as you document these changes and you can uniquely infer the path.

What to do?

Given the labyrinth, start your virtual character at the position tagged 2 and find a way to the position tagged 3. You may not pass through walls (1 cells) and you may only go one step up, left, right or down in each step. You also need to document your action of course in each step, ie output it as described above.

Note: You do not have to find the shortest path, but rather a path.

Who wins?

This is , so the shortest solution in bytes wins! Standard loophole rules apply of course. Standard I/O rules also apply.

Example

[ 
[1,1,1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1,1,1],
[1,2,0,1,0,1,1,0,1,1],
[1,1,0,1,0,0,0,0,1,1],
[1,1,0,0,0,1,1,1,1,1],
[1,1,1,0,1,1,0,0,1,1],
[1,1,0,0,1,0,0,0,1,1],
[1,1,1,0,0,0,1,0,1,1],
[1,1,1,1,1,1,1,3,1,1],
[1,1,1,1,1,1,1,1,1,1] 
]

might result in:

Going right.
Going down.
Going down.
Going right.
Going down.
Going down.
Going down.
Going right.
Going right.
Going up.
Going right.
Going right.
Going down.
Going down.
\$\endgroup\$
3
  • \$\begingroup\$ Potential questions: What other tags to use? Should it be allowed to receive position information of 2 and 3 in the input as well? \$\endgroup\$
    – SEJPM
    Jul 7 '17 at 20:15
  • 1
    \$\begingroup\$ I'd be very surprised if this wasn't a duplicate. I'm stuck on mobile for quite a while, but My car only turns right is very similar except you have to manage orientation. I'd look closely at other maze challenges to see that this adds to the site. \$\endgroup\$ Jul 9 '17 at 21:33
  • \$\begingroup\$ I agree with FryAmTheEggman. This is very likely a dupe. \$\endgroup\$
    – Gryphon
    Jul 9 '17 at 23:50
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 '17 at 14:04
  • 1
    \$\begingroup\$ I think this might be an interesting question. \$\endgroup\$ Jul 10 '17 at 22:14
  • \$\begingroup\$ Last test case -> 10 (or all the other cases ->+1) \$\endgroup\$
    – ZaMoC
    Jul 10 '17 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 '17 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 '17 at 16:18
  • \$\begingroup\$ @socraticPhoenix Good point, I've edited the post. Is it clearer now? \$\endgroup\$
    – Oki
    Jul 10 '17 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 '17 at 7:35
  • \$\begingroup\$ Note also that long multiplication has been done \$\endgroup\$ Jul 11 '17 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 '17 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 '17 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 '17 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 '17 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 '17 at 17:51
  • \$\begingroup\$ any other unique characters or numbers? \$\endgroup\$
    – Adám
    Jul 12 '17 at 17:53
  • \$\begingroup\$ @Adám hmm... unique values i guess... I'll update it now \$\endgroup\$ Jul 12 '17 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 '17 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 '17 at 8:16
  • \$\begingroup\$ @xnor Interesting. In that case, there should be no specific upper limit, right? \$\endgroup\$
    – Adám
    Jul 13 '17 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 '17 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 '17 at 8:18
  • \$\begingroup\$ @xnor How is this? \$\endgroup\$
    – Adám
    Jul 13 '17 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 '17 at 8:32
  • \$\begingroup\$ @xnor Uh, did you read the post? \$\endgroup\$
    – Adám
    Jul 13 '17 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 '17 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 '17 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 '17 at 19:57
  • 1
    \$\begingroup\$ The original challenge with letters was way better... \$\endgroup\$
    – ZaMoC
    Jul 14 '17 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 '17 at 13:17
  • \$\begingroup\$ @Jenny_mathy Like this? \$\endgroup\$
    – Adám
    Jul 14 '17 at 14:22
  • \$\begingroup\$ @Zacharý Ping ^ \$\endgroup\$
    – Adám
    Jul 14 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 at 14:05
  • \$\begingroup\$ 3 cards each times 17 players leaves 1 card in the deck. \$\endgroup\$ Jul 18 '17 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 '17 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 '17 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 '17 at 22:31
  • \$\begingroup\$ @musicman523 Yeah, it'd probably be played on an 8x8 \$\endgroup\$ Jul 23 '17 at 22:35
  • 1
    \$\begingroup\$ you forgot that pawns are partially nuke proof \$\endgroup\$ Jul 23 '17 at 23:15
  • \$\begingroup\$ @DestructibleLemon Please elaborate ? I wasn't aware there was some standard rulebook. \$\endgroup\$ Jul 24 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 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 '17 at 17:06
  • \$\begingroup\$ Yeah you're right, didn't know these existed. \$\endgroup\$ Jul 26 '17 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\$
    – trichoplax
    Jul 25 '17 at 23:01
  • \$\begingroup\$ If only a single symbol can be to the left for subtraction, how are ambiguous cases like IXL resolved? \$\endgroup\$
    – trichoplax
    Jul 25 '17 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\$
    – trichoplax
    Jul 25 '17 at 23:03
1
43 44
45
46 47
117

You must log in to answer this question.

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