527
\$\begingroup\$

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

If you think one of your posts needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

3407 Answers 3407

1
42 43
44
45 46
114
1
\$\begingroup\$

Fairly Cut a Ham Sandwich in Half

In this challenge we consider a discrete version of the ham sandwich theorem. In our case the theorem says:

Given two sets of points in a plane, there is a line that simulaneously bisects both sets.

So given two disjoint sets of distinct integral points in the plane, your task is finding a line of the form a*x + b*y = c that bisects these two sets and outputs the integers a,b,c.

  • Both (strict) half planes have to contain the same number of points of per set.
  • The line can contain input points, these are then not counted to either of the sides (e.g. when a set contains an odd number of points, or all points are on one line.)
  • The line is not necessarily unique.
  • The mentioned representation of a given line is unique up to an integral multiple (e.g. (m*a)*x + (m*b)*y = (m*c) represents the same line as above), but you do not have to output the fully reduced form.

Examples

As we said above, the output is not necessarily unique, so the presented outputs here are just examples. All the outputs are give in the form a,b,c.

Input: [(1,2),(1,4),(2,1),(2,3),(3,2),(3,4),(4,1),(4,3)] [(1,1),(1,3),(2,2),(2,4),(3,1),(3,3),(4,2),(4,4)]
Output: 410,640,2625 (410x + 640y = 2624)
        1,1,5 (x+y=5)
        0,2,5 (2y=5)

In the following we see three valid outputs:

Input: [(1,1),(2,2)] [(1,2),(2,1)]  
Output: 2,5,10 (2x+5y = 10)

(more to be added)

\$\endgroup\$
1
  • \$\begingroup\$ The best solution to this as written is probably brute force (or even randomized brute force, i.e. keep picking random lines until one of them works). You should probably either explicitly allow that, or else design a rule to disallow it. \$\endgroup\$ – user62131 Jun 6 '17 at 23:26
1
\$\begingroup\$

Collatz Bearings

Everyone knows the collatz conjecture. It is that this function:

Collatz Conjecture

when repeatedly applied on a positive non-zero integer will reach one.

There are many ways to visualise this. Inspired by this post, with the original source of this method here, this is how we will do it:

Start at 1, with a northward bearing. The next numbers will be one unit (of any, consistent) size, and x degrees clockwise (+x) if it is even, and x degrees anticlockwise (-x) if it is odd.

An example of this can be seen here (Though it starts with an eastward bearing). It uses a few hundred random starting points and goes backwards. But it's probably easier to build it backwards.

Visualisation of the Collatz conjecture

Here is a graph-like visualisation, showing the first 8 levels:

First 8 levels

There can be collisions.

Your task is to take two numbers, which would correspond to 2 nodes on that tree, and return the bearing of the second node to the first node.

Input

3 numbers. Positive integer a, Positive integer b, and angle x, in any unit you desire. b > a > 0, x is the angle of seperation, in it's simplest form (mod 360 for degrees, mod 2pi for radians, or having the upper half be negative if you wish.) a and b are guaranteed to be in different places (e.g., you won't have a = 20 and b = 21.)

Output

Using the method described above, the bearing of b from a in the graph, in the units of the input angle.

Scoring

This is code-golf, so the shortest program in bytes wins.

Note

If the Collatz Conjecture is eventually proven wrong, you do not need to take inputs where repeated application does not reach 1.

\$\endgroup\$
3
  • \$\begingroup\$ I don't understand what we're supposed to do. If we start at 1 then we'll go 1 -> 4 -> 2 -> 1 so we should draw a chain LLRLLRLLR.... The supplied image doesn't look like that chain. \$\endgroup\$ – Peter Taylor Jun 5 '17 at 14:55
  • \$\begingroup\$ 1 is the starting point. Then you go clockwise up to 2. It's a really zoomed out image, I'll post a zoomed in one with numbers \$\endgroup\$ – Artyer Jun 5 '17 at 14:56
  • \$\begingroup\$ I think what's missing is something to say that the iteration is backwards. At least, that's how I can make sense of the graph: "It uses a few hundred random starting points" still confuses the issue. "The bearing of the second angle to the first angle" is also rather confusing: judging by the Output section I think it should be node rather than angle. \$\endgroup\$ – Peter Taylor Jun 5 '17 at 22:26
1
\$\begingroup\$

Efficiently find the median

Background

Computer scientists have spent a long time looking into ways of sorting data faster. One of the known discoveries is that if you can use the actual values of the data, sorting can be faster than if you can only compare them.

Finding the median of a list is a similar operation to sorting it (you can trivially implement it via sorting the list, then taking the element in the middle). However, if you're in an environment where you can only compare list elements (as opposed to looking at the elements directly), this is not typically the fastest way to find the median, as sorts are hurt more badly by the comparison restriction than finding the nth item is. What's the fastest way? Well, finding that is what this challenge is about. (However, you may want to read this Wikipedia article to get some ideas of the approaches that are typically used. I can't guarantee that the algorithm given there is the best, though, especially on a problem of the limited size given here.)

The task

Write a program that finds the index of the median element within a list of 31 elements. However, the program may not take the list as input, and may not inspect its values directly. Rather, the program may only make comparisons to determine which of two indexes corresponds to the larger element, via calling a separate comparison function. (In other words, your program deals entirely with list indexes, not list values.)

In order to avoid solutions that brute-force their way through all possible algorithms, you must be able to run at least one worst-case input (i.e. an input that takes the maximum possible number of comparisons), using a comparison function which simply compares two array elements, in under 10 minutes on some computer you have access to. (Solutions which do not use brute force to find an algorithm are unlikely to get anywhere near this time bound.)

Clarifications

  • You may assume that all the list elements are distinct, i.e. the comparison function will always specify that one of the elements is larger, no matter how they're compared.
  • You may choose the format in which the comparison function provides output, but there must only be two possible outputs (meaning "item at first index is larger" and "item at second index is larger") for any possible query; you can't return values that mean "item at second index is much larger" or anything like that.
  • The comparison function will act consistently, i.e. if it claims that the list item at index A is larger than the list item at index B, it will always claim that; and if it also claims that the list item at index B is larger than the list item at index C, it will additionally claim that the list item at index A is larger than the list item at index C.
  • You may take the comparison function as input, or assume that it's already defined with a specific name. This is not , so there's no need to try to exploit the freedom you have here to save bytes; feel free to write it in the most readable way. (The comparison function itself is not part of the submission, but you should probably include one for testing purposes and an example of what it looks like.)
  • You may exploit the knowledge that the input list is exactly 31 elements long, if you wish (your program doesn't have to work in other cases, although of course it can if you want it to).
  • If your language doesn't have functions, you may write the comparison function via a source code insertion, so long as the rest of the code doesn't attempt to inspect its internals. (However, you may as well just pick a different language in this case; the scoring method is based entirely on the algorithm you use, and picking a different language won't change your score at all.)

Victory condition

Your score for this challenge is equal to the maximum number of times the comparison function can be called during a run of the program. Obviously, lower is better.

In the case of a tie, the first submission achieving the optimal score will win. (In other words, you don't gain anything from copying someone else's solution but golfing the code, or the like; you'll have to find an algorithmic improvement.)

Sandbox questions

Is this scoring method , , or ? I guess I'd want to call it (by analogy with ) but that doesn't exist and I'm not sure it should be created. EDIT: None of the above, it's .

\$\endgroup\$
4
  • 2
    \$\begingroup\$ I would expect the first answer to get a perfect score (because why submit one which doesn't?), at which point the question is dead. \$\endgroup\$ – Peter Taylor Mar 22 '17 at 12:32
  • \$\begingroup\$ @PeterTaylor: I expect a perfect score to be fairly hard to accomplish on this challenge. I'm not sure the optimal algorithm is known, and the problem's too large to bruteforce. \$\endgroup\$ – user62131 Mar 22 '17 at 14:43
  • \$\begingroup\$ I don't see anything in the question which rules out brute force. \$\endgroup\$ – Peter Taylor Mar 28 '17 at 8:41
  • \$\begingroup\$ Oh, I was thinking of bruteforcing an algorithm before writing the program, which isn't possible with currently available amounts of computational power. You're right that you could just write a program that bruteforces all possible algorithms at runtime and then runs the fastest (although it would clearly be impossible to test). I should probably place a limit on runtime in order to fix that. \$\endgroup\$ – user62131 Mar 28 '17 at 15:11
1
\$\begingroup\$

The Travelling Merchant

Economy is flourishing in the great Kingdom of Pipysigea [pee-pee-see-gee-ah], since the bandits have been driven away by the King's army. Especially, many people have decided to make trade their... trade, and have become merchants. You were one of them. You used most of your life's savings to purchase a good wagon and some animals of your choice. (Note: it can't be dragons. Sorry.) Unfortunately, you have just moved to Pipysigea from far away, attracted by the promises of wealth and security, so you don't really know much about the Kingdom: you have just bought a map, so you know the names of the cities and where they are, but you don't really know how long it's going to take to travel from one city to another.

So what is your goal? Being a merchant, you'll want to travel from city to city to get an idea of what good they want to buy and what goods they sell.

There will be a total of X kinds of goods in the Kingdom, and each city will be looking to buy 3 kinds and will be selling 3 kinds of goods. You will need to find out whether their prices are good for you: for example, the city of Puzzleon might be selling iron for 4 coins per unit and buying bread for 1 coin per unit, and the city of Stackapor might be selling wool for 2 coins per unit and buying iron for 5 coins per unit: in this case, it would be profitable to buy iron from Puzzleon and then travel to Stackapor to sell it.

But beware: trade is ever-changing, and prices are going to change based on what you and other merchants do. If you keep selling iron in Stackapor over and over, their need for it will soon start lowering, and so will the price they offer for that good. Similarily, if you buy a lot of iron from Puzzleon, the quantity at their disposal will lower and the amount of coins they want for it will start getting higher, until they run out of iron and stop selling it.

Beware, also, of taxes! The arch-enemy of any merchant. Every seven days (= turns) you are going to be taxed, based on your current wealth, which is measured by actual coins and amount of goods in your wagon. After all, his majesty King Golfus II deserves compensation for ridding the Kingdom of bandits and letting it prosper. And also for having established free market, of course.

During your travels, you will eventually encounter fellow (or rival, depending on your attitude) merchants, with whom you can trade just like you can with cities. You can decide to keep walking or to stop and trade. Every time this happens, you can tell them 1 good you are willing to buy (or none) and the price you offer, and the same with 1 good you are willing to sell. The other merchant will do the same. Then, you can respond by accepting or declining both of their proposals or just one. They will do the same with your proposals. Once all this is done with, you can resume your travel.

You lose if you go bankrupt: that happens when the time comes to pay taxes and you don't have enough coins. You automatically win if all other merchants have gone bankrupt.

The game ends after XXX turns, and the winner will be the merchant with the most coins.


Rules

  • Antitrust Law: a merchant cannot be made specifically to support another merchant. (To help ensure this, merchants can never know the name of the merchant they are trading with)

  • Fair Trade: a merchant cannot be made specifically to harm the trade of another merchant.

  • Fair Code: King Golfus II is the one and only ruler, and a merchant may not interfere with the law (also known as "The Controller")


Technicalities

You will be provided with a list of randomly generated cities (e.g. 10 to 15) with their coordinates on the map (a simple cartesian plan with X and Y values). The terrain is assumed to be pretty much the same overall, so travel times are based only on distance (initially I thought about giving specific travel costs - e.g. difficulty of road, maybe mountainous or muddy or whatever - to each "link", unbeknownst to the merchant, but felt like it would have complicated things too much. If you think it would be a nice addition, feel free to say it in the comments!)

Every city has a randomly generated list of 3 items to sell and 3 items to buy. The quantity they have available of each item they sell is also randomly generated, as well as the prices of all 6 kinds. Obviously, if a city sells iron they won't also be looking to buy it.

Each merchant can only be in one of these three positions:

  • in a city

  • on the way from one city to another

  • midway between two cities, stopped to trade with another merchant

The game proceeds in rounds, which are made of each player's turn. Every round, the turn order is changed (To be decided: poorest players first or randomly generated?)

In their turn, each player can do one of these things:

  • trade with the city, if they are in a city

  • trade with a merchant, if they have encountered a merchant on the road

  • resume travelling to the other city, if they have encountered a merchant

  • start travelling to another city

If, in the previous turn, the player started travelling to another city, at the start of this turn he'll either

  • be notified that they have encountered a merchant, and can decide whether to trade or keep walking

  • be notified that they have reached the other city, and receive the information about it (its name and its trade prices)

If the player encounters a merchant and decides to keep travelling instead of trading, they will reach the city they were travelling to and will still be able to act (= trade with the city or move again)

If, instead, the player trades with the merchant, their turn is considered over and will be able to move again on their next turn (note: since they will be midway between two cities, they will have the chance to decide which of the two to travel to, in case they want to change their previous "travel decision")

Taxation happens at the start of the player's turn, if it is the taxation round (= once every 7 rounds)

Note: the player can't "talk" to the other merchant unless they both stop to trade, so if the player decides to keep travelling they won't know the other merchant's prices. (I'm not sure about this rule, so please give me feedback :) would it be more sensible to know the other merchant's prices before having to decide whether to stop?)

Code

I haven't started coding the controller yet, but I was thinking about using Node.js (since javascript is my favourite language, and I don't have tools to use Java and would prefer to avoid having to install stuff) so that bots can be submitted in the form of node modules (either written in javascript or with a javascript wrapper like most low-level node modules)

Note that your bot will be able to save data into a .txt file.

Please give me feedback if you want to suggest a different approach. :)

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

Count Numbers in Integer Partition

Sandbox Remarks

I'm looking for a description to make the problem more clear.

Challenge and Example

We can partition a positive integer into smaller (or equal) ones. For instance, for N=6, it can be divided into:

  • 6 (1 integer occurs >= 1 times, 0 integer occurs >= 2 times)
  • 5+1 (2, 0)
  • 4+2 (2, 0)
  • 4+1+1 (2, 1)
  • 3+3 (1, 1)
  • 3+2+1 (3, 0)
  • 3+1+1+1 (2, 1)
  • 2+2+2 (1, 1)
  • 2+2+1+1 (2, 2)
  • 2+1+1+1+1 (2, 1)
  • 1+1+1+1+1+1 (1, 1)

Your task is to work out the sum of the count of integers in each case, which occurs greater or equal than M times. In the aforementioned case, if M=1, the result is 1+2+2+2+1+3+2+1+2+2+1=19, and if M=2, the result is 0+0+0+1+1+0+1+1+2+1+1=8.

Input

Two positive integers N, M.

N is the number being partitioned from.

M is the lower limit of occurrences.

Output

One integer, the sum of the count of unique integers in each partition.

Remarks

  • This is a code-golf so shortest code wins.
  • Standard loopholes are forbidden.

Example I/O

All padding spaces are for formatting on PPCG only. You don't need to take care of them.

8  2  => 19
10 1  => 97
25 4  => 1228
25 50 => 0
50 7  => 87004
50 50 => 1

All I/O for M,N<=50: here

\$\endgroup\$
6
  • \$\begingroup\$ To see whether I've understood this: you want ![\sum_{\lambda \vdash N} \sum_i [a_i \ge M]](i.stack.imgur.com/WEncL.png) where the outer sum is over all partitions of N, !\lambda = 1^{a_1} 2^{a_2} \ldots k^{a_k} in the frequency representation? \$\endgroup\$ – Peter Taylor Jun 7 '17 at 15:25
  • \$\begingroup\$ @PeterTaylor If I understand your equation correctly, in this problem, N should be a sum of smaller integers, instead of a product of smaller ones. \$\endgroup\$ – Keyu Gan Jun 7 '17 at 15:42
  • \$\begingroup\$ Yes, it's just that the frequency representation of partitions looks like a product because it's intended to be compact. I think that OEIS A066633 is the table of desired results, although its description isn't necessarily any clearer. \$\endgroup\$ – Peter Taylor Jun 7 '17 at 15:57
  • \$\begingroup\$ Should 5+1 not be (2,0)? \$\endgroup\$ – Shaggy Jun 7 '17 at 16:07
  • \$\begingroup\$ @Shaggy Sorry, yes. \$\endgroup\$ – Keyu Gan Jun 7 '17 at 17:52
  • \$\begingroup\$ @PeterTaylor Sorry for my not-so-good mathematic. Yes it is A066633. I just come up with the idea when learning Elder's Theorem. \$\endgroup\$ – Keyu Gan Jun 7 '17 at 17:57
1
\$\begingroup\$

Obsfucation: Use Uncommon Chars

Note that I do not have the SE lookup skills to set this up. An automated query would take this challenge a low way. If someone would like this to happen, I would greatly appreciate some help setting this up :)

Basic search (currently searches for Jelly, anywhere)

First, choose your language. It must have at least 100 answers on PPCG before the posting of this challenge, and at least 25 chars that are not no-ops. /* Click this query and insert your language's name to see if it is valid. If it is, this query will give you legal chars, and their point value */. Use those chars the complete the challenge. The lowest point value wins.

/*This Query

//Can we do challenges for SE queries? If so this would be a decent one :)

What I would like for this query to be:

Gets all chars from the first codeblock following the language name in a heading. Accumulates all chars into a frequency table. Make sure that there are at least 25 relevant chars - we can human inspect this to insure no-ops are not polluting the data. It will then return the bottom 20% (frequency) of chars, rounded down, along with point values from 1-length for each of them. The least common chars will receive lower scores. Ties will have the same point value (do it like tournament rankings - 1,1,3, not 1,1,2.)

Challenge answerers will only be able to use the chars provided. /Should whitespace be excluded (and allowed to be used, with a penalty) because of how SE treats whitespace?/

RE 25 char min: I really would like to get rid of this, but I don't know how else to prevent languages like BF from having an inherent advantage. Even if I restrict BF to 2 chars, it will score really low because they will have point scores 1 and 2.*/

/*The Challenge

I have not yet decided what the challenge should be - snippets to solve as many challenges, with point value as tiebreaker, might work, or a more difficult challenge. Input requested :) */

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

Resolve paths

Convert a path to an absolute path. The path may be:

  • relative
  • absolute
  • contain ~

If the path doesn't exist, exit with code 1. An invalid path leads to undefined behavior. i.e. do whatever you want, I don't care

Test cases, assuming /foo/bar is the current working directory, and the username is ~/admin:

<empty string> -> /foo/bar
. -> /foo/bar
.. -> /foo
... -> / # and so on until `...`
~/ -> ~/admin
~/golf -> ~/admin/golf
/bin -> /bin
foobar -> /foo/bar/foobar
.htaccess -> /foo/bar/.htaccess
./buildscript -> /foo/bar/buildscript
doesnotexist -> <exit with error code 1>

Don't use an external command or builtin that solves or almost completely solves this challenge.

This is , so the shortest answer in bytes wins.

\$\endgroup\$
2
  • \$\begingroup\$ Related \$\endgroup\$ – AdmBorkBork Oct 24 '16 at 15:49
  • \$\begingroup\$ This is very confusing... why does ~/golf go to ~/admin/golf? That's not an absolute path is it? Shouldn't ~/golf go to /home/admin/golf? \$\endgroup\$ – Tim Jun 9 '17 at 12:39
1
\$\begingroup\$

I would like to ask this challenge:

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

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

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

Any inputs will be appreciated.

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

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

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

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

Write a program or function which:

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

Clarifications:

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

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

Tag:

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

Heapify a list

META:

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

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

Details

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

Definition

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

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

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

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

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

Examples

Following image represents a max heap:

The corresponding list representation is

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

The following image represents a min heap:

The corresponding list representation is

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

Irreducible Polynomials over a Finite Field

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

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

I/O:

Your program/function will take two inputs:

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

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

Test Cases

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

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

Meta Note:

These are all really related:

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

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

stdin FPS

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

Task:

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

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

Rules:

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

Sandbox questions:

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

Print all matching leaves

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

A tree is either of:

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

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

Valid trees:

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

Invalid trees:

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

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

Task:

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

Rules:

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

I/O examples

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

Output format examples

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

Least Picky Language

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

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

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

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

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

Meta

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

Lots of Pi(e)!

For Meta:

Any tags other than , and ?

Dupe?

Any errors?

Clear enough?

Your Task:

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

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019

Input:

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

Output:

Pi truncated at 999 decimal digits.

Scoring:

This is , lowest byte count wins!

Good Luck!

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

Randomly capitalise half of a string

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

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

Scoring

This is so fewest bytes in each language wins!

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

Sample the Sierpinski traingle

Inspired by this video..

Task

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

Method

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

Input

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

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

Output

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

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

Criteria

Shortest code wins!

Example code (R)

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

  x <- 0
  y <- 0

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

enter image description here

Meta

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

Cops & Robbers, the ultimate 1-up.

This is a cops and robbers game.

Cops

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

Your task:

Produce two programs.

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

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

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

Robbers

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

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

Example I Os

cop: 16
robber: 17
Correct: Yes!

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

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

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

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

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

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

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

The following loopholes are still forbidden:

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

Beat the turing test

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

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

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


Scoring

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


Rules

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

Meta

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

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

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

Repetitive Primes

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

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

Rules

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

Test cases

B, N => Result

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

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

Meta questions

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

Mutation-hardening quine

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

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

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

For example, if you have a program:

abcd

These programs must all output abcd:

aabcd
abbcd
abccd
abcdd

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

Rules:

  • Standard quine rules apply.

This is , so shortest code in bytes wins!

Meta:

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

Make a Quiz Parser

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


The Format

Questions in input

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

How to output questions

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

How to output scores

Your score is: <score here>%

Test Case

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

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

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

As usual, standard loopholes are strictly forbidden.


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

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

The task

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

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

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

Examples

2, 4235851503548771316711413838489497242205033676
3, 16943406014195085266845655353957988968820134704
169434060141950852668456553539579889688, 16943406014195085266845655353957988968820134704

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

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

\$\endgroup\$
10
  • \$\begingroup\$ Is there a reason you picked that specific number? \$\endgroup\$ – Pavel Jul 6 '17 at 20:07
  • \$\begingroup\$ I think that unless there's a simple formula that gets that number, hardcoding that value would take more bytes than the rest of the code. \$\endgroup\$ – Pavel Jul 6 '17 at 20:07
  • \$\begingroup\$ @Phoenix I added a simple formula. \$\endgroup\$ – user9206 Jul 6 '17 at 20:13
  • \$\begingroup\$ I don't think it's a great idea to use nubmers that are so large that many languages require special constructs to represent them, it gives an unfair advantage to languages with arbitrary precision integers, which already tend to be shorter. \$\endgroup\$ – Pavel Jul 6 '17 at 20:19
  • \$\begingroup\$ @Phoenix I take your point but the point of this challenge is to devise efficient code for large inputs. Languages with builtin large number support tend to be quite slow (e.g. python) compared to e.g. C. I would like to leave it like this. \$\endgroup\$ – user9206 Jul 6 '17 at 20:22
  • \$\begingroup\$ Is there an efficient way to find the multiplicative order modulo a prime of a number, short of factoring p-1? \$\endgroup\$ – xnor Jul 7 '17 at 4:59
  • \$\begingroup\$ @xnor, none known. \$\endgroup\$ – 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
1
\$\begingroup\$

ASCII Art Turtle

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

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

\|/
- -
/|\

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

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

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

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

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

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

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

Escape the Labyrinth!


Introduction

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

Specification

Input

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

Said matrix will contain four distinct values:

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

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

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

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

Output

Your output will be sequence of four different values:

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

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

What to do?

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

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

Who wins?

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

Example

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

might result in:

Going right.
Going down.
Going down.
Going right.
Going down.
Going down.
Going down.
Going right.
Going right.
Going up.
Going right.
Going right.
Going down.
Going down.
\$\endgroup\$
3
  • \$\begingroup\$ Potential questions: What other tags to use? Should it be allowed to receive position information of 2 and 3 in the input as well? \$\endgroup\$ – SEJPM Jul 7 '17 at 20:15
  • 1
    \$\begingroup\$ I'd be very surprised if this wasn't a duplicate. I'm stuck on mobile for quite a while, but My car only turns right is very similar except you have to manage orientation. I'd look closely at other maze challenges to see that this adds to the site. \$\endgroup\$ – 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
1
\$\begingroup\$

An order of primeness

Introduction

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

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

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

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

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

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

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

Task

Given a prime, return its order.
More formally

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

This is , so shortest code wins.

Testcases

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

Sandbox Questions

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

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

Challenge

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

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

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

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

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

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

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

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

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

Sandbox

Is this different enough from this challenge?

Would this be better suited for ?

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

Stitch the Genome

Introduction

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

Challenge

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

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

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

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

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

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

Specifics

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

Test Cases

Format:

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

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

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

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

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

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

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

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

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

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

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

\$\endgroup\$
4
  • \$\begingroup\$ Too much intro, IMHO. \$\endgroup\$ – Adám Jul 12 '17 at 17:50
  • \$\begingroup\$ @Adám that was fast! I'll look into cutting down at that! Got to go do a thing now though, so it may be a while.... \$\endgroup\$ – 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
1
\$\begingroup\$

These are two separate challenges.


Convert to mixed-radix ZYX…432.234…XYZ

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

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

Examples

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


Convert from mixed-radix ZYX…432.234…XYZ

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

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

Examples

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


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

Minimize my cube

Introduction

Using my 6x6 as cubes of smaller size

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

Let's get mathematical

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

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

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

The challenge

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

Test cases

For n = 6:

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

For n = 4:

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

Scoring and Rules

Lowest number of bytes wins. Standard Loopholes apply.

Sandbox quesions

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

You must log in to answer this question.

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