459
\$\begingroup\$

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

\$\endgroup\$
  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43
  • \$\begingroup\$ I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . \$\endgroup\$ – AZTECCO Oct 5 at 19:39

2571 Answers 2571

0
\$\begingroup\$

List My Factors!


Introduction

Given an algebraic expression as input, list all the factors of it. A factor of an algebraic expression is any algebraic expression (or simply a numerical expression, sometimes) that evenly divides it. A factor can only be an integer or an algebraic expression consisting of integers and variables.


Rules

  • The algebraic expression will contain * to denote multiplication.

  • The algebraic expression will only contain integer constants and coefficients.

  • The algebraic expression will contain ^ to denote exponentiation.

  • The algebraic expression will only contain positive constants, coefficients and variables.

  • Your program should output only the positive factors.

  • The algebraic expression will not contain negative exponents.

  • You must not use any built-in to accomplish this.

  • Standard Loopholes apply.


Examples

The algebraic expression 5*x^2 has the following factors:

  1. 5
  2. x
  3. x^2
  4. 5*x^2
  5. 5*x
  6. 1

The algebraic expression 10*(x-y)^2 has the following factors:

  1. 10
  2. 5
  3. 2
  4. 1
  5. (x-y)
  6. (x-y)^2 or x^2 + y^2 - 2*x*y
  7. 2*(x-y)^2 or 2*(x^2 + y^2 - 2*x*y) or 2*x^2 + 2*y^2 - 4*x*y
  8. 5*(x-y)^2 or 5*(x^2 + y^2 - 2*x*y) or 5*x^2 + 5*y^2 - 10*x*y
  9. 10*(x-y)^2 or 10*(x^2 + y^2 - 2*x*y) or 10*x^2 + 10*y^2 - 20*x*y.
  10. 10*(x-y) or 10*x - 10*y
  11. 2*(x-y) or 2*x - 2*y
  12. 5*(x-y) or 5*x - 5*y

The algebraic expression x^2 - y^2 has the following factors:

  1. 1
  2. x-y
  3. x+y
  4. x^2 - y^2

Input

Your program may take the input in any way except assuming it to be present in a predefined variable. Reading from file, input box, modal window, command line etc. is allowed. Taking input as function argument is allowed as well.


Output

Your program should output a list of factors of the given input as a collection data type (such as array) or as a separator-separated String.

Your program may output in any way except writing the output to a variable. Writing to file, screen, modal window, command line etc. is allowed. Outputting using function return is allowed as well.


Test Cases

Input               Output

5*x^2               [5*x^2, 5, 1, 5*x, x, x^2]
10*x^2              [10*x^2, 10, 5, 2, 1, 10*x, 5*x, 2*x, x, 5*x^2, 2*x^2, x^2]
10*(x-y)^2          [10*(x-y)^2, 10, 2, 5, 1, 10*(x-y), 5*(x-y), 2*(x-y), (x-y), (x-y)^2, 2*(x-y)^2, 5*(x-y)^2]
x^2 - y^2           [x^2 - y^2, x+y, x-y, 1]

Winning Criterion

This is , so the shortest code in bytes wins!


Sandbox

  1. Should I allow negative constants and coefficients? Answer : No
  2. Should I allow variable exponents?
  3. Is there any mistake in Examples and Test Cases?
  4. How long should I let this challenge be here?
  5. Any problem with the Input/Output Rules?
  6. Should I allow built-in to accomplish the task?
  7. Any other suggestion?
\$\endgroup\$
  • \$\begingroup\$ Would x^2-y^2 be a valid input? \$\endgroup\$ – Leaky Nun Jun 22 '17 at 9:56
  • \$\begingroup\$ @LeakyNun Yes . \$\endgroup\$ – Arjun Jun 22 '17 at 9:57
  • \$\begingroup\$ What would the expected output be? \$\endgroup\$ – Leaky Nun Jun 22 '17 at 9:57
  • \$\begingroup\$ The rules should mention that addition and subtraction are allowed; they currently don't. I'm wondering whether this challenge would be more interesting if you had to find the decomposition into "prime" (i.e. irreducible) factors, rather than just all factors, though; the two are similar tasks but the latter is more interesting and easier to read the results of. As for question 4, just leave the challenge up indefinitely; time limits on challenges are a bad idea if they're at all avoidable, as many people enjoy solving older challenges. \$\endgroup\$ – user62131 Jun 22 '17 at 10:01
  • \$\begingroup\$ @LeakyNun 1, x-y, x+y, x^2-y^2 \$\endgroup\$ – Arjun Jun 22 '17 at 10:07
  • \$\begingroup\$ It seems this challenge is more about parsing/pretty printing than about factoring. (The integers allow for brute forcing.) I'd recommend allowing for more flexible input and output, otherwise this is going to be trivial to write a competitive submission for some languanges with CAS but almost impossible for other languages. \$\endgroup\$ – flawr Jun 22 '17 at 10:09
  • \$\begingroup\$ @ais523 I've added what LeakyNun asked to the challenge. Better? \$\endgroup\$ – Arjun Jun 22 '17 at 10:13
  • \$\begingroup\$ @flawr I don't understand what you mean with your first comment. To your second point : Good point, I'll edit \$\endgroup\$ – Arjun Jun 22 '17 at 10:14
  • \$\begingroup\$ @flawr Edited . \$\endgroup\$ – Arjun Jun 22 '17 at 10:22
  • 1
    \$\begingroup\$ 1. The examples now contradict the spec's limitations on input. 2. What is a positive factor? Is it a factor with only positive coefficients? 3. What are the factors of x^x? 4. If this is fundamentally "factor a multivariate polynomial", I think there may be one or two questions along those lines already in the sandbox. The univariate case has been done on main. \$\endgroup\$ – Peter Taylor Jun 22 '17 at 11:52
  • \$\begingroup\$ Before I forget, a nice (or nasty) illustration of the relevance of my question 2: x^3 + x^2 + 2x + 8 = (x + 2)(x^2 - x + 4). \$\endgroup\$ – Peter Taylor Jun 22 '17 at 16:19
0
\$\begingroup\$

Rotational Anagrams

Given, for lack of a better word, an anagram cube c with n rings and a word w, output whether or not you can rotate the individual sections to make w appear across the middle.

Constraints

  • The letters that can appear are all printable ASCII characters EXCEPT for newlines.
    • All three characters that make up the rings can appear (|-+).
  • Your program should work for cubes of any size, though the maximum I expect you to test is my biggest case (this means that if your code won't finish for n=22 on TIO, I don't care).
  • Your only input should be the ASCII-art c and the word w.
  • Your only output is one of two distinct values for true/false, which are arbitrary.
  • You can assume the input is well-formed, and output anything for bad input.

Examples

Example cube with n=3 and w='AXMOZC':

+----A----+
| +--Y--+ |
| | +N+ | |
B X M O Z D
| | +P+ | |
| +--W--+ |
+----C----+

Rotate the outer wheel once coutner clockwise:

+----D----+
| +--Y--+ |
| | +N+ | |
A X M O Z C
| | +P+ | |
| +--W--+ |
+----B----+

Ding-ding! A match, so we can output truthy for this, but for AXMOYC there is no rotation that allows that combination, so it would return falsy. (X and Y are not adjacent on the ring, which means they can't appear at the same time.


Here's a small cube of n=2:

+--G--+
| +P+ |
P C P G
| +C+ |
+--P--+

For an input w=PPCG|GPCP|PCPG|GCPP this returns true, everything else is false. So you can start to see that the possible keyspace of answers is always n**2, so... hint hint.


Here's the big honkin' example that took me a minute to piece up.

+----------1----------+
| +--------O--------+ |
| | +------5------+ | |
| | | +----E----+ | | |
| | | | +-----+ | | | |
| | | | | +G+ | | | | |
C 3 D E - B O L L I 4 G
| | | | | +O+ | | | | |
| | | | +--W--+ | | | |
| | | +----F----+ | | |
| | +------6------+ | |
| +--------N--------+ |
+----------2----------+

And, amongst many other strings, for w=CODE-GOLFING|CODE-BOWLING you should return true.


This is , if you're on my front lawn the third Tuesday of next month in a batman costume doing unspeakable things to my sprinkler system, you've won.

\$\endgroup\$
  • \$\begingroup\$ Is this meant to be a challenge about parsing the input format? If so (and it seems to be), you probably want parsing. Also, is there a need to verify the format, or can programs assume it's correct? \$\endgroup\$ – user62131 Jun 22 '17 at 10:52
  • \$\begingroup\$ @ais523 I feel like there's enoguh challenge in the parsing, and that will allow some unique interesting choices to extrapolate out the wanted symbols. You don't have to handle invalid input. \$\endgroup\$ – Magic Octopus Urn Jun 22 '17 at 13:39
0
\$\begingroup\$

Home on the Range

Challenge

Given a range [0,n) that has been shuffled, return the index of each element of the range.

Examples

[1, 2, 0] -> [2, 0, 1]

This is the range [0, 3) after being shuffled. The element at index 0 in the result is 2 because, in the input, 0 is at index 2. Likewise, the 0 in the output is the index of the 1 in the input, and the 1 is the index of 2.

[1, 0, 2] -> [1, 0, 2]
[0, 1, 2, 3] -> [0, 1, 2, 3]
[0, 2, 1, 3] -> [0, 2, 1, 3]
[2, 0, 1, 3] -> [1, 2, 0, 3]
[3, 2, 0, 1] -> [2, 3, 1, 0]
[4, 3, 2, 0, 1] -> [3, 4, 2, 1, 0]
[1, 2, 4, 0, 3] -> [3, 0, 1, 4, 2]
[2, 4, 0, 3, 1] -> [2, 4, 0, 3, 1]

Bonus

I will award a +100 bounty to the first person to design and explain an algorithm that solves this problem using O(n) time and O(1) space.

Sandbox

  • I think my explanation was rather poor. How can I make this more clear?
  • Is this a dupe?
  • Is the bonus a good idea? (I really want to hear the answer because I don't know if this is even possible!)
\$\endgroup\$
  • \$\begingroup\$ Why [4, 3, 2, 0, 1] -> [3, 4, 1, 2, 0] not -> [3, 4, 2, 1, 0]? \$\endgroup\$ – Leaky Nun Jun 22 '17 at 14:25
  • \$\begingroup\$ Oh, and do realize that this is what /: in J does, which makes this a 2-byte solution. \$\endgroup\$ – Leaky Nun Jun 22 '17 at 14:25
  • 1
    \$\begingroup\$ @LeakyNun Oh, well that sucks /: \$\endgroup\$ – HyperNeutrino Jun 22 '17 at 14:27
  • \$\begingroup\$ @LeakyNun Typo. Thanks! I've never used J so I didn't realize there would be a builtin for it /: maybe I could convert this into a "best-algorithm" question? \$\endgroup\$ – musicman523 Jun 22 '17 at 14:30
  • \$\begingroup\$ Essentially codegolf.stackexchange.com/q/95838/194 ? \$\endgroup\$ – Peter Taylor Jun 22 '17 at 14:48
  • \$\begingroup\$ @PeterTaylor Yes, essentially. And I think it's a one-byte solution in Jelly: . \$\endgroup\$ – musicman523 Jun 22 '17 at 15:09
  • \$\begingroup\$ @musicman523 And it is a one-byter in Dyalog APL as well \$\endgroup\$ – Kritixi Lithos Jun 22 '17 at 15:38
  • \$\begingroup\$ I could do one of three things: post it anyway to allow non-golfing languages to compete, make it a best-algorithm question instead, or delete it entirely. What do you all think? \$\endgroup\$ – musicman523 Jun 22 '17 at 16:10
  • 1
    \$\begingroup\$ I think that a) there's very little point in posting something which will be closed as a dupe; b) best-algorithm is hard to judge when built-ins do the job for you but their implementation might be closed or vary between versions; c) the bonus is pretty trivial provided that you specify that the code should modify the supplied array, and impossible otherwise. \$\endgroup\$ – Peter Taylor Jun 22 '17 at 16:17
  • \$\begingroup\$ @PeterTaylor how can you do it, modifying the original array? \$\endgroup\$ – musicman523 Jun 22 '17 at 17:35
  • \$\begingroup\$ Cycle by cycle, using ~ (bitwise not) as a flag to indicate which cycles have already been visited. \$\endgroup\$ – Peter Taylor Jun 22 '17 at 17:55
  • \$\begingroup\$ What happens if the entire array is a cycle? How do you process it with O(1) memory? \$\endgroup\$ – musicman523 Jun 22 '17 at 18:09
  • \$\begingroup\$ Bounty for O(n) time and O(1) space? But... but it's code golf. \$\endgroup\$ – Neil A. Jun 22 '17 at 21:54
  • \$\begingroup\$ @NeilA. don't worry this isn't going to be posted, at least not as-is \$\endgroup\$ – musicman523 Jun 22 '17 at 22:37
0
\$\begingroup\$

Find the maximum number of coprimes in a set

Inspired by a recent question on Math.stackexchange.com, which I can't find anymore.

The challenge

Exactly what it says on the tin. You are given a set of integers and you have to create a program (according to the default definitions on meta) that outputs the size of the biggest subset that shares no divisors except for 1.

Input

A set of nonzero positive integers of length >= 2. You can take this input as per the defaults in meta.

Output

Output, print or return the size of the subset of the input that does not share any divisors except for one.

Testcases

1 2 3 4 5 6 7 8 9 10 11 12 13 14
7

1 3
1

2 3 5 7 9
4

2 3 5 7 11 13
6
\$\endgroup\$
  • \$\begingroup\$ 1. The second test case is wrong: it should give 2. 2. What does it mean for a subset to share a divisor? Perhaps "the biggest subset such that no two of its elements share a divisor greater than 1". 3. In all of the test cases, it suffices to count the elements which are either 1 or prime. The question needs test cases for which that isn't sufficient. It might be nice to encode some classic graphs like Petersen's. \$\endgroup\$ – Peter Taylor Jun 22 '17 at 22:08
0
\$\begingroup\$

Golf a program whose behavior is independent from Peano arithmetic

Your task is to write a program that doesn't take any input, and whose termination cannot be proved or disproved inside Peano arithmetic. This is , so the shortest byte count wins!

Rules

  • Standard loopholes apply
  • Shortest by count wins
  • You can assume that your program runs in a machine with an unlimited amount of memory.

Tags


Questions for meta

  • Is this a good challenge?
  • Is it a duplicate?
  • I think the same question with a behavior independent of ZF set theory might be interesting as well (see this link for instance), but will attract very different answers; should I post it as a separate challenge?
  • What can be improved? Are the tags ok?
\$\endgroup\$
  • \$\begingroup\$ Current sandbox post that's fairly close to this one. There might be two challenges in this space, but maybe just one; perhaps you could give feedback on the other post? \$\endgroup\$ – user62131 Jun 23 '17 at 2:45
  • \$\begingroup\$ It seems like the other sandbox post is pretty limited to Turing machines only, whereas this one allows any programming language, so I think the two will attract quite different answers. Secondly, I believe restricting to Peano arithmetic instead of ZF will make solutions that are simpler, so I believe the two challenges are still quite different (but I'd like input from others on this as well). \$\endgroup\$ – nore Jun 23 '17 at 3:06
  • 2
    \$\begingroup\$ Is this the same as this challenge? \$\endgroup\$ – xnor Jun 23 '17 at 7:10
  • \$\begingroup\$ @xnor it is the same indeed, so I guess I should instead go for independent of ZF. This makes it closer to the other sandbox proposal, but I still think allowing any programming language makes the challenge quite different from a Turing machine-only one. \$\endgroup\$ – nore Jun 23 '17 at 13:25
  • \$\begingroup\$ See also: codegolf.stackexchange.com/search?q=aaronson \$\endgroup\$ – Peter Taylor Jun 23 '17 at 21:33
  • \$\begingroup\$ If a program’s behavior is independent of ZF or ZFC, it’s also independent of PA, so I’d be happy to see such programs posted on the existing challenge, unless it starts getting so many answers that they get drowned out (current trends suggest that’s unlikely ☹). \$\endgroup\$ – Anders Kaseorg Jun 24 '17 at 6:49
  • \$\begingroup\$ @AndersKaseorg true, it looks like people are not that interested in this kind of challenges :( The point for having two separate challenges was because ZF/ZFC-independent answers might be a lot more complicated than PA ones. \$\endgroup\$ – nore Jun 24 '17 at 14:28
  • \$\begingroup\$ @nore Do you know of any simple answers to the PA challenge? I don’t think my PA answer is notably simpler than a ZFC version would be. \$\endgroup\$ – Anders Kaseorg Jun 24 '17 at 20:52
  • \$\begingroup\$ @AndersKaseorg I tried to find statements that are easy to check and that are independent of PA, but the simplest I have been able to find is still the ZF-independent one used in the busy beaver paper. \$\endgroup\$ – nore Jun 25 '17 at 2:18
0
\$\begingroup\$

Iterate over all sets

(This question needs fixing so that the output size is not too large)

Consider all possible pairs of sets of integers (can have positive, negative and zero values) A and B such that |A| = |B| = 7. Define the set T_{A,B} = {a * b | a in A, B in B}.

The challenge is to iterate over all pairs of sets A and B so that |T_{A,B}| < 19 and the largest absolute value of an integer in A or B is at most 128. As an example of one such pair of sets, A = B = {2^i | for i in {1,...,7}}.

What should my code output?

Your code should output the pairs of sets A, B along with |T_{A,B}|.

For example:

A = {2,4,8,16,32,64,128}, B = {2,4,8,16,32,64,128}, |T_{A,B}| = 13.

Running time

I don't care how long your code takes to run except you must run your answer to completion before posting an answer.

\$\endgroup\$
0
\$\begingroup\$

Code golf the Fast growing hierarchy (fgh)

if your not familiar with the fgh you migth want to check out this explantion: Large Numbers, Part 3: Functions and Ordinals

and these value aproximations: Fast growing hierarchy Approximations

the goal this code golf is to golf the following functions:

  • the exact value of fω(x) this means you can't golf the ackermann function

  • the growth rate of fω2(x)

  • the growth rate of fω2(x)

In any language of your chose.

This is a code golf so the smallest program that defines each of these functions wins (Note:the functions are allowed to call each other).

It is also allowed to ask for an input x and output the 3 function values in any order.

Tags

,,,

Sandbox notes

I'm not sure on which functions should be the target but these functions seem challenging yet golf-able in less than 150 bytes.

Upon closer inspection I realized that fω2(x) is probably to easy since it can be golfed with something like:

f(x,a...) {
    for i in range(a.length) {
        if(a[i] != 0) { //first non zero
            Arrays.fill(a, 0, i, x); //replace 0's with x
            a[i]--; //decrement a[i]
            return f^x(x,a);
        }
    }
    //all zeros
    return x+1;
}

f(x,n) > fn(x)

f(x,0,n) > fωn(x)

f(x,0,0,n) > fω^n(x)

so f(x,0,...,0,x) (x zeros) ~= fε0(x)

Any other tags? Suggestions? Does this interest you?

\$\endgroup\$
  • \$\begingroup\$ Having three winners doesn't really work. But having three separate questions is probably not the right solution either: they're close enough to be borderline dupes of each other. Perhaps the best way would be to score for the total length of the three functions, allowing the faster ones to call the slower ones but at the cost of having to name them. That might make for some interesting tradeoffs between using the functions directly vs having one function for f_{w^2 a + wb} which the others call with different values of a and b. \$\endgroup\$ – Peter Taylor Jun 23 '17 at 21:23
  • \$\begingroup\$ @PeterTaylor good suggestion, I changed the win condition. But I realized those a probably not the right functions since w² can be golfed really easily. \$\endgroup\$ – fejfo Jun 24 '17 at 7:47
  • \$\begingroup\$ Why not do exact values? \$\endgroup\$ – Simply Beautiful Art Nov 24 '17 at 20:51
  • \$\begingroup\$ Your solution for f_{ω^2} is very sub-optimal. See my answer. \$\endgroup\$ – Simply Beautiful Art Nov 24 '17 at 20:53
0
\$\begingroup\$

Just One More Time

Challenge

Write a program or function that will run without error once, but will crash when run for the second time.

If you are writing a function, you may assume the function will be run twice within the same interpreter session or program.

If you are writing a program, you may assume the machine will not be rebooted between runs.

Scoring

This is , so the shortest answer in each language wins.

\$\endgroup\$
  • \$\begingroup\$ I feel like the function version is much easier than the program version so I don't think you will see many programs in languages that could do both. Take C: i=1;f(){return 1/i--;}. I don't think you could reasonably ban "global" values to prevent this, but it's up to you if you even think this is a bad thing. \$\endgroup\$ – FryAmTheEggman Jun 27 '17 at 1:10
  • \$\begingroup\$ Will it run a third time? \$\endgroup\$ – Okx Jun 27 '17 at 10:16
  • \$\begingroup\$ @FryAmTheEggman The answer you gave is exactly the type I would be looking for \$\endgroup\$ – musicman523 Jun 27 '17 at 15:01
  • \$\begingroup\$ @Okx It would not be run a third time. For functions, the assumption is that the crash would kill the interpreter session/program. For programs, I just won't run it a third time. \$\endgroup\$ – musicman523 Jun 27 '17 at 15:02
0
\$\begingroup\$

Texas Koth'em Poker

Texas Hold'em Poker is a form of poker, where each player is given 2 cards just for them and between 3 and 5 cards on the table that anyone can use. You aim to get the best hand that you can with the cards available to you.

The hand rankings are as follows (1 is the worst, 10 is the best)

1.  Junk (This is when none of your cards fit in any other category. High card wins)
2.  1 pair (Where 2 of your cards are the same number (5/Ace/King))
3.  2 pair (Kinda obvious)
4.  Three of a Kind (Where 3 of your cards are the same number)
5.  Straight (Where your cards go in order, not all in one suit (5,6,7,8,9))
6.  Flush (Where all your cards are the same suit)
7.  Full House (Where you have 1 pair and 1 three of a kind)
8.  Four of a kind (Where you have all 4 of a single number)
9.  Straight Flush (A straight when all the cards are the same suit)
10. Royal Flush (A flush where your cards are 10, Jack, Queen, King, Ace)

This version of Hold'em will contain betting, with it being the winning criteria. Each player will begin with £1000 which means that they will be £1000 * num_of_players up for grabs.

Your task is to submit a Python function that, when run, will return one of your choice detailed below per hand

"Fold" : This means that you are out of this hand and cannot win any chips in this hand
"Check" : This is where you bet the current bet into the betting pool.
"Raise<number>" : This raises the current bet to <number>. You also have to pay this.

The bet always begins at 1 and increases throughout the round.

We will also introduce the Blind. This is someone who must bet, as to not have anyone folding all the time. The Blind rotates through the players, with the first person being randomly chosen. As in for Players A, B and C, let's say that B starts. The next round, C would be the blind, then A then back to B.

Your function should look something like this

def <name_of_bot>(hand: list, table: list, bet: int, chips: int, blind:bool, other_players:dict):
    <your code here>
    return <option>

other_players looks somewhat like this

{
    'player1':[chips,last_action],
    'player2':[chips,last_action],
    'player3':[chips,last_action],
}

As everything is sort of spread out everywhere, this is the game play in 1 wall-of-text paragraph.

Game of Play

The game is made up of several rounds, each of which has a betting pool where the money goes, and each of which ends with a single winner, who collects all the chips in the betting pool. At the start of a round, the deck is shuffled and each player is dealt 2 cards. 3 cards are then placed on the table.

Each round is made up of several hands. Each hand consists of each player making a choice: fold, check or raise (detailed above). A player's cards (the ones only they can use) remain constant. The cards on the table can be added to twice. Using your 2 cards and 3 of the cards on the table, you aim to make the highest hand you can.

Cards

Cards are denoted by 2 character codes, one for number and one for suit.

  • 2 through 9 are simply their numbers.
  • 10 => T
  • Jack, Queen, King and Ace become the first letter of their names (J,Q,K,A)

  • Spades => S

  • Hearts => H
  • Diamonds => D
  • Clubs => C

Let's look at an example!

Players: Bob   ,  Jim  , Steve and Gary
Cards  : 2S 5S , AC 7C , 3H TC and 6S 7D
Table  : 9D 8C JH
Blind  : Jim

Round 1
  Hand 1
    No-one has a good hand. Jim puts in 1. Gary puts in 1. Other two fold. 
    Bet = 1. Pot = 2
    New card on table: TH
  Hand 2
    Jim still has junk, but is hopeful and thinks he could get 1 pair. He puts in 1.
    Gary has a straight (6,7,8,9,T) and raises. He puts 2 in.
    Bet = 2. Pot = 5
    New card on table: AH
  Hand 3
    Jim has the pair he wanted and matches Gary. He puts 2 in
    Gary, convinced he can win this, raises the bet to 3.
    Bet = 3. Pot = 10
    No card on table as there are already 5 (the max)
  Hand 4
    This is a betting hand. Gary and Jim bet against each other to see who wins.
    Jim, thinking he will lose, checks.
    Gary, knowing he's won this, checks.
    Bet = 3. Pot = 16
    The players show their cards. Gary wins and get the pot.
  Cards are shuffled and re dealt
Round 2
Bet = 1. Pot = 0

Rules

  • You may not copy or use the same algorithm from another answer, intentionally or not.
  • Your bot shouldn't rely on any other bots to work
  • You are allowed to post more than 1 bot, but as different answers and with each bot operating completely independent from each other
  • The bots will be ranked in the order that they lose all their chips. The last bot with chips wins!

Example Bot

This is Patch-bot. He can't play poker very well as he is a dog.

def patch_bot(hand: list, table: list, bet: int, chips: int, blind:bool, other_players:dict):
    if blind:
        return 'Check'
    return 'Fold'

Have fun and may the best poker-er win!

Meta

This question is quite similar, in that it plays a game of poker. However, this is a totally different form of poker, uses betting and is basically totally different. But what do you think?

  • Any questions?

  • Any tags?

  • Aside from the one linked, any similar questions?

  • Do you like it?

  • Are there any glaring loopholes that would make the challenge less fun?

\$\endgroup\$
  • \$\begingroup\$ The other player information should probably be specified somewhere, although since it might change as you write it take your time coming up with it. I'd recommend at least giving the total money they have, their current bet, and whether they raised/checked, \$\endgroup\$ – FryAmTheEggman Jun 26 '17 at 22:47
  • \$\begingroup\$ why does he check, knowing he's won? \$\endgroup\$ – Destructible Lemon Nov 7 '17 at 22:17
  • \$\begingroup\$ Also, Leo's pokerface died because the controller got deleted or something? anyway, don't need to worry about being a dupe of that \$\endgroup\$ – Destructible Lemon Nov 7 '17 at 22:18
0
\$\begingroup\$

What Tiles did I have?

Everyone should be aware of the scoring system in a classic board game: Scrabble. I remember going back into my old scrabble box and finding some old post-it notes containing old scores. I always wonder what the heck was played for some of the more insane point scores. That gave me the idea for this challenge...


English-language editions of Scrabble contain 100 letter tiles, in the following distribution:

  • 0 points: * x 2 (These are the blank tiles)
  • 1 point: E ×12, A ×9, I ×9, O ×8, N ×6, R ×6, T ×6, L ×4, S ×4, U ×4
  • 2 points: D ×4, G ×3
  • 3 points: B ×2, C ×2, M ×2, P ×2
  • 4 points: F ×2, H ×2, V ×2, W ×2, Y ×2
  • 5 points: K ×1
  • 8 points: J ×1, X ×1
  • 10 points: Q ×1, Z ×1

Your challenge is, given a single integer input between 0 and 185, output a corresponding sequence of scrabble tiles that sum to that score with a length between 2 and 100 characters in length.

The Specifics

  • The letters don't have to spell anything, they just have to sum to that score.
  • You can only use a tile the number of times it exists (E.G. E can be used 12 times).
  • The shortest word is 2 characters long, for an input of 0 you get **.
  • Outputs will not match between answers, as there are many solutions.

Inputs and Outputs

  • Input should be a single integer, anything else is wrong.
  • Output should be a single string, with no spaces, order of letters is arbitrary.

Example (Potential Solution)

0   | **
1   | *E
2   | EE
[... Pattern Omitted ...]
12  | EEEEEEEEEEE
13  | EEEEEEEEEEEA
[... Pattern Omitted ...]
68  | EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRRTTTTTTLLLLSSSSUUUU
[... Arbitrary Ordering Omitted ...]
185 | EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXZQ

This is ,: Whomever contacts Cthulhu using the dark arts first wins.

\$\endgroup\$
  • \$\begingroup\$ Whomever contacts Cthulhu using the dark arts first wins. that's bait \$\endgroup\$ – Stephen Jun 27 '17 at 20:25
  • \$\begingroup\$ @StephenS wellp, if you want more bait check out 20 of my other random ass winning criterion for my sandboxies. \$\endgroup\$ – Magic Octopus Urn Jun 27 '17 at 20:27
  • \$\begingroup\$ Sorry Sandbox sucks :/ can output be a list of one-char strings? and integer includes negatives, dunno if that's on purpose or not \$\endgroup\$ – Stephen Jun 27 '17 at 20:29
  • \$\begingroup\$ @StephenS nono! That wasn't a diss on you or sandbox! That was just me stating that last 20 submission I've made to the sandbox I've put random winning criterion like "Winner buys dennis a subway footlong, or his countries' equivalent". \$\endgroup\$ – Magic Octopus Urn Jun 27 '17 at 20:35
  • \$\begingroup\$ Also, it says an integer between 0 and 185. Also I mentioned words must be at least 2-chars. I feel like either my challenge's wording blows or you misread it a little. Probably more likely the challenge is worded poorly, I've had 2 already. \$\endgroup\$ – Magic Octopus Urn Jun 27 '17 at 20:35
  • \$\begingroup\$ I made it a diss on Sandbox, that no one noticed them xD and I was looking in the #Input section for all the input specifics - I should have looked at the whole challenge, my bad. I just read Input should be a single integer, anything else is wrong. so that's what I assumed the whole rule for Input was (reading is hard) \$\endgroup\$ – Stephen Jun 27 '17 at 20:37
  • \$\begingroup\$ @StephenS to be honest, reading isn't hard, it's contextual. I always have noticed in my career that I 100% understand anything that I create. Then, when explaining it to others, it may make literally 0 sense but be 100% viable in my head. Then like 10/12 people come forth saying "What the heck did you even try to write man?" And I realize, "what the hell did I even try to write?" Hahaha. The way I explain things to others can be horrifically inadequate by my own experience. \$\endgroup\$ – Magic Octopus Urn Jun 27 '17 at 20:48
  • \$\begingroup\$ Related. It's a borderline dupe, in that the only real difference is a suitable wrapping loop. \$\endgroup\$ – Peter Taylor Jun 27 '17 at 21:42
  • \$\begingroup\$ A standard Scrabble board is 15 x 15, and even a "Super Scrabble" board is only 21 x 21. Should the maximum word length be limited to 15 (instead of 100)? \$\endgroup\$ – Jasper Jun 29 '17 at 5:50
0
\$\begingroup\$

Display the Undisplayable

I have sometimes seen answers to challenges, written in binary machine code. The users who post them usually display them in hexadecimal representation. This representation makes the code extremely long, and does not do them justice!

Thus, we should give them help, and I don't care if they don't need it. Your task will to write a program/function/eldritch incantation to turn their beautifully golfed binary code into the shortest possible string of printable characters.

Input

A sequence of random binary data of random length. Use any of the standard IO methods (note to self: find the link to the Meta post).

Output

A sequence of printable characters. Use any of the standard IO methods.

  • If encoding is relevant, you are free to choose any encoding, provided you clearly indicate which one you used in your answer. What is relevant is the number of characters anyway.

  • Whitespaces (regular space, new line, non-breaking space, form feed, etc.) are considered not printable. They can be added if you wish, but their presence or absence must not impact the decoding of the output.

Conditions

  • There must exist a program, that can take any possible output of your program, and turn it back into the input (providing it is not needed, but will be smiley'd at).

  • If your program is run twice, with 2 inputs of same size, the 2 resulting outputs must have the same size.

  • Standard loopholes apply.

Score

The score is calcaulated as the number of bytes in the input, divided by the number of characters in the output. The higher the better.

If the score varies depending on the length of the input, take its average over input sizes from 1 to 1024 bytes included (I don't think we'll have answer 1 kb long here).


Giving an answer in a binary language (machine code, LLVM bitcode, etc.) and adding the output when run with its own binary source will be smiley'd at (but no bonus, unless it can also summon Cthulhu).

Don't forget to explain how your code works!


Meta

  • Do you think it's a good idea? Is there already a challenge like this one?
  • Is there any blatant loophole/possible imporvements?
  • What tag(s) do you recommend for this challenge? (please edit the answer)
\$\endgroup\$
  • \$\begingroup\$ @Mr.Xcoder Sorry ^^ \$\endgroup\$ – Nathan.Eilisha Shiraini Jun 28 '17 at 12:43
  • \$\begingroup\$ it's spelled Cthulhu \$\endgroup\$ – Skidsdev Jun 28 '17 at 13:10
  • \$\begingroup\$ @Mayube That was what Mr.Xcoder's deleted comment was about... At first I didn't want to make a trivial edit, but since spelling of culture reference is such an important matter... Fixed! Now maybe I'll get more reactions about the challenge itself ^^ \$\endgroup\$ – Nathan.Eilisha Shiraini Jun 28 '17 at 13:14
  • 2
    \$\begingroup\$ I think this needs a precise definition of printable character. Unicode doesn't define the term. But once that's provided this is just a base conversion with an awkward base and every answer should get the optimum score, so the scoring system doesn't work. \$\endgroup\$ – Peter Taylor Jun 28 '17 at 13:51
  • \$\begingroup\$ I just wanted to say thank you for using the sandbox! I hope things go well with your challenges :) That said, I have to agree with Peter Taylor, it seems like every answer will get the optimal score. I think requiring the optimal score and changing to code-golf will work better, but there are many other ways you could fix it. Good luck! \$\endgroup\$ – FryAmTheEggman Jun 28 '17 at 14:03
  • \$\begingroup\$ Worth noting that encoding is always gunna be relevant given non-printables don't count, as bytes 0x00-0x20 are non-printables by your definition, meaning if the given binary contains any of those bytes, ASCII can't be used. \$\endgroup\$ – Skidsdev Jun 28 '17 at 14:06
  • \$\begingroup\$ @FryAmTheEggman I thought about something like that - maybe not the optimal score, but greater than a given value. And it seems I was right to use the sandbox, since there are already 2 potential loopholes detected! \$\endgroup\$ – Nathan.Eilisha Shiraini Jun 28 '17 at 14:08
0
\$\begingroup\$

Every Nth Line in Source Outputs N

Heavily inspired by Hello, World! (Every other character)

Related to my other Sandbox post Every Nth Char in Source Outputs N; is it a dupe?

Write a program that outputs 1. When the first, third, fifth, etc. lines are removed, it outputs 2. When all lines where their (1-based) index in the source, mod N, are not 0, are removed, it should output N.

This is . The winner is the program that works with the largest N, while working for all n < N (obviously, to run up to N, it has to be at least N lines long). If there is a tie, the winner is the shortest answer that reaches the largest N. Your program must at least work up to N=2, since I don't think any languages will struggle with simply printing 1.

Example

Examples are based off of this sample program:

test
hi
world
hello
12345
System.out.println(test);
timeout
let's dance

For the program to work for N=1, the original program should output 1.

For the program to work for N=2, the following should output 2:

hi
hello
System.out.println(test);
let's dance

For the program to work for N=3, the following should output 3:

world
System.out.println(test);

For the program to work for N=4, the following should output 4:

hello
let's dance

For the program to work for N=5, the following should output 5:

12345

etc.

The highest N this program could work for is its line length, 8.

\$\endgroup\$
0
\$\begingroup\$

Sandboxing this mostly so I don't forget about it (as I don't want to initiate this so soon after v3). Unlikely to need any serious revision, but comments are appreciated none the less.

Prisoner's Dilemma v4: The Amnesiac Gentlemen.

This is similar to v3 Petri Dilemma, except with one significant change: no one knows what round it is. The same setup, submission format, and scoring will be used. For sandbox brevity, I'm only noting the differences from v3.

Bots will receive input at the beginning of its turn in the format:

current points, enemies points, your previous moves, enemy's previous moves

The format of the move list (both yours and the enemy's) will be a string of characters, "c" for cooperation "d" for defection, in order from first round to last. However this list will contain only the first seven moves of the game as well as the most recent 7 moves (as everyone knows, you can only hold seven items in working memory). A String 14 characters or fewer would indicate a round at the beginning of the game where 14 total moves haven't yet been performed. Later rounds would be indeterminate.

Additionally, as the current round number is not being passed in, bots will be unaware of when the end of the game comes (games will still be 200 rounds). This should prevent "Ah ha, last round, I backstab!" "Ah ha, but I backstab you first, one round earlier!" strategies, which is what dominated a large swath of the v3 strategic playspace (I did tests where all backstab-early bots were coded to all backstab on the same round and there were only two that performed sub-optimally as a result, both of which were set to backstab "before all n-Tit-for-Tat strategies", moving them back 1 rounds re-elevated them above n-Tit-for-Tat again, as well as which one backstabbed the other first determining the winner between them). While several bots from v3 would be valid submissions in v4, all of the winning bots utilize more data than v4 will let them have, opening up the playing field for new techniques.

Here are four sample strategies that will be entered to start with:

Tit for Tat

def titfortatfunc(mypoints, enpoints, mylist, enlist):
    if not enlist or enlist[counter-1] == "c":
        return "c"
    else:
        return "d"

RandomPick

from random import choice
def randompickfunc(mypoints, enpoints, mylist, enlist):
    return choice(["d", "c"])

Cooperator

def cooperatorfunc(mypoints, enpoints, mylist, enlist):
    return "c"

Defector

def defectorfunc(mypoints, enpoints, mylist, enlist):
    return "d"
\$\endgroup\$
0
\$\begingroup\$

(Code Golf) How Many Notes Are There?

Background

Most music games (MUG) describes the "instructions" that the player must follow as "notes". When the charts (set of notes) are first available, MUG players usually record the chart as a video and upload them to video sites. However, unless playing a full combo (able to pick up all notes) that the combo count directly shows the number of notes, it is usually not practical to count the number of notes one by one directly (since there are usually hundreds of notes), so they calculate that from the scores that may show on those videos if the score formula is known.

One of those examples is jubeat, which is somehow like a MUG version of "Whack-a-Mole". Although officially "instructions" are called "chips", players have the consensus to call them "notes". (For those who don't know what jubeat is please check it out here: jubeat - RemyWiki)

Objective

What you have to do, is to:

  • Write a program or function,
  • Which accepts a list of integers as the only input,
  • That calculates the numbers of notes which is possible for all the given "basic scores".

Requirements

  • The input can be an array of integers or a string containing those integers (Please indicate the input format).
  • The integers in the input are guaranteed to be in the range of [0, 900000] inclusive.
  • A case (NOTES in the formula) is possible means that, for each integer in the input, there exists a variable ACH, when substituted into the formula below, the formula evaluates to that integer. (See The Formula and Test Cases for details)
  • All possible cases within the range [1, 1100] inclusive must be included in the output.
  • The output can be an array of integers or a string containing the results (Please indicate the output format).
  • If there is no case fulfilling the requirements, the program or function should either return an empty array, an empty string, null, or any objects indicating absence of results.
  • NO RUNTIME EXCEPTIONS shall be thrown in any circumstances.

The Formula

The max score is 1000000, but here we only consider BASIC_SCORE, whose maximum is 900000.

The BASIC_SCORE is calculated by BASIC_SCORE = floor(floor(ACH * 100000 / NOTES) * 0.9), where ACH is an integer in the range [0, NOTES*10] inclusive except NOTES*10-1 and NOTES*10-2.

As a concrete example, take ACH=6850, NOTES=900, we have BASIC_SCORE = floor(floor(6850 * 100000 / 900) * 0.9) = 684999.

As a result, NOTES=900 is a possible case for the basic score 684999.

Test cases

 Input                                    | Output
-----------------------------------------------------------------------------------------
 896757, 846353, 844486                   | 916
 891000, 893999                           | (all multiples of 30 within [1, 1100])
 899736                                   | 1024, 1025, 1026, 1027
                                          | (342, 683, 684 are false positives because  
                                          |  in these cases ACH = NOTES*10-1 or 
                                          |  ACH = NOTES*10-2)
 873540, 802468                           | (none: no case fits all inputs.
                                          |  some cases do fit some inputs but not all)
 0, 900000                                | (all values within [1..1100])
 800000                                   | (none)

Rules and Winning Criteria

This is a , so the source code with the shortest length (in terms of bytes) wins. Standard loopholes apply.

\$\endgroup\$
0
\$\begingroup\$

Poor Man's Ransomware

This challenge is loosely inspired by the cheapo-enigma machine question. However, I beleive that the differences are substantial enough that this would not be a dupe. Feedback welcome.


You have been captured by a morally questionable "employer" and forced to write a piece of "ransomware". All it has to do is take in a string "in whatever format" and output another string (which can be used to recover the files) Essentially, across the set of all possible inputs (infinite) you will define a one to one function.

Participants will then publish their code to stack-exchange, where other aspiring "hackers" will try to break your code. A "cop" submission will consist of a byte count a sample plaintext and a sample "encrypted" file as well as an encrypted copy of your code.

Robbers will work tirelessly in another thread to reproduce your code. Any submission which correctly produces the corresponding "encrypted" files when fed the sample plaintext and itself will be considered to be cracked.

If your code lasts 7 days or longer you may mark your submission as "safe" by publishing the source code for the encryptor and a decryptor. Until this time robbers may still work to break your code. If anyone finds that a specific decryptor fails on a certain plaintext it is invalid.

The winning cop has the shortest safe submission and the winning robber has the largest sum of the bytes of his cracked cops. Ties go to the earlier poster. Good Luck!

\$\endgroup\$
  • \$\begingroup\$ I'm not sure how much of the history of cops-and-robbers you are aware of. In the early days it was almost killed off as an interesting challenge type precisely by crypto, because it's so easy to make a problem which depends on e.g. factoring a large prime. In some senses this would be a duplicate of the very first cops-and-robbers. \$\endgroup\$ – Peter Taylor Jun 30 '17 at 20:07
  • \$\begingroup\$ Almost every cnr problem can be solved using cryptography. Would you then say that almost every cops and robbers problem is dupe of the other ones? \$\endgroup\$ – Rohan Jhunjhunwala Jun 30 '17 at 20:41
  • \$\begingroup\$ Many cnr's now try to ban the use of cryptography precisely to avoid this problem. \$\endgroup\$ – Peter Taylor Jun 30 '17 at 20:55
  • \$\begingroup\$ @PeterTaylor could I ban Crypto built ins? \$\endgroup\$ – Rohan Jhunjhunwala Jun 30 '17 at 21:32
  • \$\begingroup\$ What would be the point? It's crypto that's the problem, not crypto built-ins. \$\endgroup\$ – Peter Taylor Jun 30 '17 at 21:45
  • \$\begingroup\$ Maybe it might not be that bad of a thing? \$\endgroup\$ – Rohan Jhunjhunwala Jun 30 '17 at 21:57
  • \$\begingroup\$ I tmight be worth asking about this somewhere \$\endgroup\$ – Rohan Jhunjhunwala Jun 30 '17 at 21:57
  • \$\begingroup\$ It would be easy to implement some simple crypto and hardcode a key, making it impossible for robbers. \$\endgroup\$ – Shelvacu Jul 1 '17 at 23:39
  • \$\begingroup\$ Isn't that what most cnr challenges center on? \$\endgroup\$ – Rohan Jhunjhunwala Jul 2 '17 at 0:30
0
\$\begingroup\$

Count bytes like a Java golfer

Java is verbose, everybody knows that. Sometimes, here on PPCG, it happens that a Java answer is shorter than 60 characters, but most of the time it's longer, way longer! And the Java golfers here often post improvement suggestions in comments.

Alas, the PPCG website is based on the stack software, which invisibly cuts <code> comments according to an obscure rule, which I shall name the "Java golfer's bane", making it impossible to get an accurate byte-count by copy-pasting.

The rule in question is the following:

  • in a <code> tag, insert two invisible characters
    • the first time after 60 non-whitespace consecutive characters
    • then subsequently ever 20 non-whitespace consecutive characters

Challenge

Your goal is to help us, poor Java golfers, to get the byte-count straight from when we copy/paste code from comments.

SE software rules are, I'm sure, complex, so we will simplify a bit, but not that much.

  • Your input:
    • is mappable to UTF-8;
    • must support codepoints until at least U+FFFF;
    • will contain only characters with codepoints greater than or equal to U+0020;
    • must be a string or a characters array/list if those accept unicode characters, or else must be an integer (16 bits minimum) array/list. Unless I forgot anything obvious, no other input format is allowed.
  • If a sequence of non-whitespace characters in the input contains more than 60 characters:
    • keep the 60 first characters, then skip the next 2 characters;
    • then until you meet a whitespace, keep the next 20 characters and skip the next 2.
    • We don't care which are the two stripped characters.
  • Your output is the size of the string after being sanitized, in bytes as encoded in UTF-8! You must support very long Java answers, up to 500 characters (not bytes).
    • You don't need to map to UTF-8 since I give the rule on how to count without mapping, but in some languages it might be easier to actually map!
  • The standard loopholes are naturally forbidden.
  • This is codegolf, so the shortest answer in bytes wins!

You may assume the following:

  • the only whitespace character you will ever get is the space (U+0020). I abuse the term whitespace by including the start of the string as well in its meaning.
  • no whitespace will be at positions 62, 94, 116, (+22) ... after the previous whitespace

You may not assume the following:

  • The skippable characters will exclusively be the ones SE actually uses (U+200C U+200B);
  • you will get only ASCII characters;
  • you will not get any diacritics.

Bonus

  • if your code supports Unicode code points up to U+1FFFFF, you can remove 10% off your byte count, do not round the resut.

How to count the number of UTF-8 bytes?

If you haven't a builtin for that, Wikipedia gives us the rule, based on code points:

first code point  |  last code point  |  # bytes
U+0000            |  U+007F           |  1
U+0080            |  U+07FF           |  2
U+0800            |  U+FFFF           |  3
U+10000           |  U+1FFFFF         |  4

Wikipedia goes beyond those number, but the RFC 3629 capped this mapping to 4 bytes, so we thank it!

Test cases

Work in progress!


Notes for review:

\$\endgroup\$
0
\$\begingroup\$

What feedback do you have for me?

Challenge

Convert and print out a time in a 12-hour format. HH:MM AM/PM

Examples

Input:

  • 'Fri Jun 30 2017 21:14:20 GMT-0700 (PDT)'
  • 'Sat Jun 31 2018 08:06:20 GMT-0700 (PDT)'
  • 'Fri Jul 01 2017 01:14:20 GMT-0700 (PDT)'
  • 'Sat Apr 10 2020 09:06:20 GMT-0700 (PDT)'

Ouput:

  • 09:14 PM
  • 08:06 AM
  • 01:14 AM
  • 09:06 AM

Rules

\$\endgroup\$
  • \$\begingroup\$ I think this question has been covered pretty thoroughly by this challenge and this one, and would probably be closed as a dupe. \$\endgroup\$ – musicman523 Jul 1 '17 at 1:20
  • \$\begingroup\$ did not realize it had already been done :( \$\endgroup\$ – zoecarver Jul 1 '17 at 1:22
  • \$\begingroup\$ It's not exactly the same question, but I think that area has been pretty much covered. Now, what you could do is use this question as a model, but go from 24-hour time to 12-hour time :) \$\endgroup\$ – musicman523 Jul 1 '17 at 1:28
  • 1
    \$\begingroup\$ I like that Idea! in fact I could take it a step further and convert a string in the following format: 2017-07-01T02:58:38.799Z to 12 hour time \$\endgroup\$ – zoecarver Jul 1 '17 at 2:58
  • \$\begingroup\$ @musicman523 I made an edit to the question, what do you think? \$\endgroup\$ – zoecarver Jul 1 '17 at 4:16
  • \$\begingroup\$ I definitely like this better. You should add more test cases with different days (for example, does 1 come out as 1 or 01?), months, days of the week, etc. so there is no confusion about the input format \$\endgroup\$ – musicman523 Jul 1 '17 at 4:27
  • \$\begingroup\$ ok, sounds good. Is that enough test cases? feel free to edit and add more details. \$\endgroup\$ – zoecarver Jul 1 '17 at 4:28
  • \$\begingroup\$ I feel like the testcases should be formatted like input -> output\ninput -> output. What about the midday and midnight? \$\endgroup\$ – NieDzejkob Jul 2 '17 at 17:53
  • \$\begingroup\$ Ok, Sounds good. I am posting it. \$\endgroup\$ – zoecarver Jul 2 '17 at 23:12
0
\$\begingroup\$

Help! My code has exploded!

Insert backstory here

Task:

Your task is to create a program, which must follow these rules:

  • It must be able to be split exactly into pieces of the same length in bytes.
  • Once you have separated your program into pieces, your program must print 1 if the first "piece" is removed from your code, 2 if the second "piece" is removed, etc., until the program prints n if the nth piece is removed.

For example, if your program was the following:

aabbccdd

And it could be split into 4 equal parts of length 2, then these programs must result in the following outputs:

bbccdd -> 1 (aa is removed)
aaccdd -> 2 (bb is removed)
aabbdd -> 3 (cc is removed)
aabbcc -> 4 (dd is removed)

Scoring requirements:

Your program is scored based on the number of parts that it can be split into, with each part following the rules defined above. The more parts, the higher the score.

In the event of a tie, there is a "hierarchy" of scoring methods (with the next method in the list being used when there is a tie):

  • Number of parts the program can be split equally into
  • Size of the full program, in bytes (shortest byte-count wins)
  • Time posted (first poster wins)

Rules:

  • Each byte in the program must belong to one part.
  • Each part in the program must be of equal length.
\$\endgroup\$
  • \$\begingroup\$ You can make arbitrarily long programs that do this. I suggest instead that each answer should describe a pattern that can go to infinity (with possibly a starting piece). However scoring is difficult, since I forsee that some answers will have the segment number within each segment, meaning that going from 99 segments to 100 segments may require more characters per segment. \$\endgroup\$ – Shelvacu Jul 1 '17 at 20:02
  • \$\begingroup\$ Proof of concept for arbitrary number of segments: gist.github.com/shelvacu/e04c237ad8d1c066a7fd8b5170261e25 However, that was still fun to make so I definitely think there's potential here. \$\endgroup\$ – Shelvacu Jul 1 '17 at 20:13
  • \$\begingroup\$ @Shelvacu That seems like a really cool idea, yeah. Will change my question. \$\endgroup\$ – Qwerp-Derp Jul 1 '17 at 23:12
  • \$\begingroup\$ @Shelvacu Hmmm, I'm not sure how to properly make this into a challenge, TBH. I might scrap it. EDIT: I might have an idea, but I need to completely rewrite it. I might just delete this whole thing. \$\endgroup\$ – Qwerp-Derp Jul 3 '17 at 8:26
  • \$\begingroup\$ If you don't want to post it I will. Keep me posted. \$\endgroup\$ – Shelvacu Jul 3 '17 at 22:14
0
\$\begingroup\$

Introduction

Ten years ago, a secret encryption key used by DVD players was published online. When the industry tried to censor it, the internet reacted by republishing it widely—creatively incorporating the key onto shirts, a flag and even in song.

If this code golf community had existed, I'm sure we would have joined in.

Challenge

Output the number 13256278887989457651018865901401704640.

Example input and output

Input:

Not applicable.

Output:

13256278887989457651018865901401704640

\$\endgroup\$
  • \$\begingroup\$ This is code-golf I suppose, you should mention the winning condition. \$\endgroup\$ – officialaimm Jul 3 '17 at 17:42
  • \$\begingroup\$ Is there any reason to believe that there's any way to compress this other than base conversion? \$\endgroup\$ – Peter Taylor Jul 4 '17 at 7:40
0
\$\begingroup\$

Decode Reddit's Voting System

Background

Users with a high enough reputation on Stack Exchange can see the number of upvotes and downvotes on each question and answer. On Reddit, however, the net vote count and percentage of upvotes are displayed. Unfortunately due to rounding errors, it is impossible to determine exactly how many upvotes and downvotes occurred.

Challenge

Given a nonzero net vote count and a percentage of upvotes, return all possible pairs of the numbers of upvotes and downvotes.

Constraints

The net vote count can be any integer in the range [-2^31, 2^31).

The percentage can be a whole number in the range [0, 100], or a floating point number in the range [0, 1] with no more than two digits; you may decide which format to accept.

The percentage represents the percentage of votes which are upvotes, rounded to the nearest integer. So a value of 93% could be anywhere in the range [92.5%, 93.5%) that would result

The maximum numbers of upvotes and downvotes will not fall outside the range [-2^31, 2^31); that is, you should be safe using 32-bit signed integers.

You may not return two ranges representing all possible amounts of downvotes and upvotes; you must specify which numbers of upvotes correspond to which numbers of downvotes; hence you must return all possible pairs.

Test Cases

1, 67%  -> [(2, 1)]
1, 100% -> [(1, 0)]
1, 60%  -> [(3, 2)]
0, 50%  -> [(0, 0), (1, 1), (2, 2), ...]; cases like this will not be valid input
More involved ones to come...

Meta

Anything I can do to make this more clear or more fun?

\$\endgroup\$
  • 2
    \$\begingroup\$ 1. Does "net vote count" mean upvotes minus downvotes? 2. The listed input 0, 100% is a special case ((0-0)/(0+0) = NaN% or a division by zero exception) so it should be mentioned explicitly in the spec, not just added as a test case. 3. Input 0, 50% would have 2^31 valid outputs, so that should also get an explicit mention because of the potential for answers to fail due to array size limits etc. Combined with point 2, I would suggest editing the question to guarantee that the net vote count will never be 0. \$\endgroup\$ – Peter Taylor Jul 4 '17 at 7:38
  • \$\begingroup\$ "Unfortunately due to rounding errors, it is impossible to determine exactly how many upvotes and downvotes occurred." I was under the impression that reddit adds some random noise to the net votes (not sure about the percentage) to throw off bots or something. \$\endgroup\$ – Martin Ender Jul 4 '17 at 9:52
  • \$\begingroup\$ @PeterTaylor Thank you, updated \$\endgroup\$ – musicman523 Jul 4 '17 at 19:33
  • \$\begingroup\$ @MartinEnder I believe they simply stop reporting exact values after it reaches a certain threshold, but I'm not sure. For this challenge we'll assume they don't add any noise \$\endgroup\$ – musicman523 Jul 4 '17 at 19:34
0
\$\begingroup\$

Create The Correct Path

Which would be better code golf with shortest code and being able to run on at least two operating systems or code challenge and scoring by how many operating systems it can run on?

( OR )

Given an input create a program that when ran on different operating systems creates a path for each one. For example, when ran on Windows:

[ "folder1", "folder2" ] -> folder1\folder2

Input

An array of strings or any suitable alternative. The input can be empty, in which case you would just return an empty string.

Output

The correct path for the operating system the program has been ran on.

\$\endgroup\$
  • \$\begingroup\$ I'm mainly looking at feedback for what people think of this challenge before developing it further. \$\endgroup\$ – TheLethalCoder Jul 5 '17 at 10:16
  • \$\begingroup\$ I think you should include other operating systems with different paths separators in the challenge itself. \$\endgroup\$ – Kritixi Lithos Jul 6 '17 at 8:45
  • \$\begingroup\$ @KritixiLithos I was going to, was waiting to see if I should go with code-golf or code-challenge before writing up the formatting for all the examples. \$\endgroup\$ – TheLethalCoder Jul 6 '17 at 9:02
0
\$\begingroup\$

Draw a Probability Road

Background

I'm conducting a probability experiment. I have a collection of live rats, and I'm going to assign each rat a probability as a percentage integer from 1 to 99 (inclusive). The experiment will last 10 weeks, and at the end of each week, I'll roll a 100-sided die. Any rats who have a higher or equal probability than the number I roll, I kill.

Now of course I'd rather not go actually killing rats, so I want to write a program to create a probability road to show the probability of a rat surviving, when given that rat's probability number.

Unfortunately my lab is full of rats, so I don't have much room to write this program. As a result it needs to be as short as possible in order to fit in my cramped room.

The Challenge

Given an integer 0 < x < 100, output an ASCII Art probability road that shows the rat's chances of surviving.

Input can be taken as an integer, a string, an array of digits or an array of characters.

Output (detailed below) should be either printed/outputted, or returned as a single string (not an array of strings)

But what is a probability road?

A probability road is a type of probability chart used for displaying all possible outcomes of a given event. It consists of a series of lanes, each lane being one possible outcome, and the vertical axis representing time.

For our ASCII art challenge, we want each lane to be a space with a pipe on either side, like so:

| |
| |
| |

However 2 neighbouring lanes should share a pipe, like so:

| | | |
| | | |
| | | |

Every 2 lines of ASCII art represents one week of the experiment, and at each week, a number of lanes corresponding to the probability given should be terminated. A terminated lane ends in an X like so:

| | |
| | |X
| | | |

The lanes should be ordered with the longest lanes on the left, in descending order to the right, and the number of lanes in your probability road should be the fewest possible to accurately represent the given probability, for example given a probability of 50 (50%), the road would look like this:

| | | | | | | | | | |X - Week 10
| | | | | | | | | | | |
| | | | | | | | | | | |X - Week 9
| | | | | | | | | | | | |
| | | | | | | | | | | | |X - Week 8
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |X - Week 7
| | | | | | | | | | | | | | |
| | | | | | | | | | | | | | |X - Week 6
| | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | |X - Week 5
| | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | |X - Week 4
| | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | |X - Week 3
| | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | |X - Week 2
| | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | |X - Week 1
| | | | | | | | | | | | | | | | | | | | |

Given the probability of 50%, half of the lanes should succeed past week 10, while each week, 5% of the total lanes should be eliminated. This could be displayed using 1000 lanes (as could every probability from 1-99), by terminating 50 each week and having 500 reach the end, however this is not the most simplified form of the chart, so doing so would not be valid for this challenge.

Note that the Week X labels are not necessary

Another example, this time for the input 80:

| | | | | |X X
| | | | | | | |
| | | | | | | |X X
| | | | | | | | | |
| | | | | | | | | |X X
| | | | | | | | | | | |
| | | | | | | | | | | |X X
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | | |X X
| | | | | | | | | | | | | | | | | | | | | | | | | |

This time, there are 25 lanes. Each week, 2 (8%) are terminated, and 5 (20%) make it to the end.

Rules

Standard loopholes apply, shortest code (in bytes, per language) wins.

As per usual, trailing whitespace is allowed. You may have trailing spaces at the end of lines, and one or more trailing newlines at the end of the output.

Meta

How can I make the explanation clearer? It seems difficult to understand currently.

Also is there anything else that needs specifying or clarifying?

\$\endgroup\$
0
\$\begingroup\$

If you've come here, you probably know what is, and that's what I'm going to assume.

Story

(I guess)


Keyboards are input devices we use all the time. They existed before mice and touch screen, etc.

Their fundamentals have not changed: when you press a key down, a signal is sent to the computer. When you release it, another signal is sent.

So here's the challenge: calculate the minimum number of signals(length of a signal does not matter) depending on the input string.

Example:

Input:

test

Output:

8

Explanation: All keys have to be pressed down and released


Input2:

TEst

Output2:

10

Explanation: Shift has to be pressed, then T, down, up, E, down, up, then release shift, then s down, up, then t down, up, totalling up to 10.


Rules

Any language is accepted.
This is , so shortest code in bytes wins.
Programs with incorrect outputs will be disqualified.

Happy golfing!

Edit:

The keyboard layout used should be this: http://dry.sailingissues.com/keyboard-US-International.png

Only characters in this keyboard layout will be used (+lowercase letters).

Using Caps-Lock is ok, since it DOES have an advantage: numbers remain numbers while letters become uppercase.

Thanks for the feedback so far.

\$\endgroup\$
  • \$\begingroup\$ I think this might be a dupe, lemme see if I can find the original. EDIT: Ah, it's your challenege. I suggest deleting it from main while you work on it here; you can edit and then undelete it when it's ready. \$\endgroup\$ – Shaggy Jul 6 '17 at 9:10
  • \$\begingroup\$ Test cases? Your comment about caps lock is a good example of an edge case which should be explicitly covered by the test cases, and implies another where a shift covers a substring which mixes upper-case letters and symbols. \$\endgroup\$ – Peter Taylor Jul 6 '17 at 10:24
0
\$\begingroup\$

Abbreviate a rename

After you commit a rename, git reminds you but tries to avoid showing the full source and target path. It does this by splitting the path into components, extracting identical leading and trailing components, then using them to abbreviate the rename. (Other output that git produces is not relevant here.) Here is an example:

foo/bar/baz/quux.c => foo/baz/bar/quux.c

The leading component foo and trailing component quux.c is the same, so this becomes

foo/{bar/baz => baz/bar}/quux.c

This also works when one of the components is empty, e.g.:

foo/{bar/baz => }/quux.c
foo/{ => baz/bar}/quux.c

Please write a program or function that abbreviates a rename. The input can be a pair of strings or a single string with a delimiter which can be => or newline or something else not typically found in a file name. The output should be a single string containing a => as shown. You can assume that neither string is a prefix of the other (git doesn't abbreviate the rename in that case for some reason.)

This is , so the shortest program wins!

\$\endgroup\$
0
\$\begingroup\$

Lazy programmers need help versioning!

So here's a question, which is related to a recent problem I had while doing some data processing. I think it is good practice to include version numbers in file names to prevent data being overwritten and so you can see how things have changed with each version but I'm lazy so want it automating!

Your challenge

Take a full Windows file path and either increment the file version, or if there is no version, make it version 1.

Input

A full Windows file path, that includes the file extension.

Output

The original file path with the file version, incremented appropriately.

Rules

  • The version is determined by an underscore followed by a single digit, i.e _1 for version 1.
  • For a file that already have a version, it will only be in the range 1-8, so you only ever have to deal with single digit file versions.
  • Standard rules apply
  • Default Loopholes are forbidden.
  • Please provide explanations of your code so others can learn form it and if possible, links to an online interpreter such as TIO
  • This is so shortest code in bytes wins!

Test cases

Case 1
Input:  C:\Foo\Bar.txt
Output: C:\Foo\Bar_1.txt

Case 2
Input:  C:\notsortedfile_version_1_new_5.docx
Output: C:\notsortedfile_version_1_new_6.docx

Case 3
Input:  D:\a\very\deep\file\567234.pdf
Output: D:\a\very\deep\file\567234_1.pdf

Case 4
Input:  Z:\Storage\Somefile_2017-04-11.txt
Output: Z:\Storage\Somefile_2017-04-11_1.txt

Case 5
Input:  Z:\Storage\I.Like.Dots.txt
Output: Z:\Storage\I.Like.Dots_1.txt

Sandbox Questions

Not sure if this is dupe of Please release me!

Any feedback welcome.

\$\endgroup\$
  • \$\begingroup\$ I don't think it's a dupe. My opinions: You shouldn't let the test cases be dependent on OS. Just stick with one, the challenge is to modify a string, it doesn't really depend on which OS you're on. Personlly, I'd skip the 1-8 limitation. I think it would be more fun to go from file_9 to file_10. People (including you) might disagree with me though. \$\endgroup\$ – Stewie Griffin Apr 11 '17 at 8:51
  • 1
    \$\begingroup\$ Also, I though version control was handled this way: filename.xyz -> filename_new.xyz -> filename_new_1.xyz (remember to rename the previous to: filename_new_OLD.xyz). And of course versions such as filename_new_2_backup.xyz, filename_final_version.xyz -> filename_final_version_2.xyz. \$\endgroup\$ – Stewie Griffin Apr 11 '17 at 8:56
  • \$\begingroup\$ Which is why need to get some code to do it for us :) \$\endgroup\$ – Notts90 Apr 11 '17 at 8:58
  • \$\begingroup\$ Will file names only ever contain a .? \$\endgroup\$ – Shaggy Jul 6 '17 at 11:19
  • \$\begingroup\$ @Shaggy It could be any valid windows file path so yes, I've added a test case to cover it. \$\endgroup\$ – Notts90 Jul 6 '17 at 11:26
  • \$\begingroup\$ Test case: c:\foo? \$\endgroup\$ – Peter Taylor Jul 6 '17 at 13:32
0
\$\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\$
  • \$\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\$ – Peter Taylor 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
0
\$\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\$
  • \$\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\$ – FryAmTheEggman 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
0
\$\begingroup\$

Combine RGBA colors

The function Combine input a list of RGBA colors. Shapes with given color was drawn on the same position one by one. The first color was drawn on the top, and the last one drawn on the bottom. You need calculate what color the shape is when all these shapes was drawn.

Formula

Colors are represented in Red, Green, Blue, and, Alpha components:

  • Red, Green, Blue are numbers in range 0 ~ 255 (inclusive).
  • Alpha is a number in range 0 ~ 1 (inclusive).

If there are only one color, the following formula applied:

Combine(color) = color

If there are exactly two colors, the following formula applied:

Combine(top, bottom) = {
    r = (top.r * top.a + bottom.r * (1 - top.a) * bottom.a) / (1 - (1 - top.a) * (1 - bottom.a)),
    g = (top.g * top.a + bottom.g * (1 - top.a) * bottom.a) / (1 - (1 - top.a) * (1 - bottom.a)),
    b = (top.b * top.a + bottom.b * (1 - top.a) * bottom.a) / (1 - (1 - top.a) * (1 - bottom.a)),
    a = 1 - (1 - top.a) * (1 - bottom.a)
}

* if top.a = bottom.a = 0 then r, g, b may be any numbers in range 0 ~ 255

If there are more than two colors, the following formula applied:

Combine(first, second, third, ..., (n-1)th, nth)
    = Combine(Combine(first, second), third, ..., (n-1)th, nth)
    = Combine(first, Combine(second, third), ..., (n-1)th, nth)
    = ...
    = Combine(first, second, third, ..., Combine((n-1)th, nth))

Since this function is associative, you may chose the order you prefer.

Input format

You may take input from stdin, or function parameter, or other acceptable input format.

If you are taking input from an single string or stdin, colors should in following format:

  • In red green blue alpha format (e.g. 10 20 30 0.4, 100 200 250 0.5)

colors are separated by a single whitespace character (space, tab, cr, lf, ...).

You may also take input in anything which can express an ordered list (e.g. array, list, tuple, multiple function parameters, or maybe something else...) of colors. And colors may be represented as a string described above or an ordered list with 4 number values.

Red, green, blue components inputted are guaranteed to be integer. But you are allowed to output them as real number.

An optional integer number for count of colors at the beginning or ending of the input or as an parameter is allowed.

Input should not contain other values which does not described above.

Input always has at least one color.

Output format

You should output a single color in any format described above and the format should also be accepted by your code.

If output color meets alpha = 0, red, green, blue component may be any valid number in range 0 to 255.

Output value should in the range described above (rgb should in 0 ~ 255, a should in 0 ~ 1).

Floating point precision

When calculate Combine function with only one parameter, any floating point error is not allowed.

When calculate Combine function with two parameters, red, green, blue component should not have an error greater than (0.5 + ε); alpha component should not have an error greater than (0.005 + ε).

When calculate Combine function with more than two parameters, the formula first convert it to an sequence of calling Combine multiple times with two parameters, the errors allowed in each call is described above, and the error may be accumulated.

Sample testcases

[[0, 0, 0, 0.5]] -> [0, 0, 0, 0.5]
[[0, 0, 0, 1], [1, 1, 1, 1]] -> [0, 0, 0, 1]
[[0, 0, 0, 0], [1, 1, 1, 0.5]] -> [1, 1, 1, 0.5]
[[50, 100, 200, 0.5], [100, 200, 0, 0]] -> [50, 100, 200, 0.5]
[[10, 20, 30, 0.5], [10, 20, 30, 0.5]] -> [10, 20, 30, 0.75]
[[120, 240, 33, 0.5], [0, 0, 0, 0.5]] -> [80, 160, 22, 0.75]
[[0, 0, 0, 0], [0, 0, 0, 0]] -> [r, g, b, 0]*
    * r, g, b may be any numbers in range 0 ~ 255
[[20, 70, 20, 0.5], [140, 110, 80, 0.5], [200, 200, 110, 0.5]] -> [80, 100, 50, 0.88]
[[251, 140, 20, 0.19], [182, 161, 148, 0.28], [27, 99, 33, 0.05], [154, 107, 234, 0.55], [112, 142, 9, 0.26], [136, 225, 243, 0.39], [57, 157, 208, 0.54], [214, 252, 4, 0.96], [152, 183, 38, 0.13], [140, 242, 83, 0.73]] ->[168, 146, 140, 1]*
    * floating errors are allowed

Winner

This is code golf, code shortest in bytes win.

\$\endgroup\$
  • \$\begingroup\$ Is there an upper limit to the number of colours we'd need to be able to handle? Can you explain your reasoning for allowing the number of colours to be taken as an additional input? \$\endgroup\$ – Shaggy Jul 7 '17 at 9:00
  • \$\begingroup\$ Oh, and a few test cases and a worked through example would be handy, too. \$\endgroup\$ – Shaggy Jul 7 '17 at 9:06
  • \$\begingroup\$ @Shaggy for languages do not support the EOF concept in stdin (I do not know but maybe), or languages need an mark to indicate array length (like C). \$\endgroup\$ – tsh Jul 7 '17 at 9:21
  • \$\begingroup\$ @Shaggy Is an upper limit should be included? Will it simply be "any finite number"? Although program may not be able to handle large input due to memory limitation. But that should not be considered generally, IMO. \$\endgroup\$ – tsh Jul 7 '17 at 9:38
  • \$\begingroup\$ No, I don't think and upper limit is needed, it was just a query. Whether you do have an upper limit or not, you should probably specify it in the challenge somewhere. See my opinion on allowing C to take list length as an extra argument here. For the test cases (when you add them), I'd suggest providing both the expected output and the allowed ranges when taking floating point precision errors into consideration. \$\endgroup\$ – Shaggy Jul 7 '17 at 10:02
  • \$\begingroup\$ Ooops, the formula was wrong. fixed. \$\endgroup\$ – tsh Jul 7 '17 at 10:25
  • \$\begingroup\$ @Shaggy test cases had been added, should there be some more? \$\endgroup\$ – tsh Jul 7 '17 at 10:25
  • \$\begingroup\$ @Shaggy but question itself may override these default rules, right? also, I don't think add another optional parameter would make the question any easier. \$\endgroup\$ – tsh Jul 7 '17 at 10:29
  • \$\begingroup\$ I'd suggest adding test cases that have 3 or more colours and also a greater range of colours and alphas. \$\endgroup\$ – Shaggy Jul 7 '17 at 10:46
  • \$\begingroup\$ @Shaggy two more testcases are added. \$\endgroup\$ – tsh Jul 7 '17 at 11:34
  • \$\begingroup\$ I still think specifying the range of acceptable results for the test cases (the last one in particular) could help add some clarity. My rough tests without any rounding gave RGB values of 168.1342541694134,146.5053458267826,140.72902296732062for the last test case but, depending on when and how I rounded, they could end up being as low as 163,143,136 or as high as 171,151,143. \$\endgroup\$ – Shaggy Jul 10 '17 at 10:32
  • \$\begingroup\$ @Shaggy Since the operation is not a linear one, it is very difficult to calculate the range allowed. Maybe if the final answer has an error greater than (0.5, 0.005), the proving of the error should be left to the respondent. \$\endgroup\$ – tsh Jul 11 '17 at 1:11
0
\$\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\$
  • \$\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\$ – Socratic Phoenix 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\$ – Socratic Phoenix Jul 12 '17 at 18:31
0
\$\begingroup\$

What's Underneath the Sine Wave?

Task

Your task is to output a part of the sine wave out of any characterss of your choosing and on any background of your choosing. The wave can start and end either on the highest or the lowest point of the wave if both are the same.

The challenges main part is what happens below the wave (or above if you chose to start at the peaks of the wave). For each column, looking top-to-down it should repeat until the bottom the segment of spaces until the wave.

Or a visual explanation:

Start with a sine wave of your choosing (this is not a valid one as it isn't 50x20, but smaller to save space):

             ####             
           ##    ##           
          #        #          
         #          #         
        #            #        
       #              #       
      #                #      
     #                  #     
    #                    #    
  ##                      ##  
##                          ##

and then, look top-down and until the 1st encounter of a non-background character record the characters and then repeat them:

        ↓   ↓####             
        ↓  ##  P ##           
      4x↓ # ↓  P   #          
        ↓#  P  P    #         
        X   ↓  P     #        
       #↓   P  P      #       
      # ↓4x ↓  P       #      
     #  ↓   P  P        #     
    #   ↓   ↓  P         #    
  ##    P   P  P          ##  
##      ↓   ↓  P            ##

so for this the output would be

             ####             
           ########           
          #  ####  #          
         # ######## #         
        #    ####    #        
       #  ##########  #       
      #      ####      #      
     #   # ######## #   #     
    #     #  ####  #     #    
  ##    #  ########  #    ##  
##           ####           ##

Clarifications

  • There can be any amount of leading/trailing lines with any amount of whitespace
  • On each line there can be extra leading whitespace, as long as the amount is equal on all lines
  • The width should be at least 50 characters total (excluding columns of only whitespace)
  • The height should be at least 20 characters total (excluding lines of whitespace only)
  • The repeating bottom parts must be cut from the bottom (or top) of the wave
  • Inaccuracies due to rounding or floating-point errors can be dismissed
  • The background character has to be constant
  • The wave characters can be different, as long as they aren't ever equal to the background
  • This is , the shortest code per language wins!

Sample outputs

                         XXXXXX
                       XXXXXXXXXX
                     XX  XXXXXX  XX
                    X  XXXXXXXXXX  X
                   X     XXXXXX     X
                  X  XXXXXXXXXXXXXX  X
                XX       XXXXXX       XX
               X    X  XXXXXXXXXX  X    X
              X      XX  XXXXXX  XX      X
             X     X   XXXXXXXXXX   X     X
            X            XXXXXX            X
           X      X XXXXXXXXXXXXXXXX X      X
          X              XXXXXX              X
         X      XX     XXXXXXXXXX     XX      X
        X          X XX  XXXXXX  XX X          X
       X       X    X  XXXXXXXXXX  X    X       X
      X                  XXXXXX                  X
    XX        X   X  XXXXXXXXXXXXXX  X   X        XX
   X                     XXXXXX                     X
XXX          X     XX  XXXXXXXXXX  XX     X          XXX

..................................................
DCB....................QPONM....................10
...A9........0.......SRQPONMLK.......C........32
.....8..........X...T..QPONM..J...F..........4
......7.......Z...VU.SRQPONMLK.IH...D.......5
.......6...............QPONM...............6
........5......Y.W..TSRQPONMLKJ..G.E......7
.........4.............QPONM.............8
...................U.SRQPONMLK.I
..........3.......V.T..QPONM..J.H.......9
...........2....X....SRQPONMLK....F....A
............1..........QPONM..........B
.................W.UTSRQPONMLKJI.G
.............0.........QPONM.........C
..............Z...V..SRQPONMLK..H...D
...............Y....T..QPONM..J....E
...................U.SRQPONMLK.I
................X......QPONM......F
.................W..TSRQPONMLKJ..G
..................V....QPONM....H
...................U.SRQPONMLK.I
....................T..QPONM..J
.....................SRQPONMLK
.......................QPONM..................................
...
.
....

sandbox

  • please suggest (or just edit in) ways of making this clearer
  • Anything missing?
  • Should I make this challenge take input, rather than being an broad kolmogorov-complexity challenge?
\$\endgroup\$
  • \$\begingroup\$ Is the sample output for input X? \$\endgroup\$ – officialaimm Jul 3 '17 at 12:27
  • \$\begingroup\$ @officialaimm The characters can be of your choosing, there's no input currently \$\endgroup\$ – dzaima Jul 3 '17 at 12:27
  • \$\begingroup\$ So, all the positions marked by X should have same character or can have different characters? \$\endgroup\$ – officialaimm Jul 3 '17 at 12:40
  • \$\begingroup\$ @officialaimm They can have any characters \$\endgroup\$ – dzaima Jul 3 '17 at 12:42
  • 1
    \$\begingroup\$ I think its better if you showcase sample output with different characters then. \$\endgroup\$ – officialaimm Jul 3 '17 at 12:53
  • \$\begingroup\$ I can't tell what the task is from reading the description, or from looking at the example. It might help to walk through a few example columns to make it clear, then follow up with the full wave examples after that. \$\endgroup\$ – trichoplax Jul 17 '17 at 14:12
  • \$\begingroup\$ @trichoplax good idea \$\endgroup\$ – dzaima Jul 17 '17 at 14:12
  • \$\begingroup\$ Thanks. A second look at the examples was enough for me to grasp the pattern, but a step by step example would probably have got it across quicker. \$\endgroup\$ – trichoplax Jul 17 '17 at 14:14

You must log in to answer this question.

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