464
\$\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 '19 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 '19 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – S.S. Anne Sep 26 '19 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 '19 at 13:43

2668 Answers 2668

0
\$\begingroup\$

Find fixed points of the Logistic Map


Definitions

Logistic Map

A logistic map is defined as the following equation:

equation

Where the next value in the map (on the left) is determined by a function of the current value (on the right), where the constant lambda represents a set constant between zero and four (non-inclusive, along the reals).

Stable Point

A "stable point" in relation to a map is a point which is approached repeatedly by iterating the logistic map. They are distinct, and there are one to many for any given lambda.

The Task

Write a function or program which, given an input real value n between zero and four (non-inclusive), returns the number of stable points for a map where lambda is n.

Examples

Soon to be added


Meta

Main problem: Defining "stable point". Is this definition sufficient?

\$\endgroup\$
  • \$\begingroup\$ The definition is wrong. A fixed point of a map is a point which is mapped to itself. For the logistic map the fixed points are 0 and 1-1/x. \$\endgroup\$ – Peter Taylor Jan 31 '17 at 8:45
  • \$\begingroup\$ If you instead look for points in stable cycles, you need to also specify that the domain is the real numbers, because stable cycles correspond to roots in the polynomial obtained by iterating the map, and over the complex numbers a polynomial always has as many roots as its order. If you specify distinct points in stable cycles of any length, that becomes a real challenge. \$\endgroup\$ – Peter Taylor Jan 31 '17 at 8:55
  • \$\begingroup\$ @PeterTaylor The second one was what I was going for. :P Got my terminology wrong. \$\endgroup\$ – Addison Crump Jan 31 '17 at 9:40
  • \$\begingroup\$ @PeterTaylor Just to verify, I'm looking for the number of distinct stable points for specific values of lambda along this graph. \$\endgroup\$ – Addison Crump Jan 31 '17 at 9:49
0
\$\begingroup\$

Language contest

Moving this here from normal question

So, I'm kind of an esolang loony so let me propose the following contest. First of all, we do not care about speed: if two algorithms safe the same problems then they are 'equally good' at least for this challenge. Also, let's think in "special case" terms. Sorting is the problem of well... sorting a list. However, an algorithm that generates permutations of lists with an abort condition equally solves the sorting problem. However, such an algorithm is more generic as the abort condition allows it to do more stuff. In other words: sorting a list is just a special case of generating permutations with an abort condition.

The idea is to concentrate on the most generic version of an algorithm that solves a problem. In other terms: Getting rid of redundant built-ins in esoteric programming languages.

The contest would go as following: The goal is to create an esoteric concatenative language (not necessarily stack based but concatenative) with the fewest built-ins that solve all problems (in some catalog). However, this would be really boring like that because a minimized version of brainfuck would pretty much win. Thus the 'score' function would likely be a function of 'amount of built-ins' and 'average program length'. One other constraint is that you are not allowed to have redundancy in your built-ins. If you have a built-in sortAsc and sortDesc and reverse then sortAsc = reverse . sortDesc thus you are disqualified. This also means that if you have too generic loops as built-ins like uhm for loops you can use these for loops to create a sort function which means you wouldn't be allowed to have a sort function.

What do you guys think?

TL;DR optimize for program length and least amount of builtins required.

\$\endgroup\$
  • \$\begingroup\$ This is an interesting idea, but the rule against redundancy is problematic. It's very difficult (in fact undecidable) to say whether the built-ins of a language are redundant. It's also probable that such limitations can be circumvented with some trick, like having each function take and return a tuple (d, l), where d is some arbitrary data and l is a string that records which functions were used on the data. You might also want to define unambiguously what a "concatenative language" is. \$\endgroup\$ – Zgarb Jan 31 '17 at 13:19
  • \$\begingroup\$ I agree with all of Zgarb's comments. That said, if you enforce a language paradigm, then you could define exactly what "combining commands" means. If you do do that, then I'd highly recommend making this a code-golf challenge, and dropping "least builtins" as a scoring mechanism \$\endgroup\$ – Nathan Merrill Jan 31 '17 at 13:34
  • \$\begingroup\$ If you can formulate any built-in in terms of other built-ins then you have redundancy. Hidden state doesn't really count. But yes, there are likely loopholes nobody has thought about yet. \$\endgroup\$ – mroman Jan 31 '17 at 14:06
  • \$\begingroup\$ @mroman Yeah, that's the definition of redundancy. But given an arbitrary list of built-ins, how can you definitively say "this list is not redundant"? Particularly with the weird stuff esolangs tend to have. \$\endgroup\$ – Zgarb Jan 31 '17 at 14:17
  • \$\begingroup\$ with handwaving probably. \$\endgroup\$ – mroman Jan 31 '17 at 15:09
  • \$\begingroup\$ Hmm, I've thought about this some more, and this is what I'd probably do. Drop the non-redundancy requirement, have a lot of smallish tasks (like 20 or so), and have the scoring function be something like N * 3^B, where N is the total length of the solutions to the tasks and B the number of built-ins. Then implementing a redundant built-in would only be worth it if it cut off 2/3 of your program size across all tasks. I'll have to think about it more to see if there are obvious loopholes that I've missed. \$\endgroup\$ – Zgarb Jan 31 '17 at 16:58
  • \$\begingroup\$ And don't get me wrong, I think this is a superb challenge idea! :) It just needs to be done right to have a positive reception and good answers. \$\endgroup\$ – Zgarb Jan 31 '17 at 17:00
  • 1
    \$\begingroup\$ As I commented elsewhere, "First of all, the assumption is that every algorithm that solves the same problem is equally fast" is nonsense, and primes readers with a background in computer science to expect the whole question to be low quality. I suggest rephrasing as "First of all, the assumption is that we don't care about performance". \$\endgroup\$ – Peter Taylor Jan 31 '17 at 17:42
  • 1
    \$\begingroup\$ Okay, I think I have found another "loophole". Suppose you have K tasks. Then you can make 3 built-ins and solve each task with a program of length 1 + ceiling(log2(K)) as follows. One built-in does "encoding": it transforms the data into some more restricted format (like multiply every list element by 2 to make them even, if the data is always a list of integers). The other two built-ins work as follows. (contd.) \$\endgroup\$ – Zgarb Feb 1 '17 at 9:05
  • 1
    \$\begingroup\$ If the encoded data has been processed by fewer than ceiling(log2(K))-1 functions, they just add a unique marker to the encoding (like by appending 1 or 3 depending on the function). Otherwise, the applied built-ins (counting the current one) form a binary string of length ceiling(log2(K)), which we interpret as a base-2 number encoding the task. Then we just decode the data and solve that task. \$\endgroup\$ – Zgarb Feb 1 '17 at 9:05
  • \$\begingroup\$ @PeterTaylor It just means that for this challenge it doesn't really matter how fast your program is as long as it solves the task in a (meaningful) finite amount of time. \$\endgroup\$ – mroman Feb 1 '17 at 14:14
  • \$\begingroup\$ @Zgarb I can't really follow that. Do you have a more practical/real example of that loophole? \$\endgroup\$ – mroman Feb 1 '17 at 14:17
  • \$\begingroup\$ If that's what it's intended to mean, write that instead, because as it stands it's very easy to interpret it as meaning something different. \$\endgroup\$ – Peter Taylor Feb 1 '17 at 14:39
  • \$\begingroup\$ @mroman Here's an implementation in Python 3. I hope you can follow it. I'm using 8 tasks as an example, which results in length-4 programs. Each program has the form Eabc, where abc is the binary encoding of the task number. \$\endgroup\$ – Zgarb Feb 1 '17 at 14:47
  • \$\begingroup\$ @zgarb yeah I get it now. I guess that's legal to do. \$\endgroup\$ – mroman Feb 2 '17 at 7:44
0
\$\begingroup\$

Detect skewed exponential sequences

Observe the following sequence:

1 3 9 54 162 729 2187 6561 19683

We can see that this is equivalent to:

1 *    1
1 *    3
1 *    9
2 *   27
2 *   81
3 *  243
3 *  729
3 * 2187
3 * 6561

The sequence on the right is the first 9 values of the exponential function f(x) = 3^x, that is, the exponential function of 3. It is multiplied element-wise by 1 1 1 2 2 3 3 3 3. Now, this sequences is strictly non-decreasing.

Your challenge is to, given a sequence K of length c, determine if there is a strictly non-decreasing list of integers L such that each element ej of (K / L) (element-wise division) is equal to bj, for 0 ≤ j < c, and for some b > 1.

This is a , so the shortest program in bytes wins.

True cases

1                    (1 * 1, base = any)
1 3 9                (1 1 1 * 1 3 9, base = 3)
2 4 8 32             (2 2 2 4 * 1 2 4 8, base = 2)
1 9 27               (1 3 3 * 1 3 9, base = 3)
1 5 500 2500 13125   (1 1 20 20 21 * 1 5 25 125 625, base = 5)

False cases

1 1 1 1              (false because this would have base = 0)
1 2 3 4              (no base)
1 2 4 32 16          (decreasing multiplier)
\$\endgroup\$
  • \$\begingroup\$ According to how you have it stated right now, the lists 1 1 1 1 and 1 2 3 4 can be done. It should be b>1 if you want it to not be possible. \$\endgroup\$ – fəˈnɛtɪk Feb 1 '17 at 18:07
  • \$\begingroup\$ @LliwTelracs Right you are. \$\endgroup\$ – Conor O'Brien Feb 1 '17 at 18:43
0
\$\begingroup\$

Solve for X

Given an equation using the following symbols:

  • Parenthesis: ()
  • Operators: +-/*
  • Variable: x
  • Comparators: <=>

And the following guarantees:

  • There will only ever be one x variable.
  • x / 0 will never be in the denominator.
  • Only one comparator will be used (no >= or <=).
  • All numbers used in the input will be integers.
  • Numbers in the output may be expressed as decimals, the chosen precision should be >= 3.

Output the correct reduction for the value of x.

  • Output should be in the form: x[Operator][Decimal] (E.G. x=2)
    • 2=x is not acceptable, you must have x on the left side.

Here are a few examples (The last part in bold is the part you need to output):

2+2=x 4=x x=4

x=4*3+(2-2) x=4*3+0 x=12

1+(x/4)-2=0 1+(x/4)=2 (x/4)=1 x=4

-2*(2+x)>-1*12 -2*(2+x)>-12 (2+x)<6 x<4

-2*x<(29+1)/6 -2*x<(30)/6 -2*x+2<5 -2*x<3 x>-6

(x/-1)*(10/-4)=10*5 (x/-1)*(10/-4)=50 (x/-1)=-20 x=20

(x/-5)*-1+2*8>0 (x/-5)*-1+16>0 (x/-5)*-1>-16 (x/-5)<16 x>-80

-1*(4*(6*(x/7)))<10 (4*(6*(x/7)))>-10 (6*(x/7))>-2.5 (x/7)>-0.416 x>-2.916


This is , lowest byte-count will be deemed the winner.

\$\endgroup\$
  • \$\begingroup\$ I'm not convinced this can be solved faster than brute force in the general case (although a golfed solution would likely use brute force anyway). On another subject, what should be the answer for input like x>4 x<6? \$\endgroup\$ – user62131 Feb 2 '17 at 21:48
  • \$\begingroup\$ Return it, as is. \$\endgroup\$ – Magic Octopus Urn Feb 3 '17 at 3:02
0
\$\begingroup\$

A kinda different large number contest

I really like large number's and code puzzles so I really like these large number contests. And I would like to have an other even if it's a duplicate. I feel like a lot of people feel the same way.

So I had to be creative and come up with a slight variation. I had the idea of prohibiting recursion since most of the fast growing techniques require it. Practically I might a accomplish this by only allowing a single array/list for memory.

I think it's almost impossible to avoid this idea being closed as a duplicate of Largest Number Printable but if there is interest I will work it out a lot more. And maybe I will be able to convince 5 people it's an interesting competition despite of the duplicate.

(And in case this is unclear it would be a you have X bytes to make a program the outputs the largest number)

Do you have any further ideas, suggestions or tags? Or are you even interested?

\$\endgroup\$
  • \$\begingroup\$ So print the biggest number you can in O(1) complexity? \$\endgroup\$ – Rɪᴋᴇʀ Feb 3 '17 at 18:57
  • \$\begingroup\$ 1. Neither the accepted answer nor the top 4 (arguably 5) voted answers in Largest Number Printable use recursion. 2. Bounding the memory is probably quite hard to specify well, but if you do manage it then essentially all you will achieve is to force all the answers to work by counting so as to go through every possible distinct state. \$\endgroup\$ – Peter Taylor Feb 3 '17 at 22:22
  • \$\begingroup\$ It's always possible to translate a recursive program into a corresponding iterative program (if the language is sufficiently powerful, but not much power is required, e.g. C is powerful enough). Depending on the language, this might or might not make the program significantly longer. Likewise, it's always possible to take a program that stores data in multiple places and change it so that it uses a single array for all storage (again, assuming appropriate language features that most languages will have). \$\endgroup\$ – user62131 Feb 7 '17 at 3:42
  • \$\begingroup\$ @PeterTaylor Hehe, I managed to squeeze some recursion up in there if you haven't checked :-) \$\endgroup\$ – Simply Beautiful Art Jul 31 '17 at 23:30
  • \$\begingroup\$ Another related proposal I just made: Can you surpass Γ<sub>0</sub>? For those serious about making extremely large numbers. \$\endgroup\$ – Simply Beautiful Art Jul 31 '17 at 23:32
0
\$\begingroup\$

Conjugate a Spanish Verb

A Little Background

I thought up this challenge, believe it or not, in a spanish class. I was thinking how simple it is to conjugate regular spanish present tense verbs and the programmer in me told me to make a question about it on PPCG

The Challenge

Given a regular Spanish infinitive and a subject, conjugate the infinitive in the present. How to do such a thing. For the sake of simplicity assume that all of the verbs are regular infinitives not irregular, stem-changing or reflexive.

Rules

-The input may be given in any reasonable format

subject verb | verb subject| subject,verb | ["subject", "verb"] etc. 

-If the input is not valid you may output anything or nothing at all

-The input is not valid if

a) It does not contain a regular, spanish, infinitive verb or a Spanish subject

b) It is not in the appropriate format, which you must specify

-The output can have any capitalization and is alowed trailing whitespace

Test Cases

Assume the input is given as "verb, subject" (Without the quotes)

comer, yo              --> como
ir, vosotros           --> Anything (Irregular)
jugar, ellas           --> Anything (Stem Changing)
                       --> Anything (Empty)
gsmkhnjkgn, tu         --> Anything (Not a verb)
sacar, ésdfgs          --> Anything (Not a subject)
\$\endgroup\$
0
\$\begingroup\$

Consecutive Composites

Your task is to write a program or function which, given a positive integer N, finds the first block of N consecutive composite numbers.

This should be the first block of integers which fit the requirements, larger than 0. For example, with an input of 2, the output must be [8, 9], and not [14, 15].

Rules:

  • The numbers in the block should be printed or returned as a list, in any reasonable format.
  • Submissions may be either full programs which perform I/O, or functions - no snippets.
  • You can assume that the block of numbers your program has been request to find is within your language's standard integer range.
  • This is , so the shortest program (in bytes) wins! Standard golfing loopholes apply.

Test Cases

1 -> [1]
2 -> [8, 9]
5 -> [24, 25, 26, 27, 28]
6 -> [90, 91, 92, 93, 94, 95]
10 -> [114, 115, 116, 117, 118, 119, 120, 121, 122, 123]

\$\endgroup\$
  • 1
    \$\begingroup\$ This is essentially codegolf.stackexchange.com/q/23844/194 with a tweaked output format. \$\endgroup\$ – Peter Taylor Feb 6 '17 at 9:34
  • \$\begingroup\$ One is not a composite number, the smallest is four, so the test case for 1 should be [4]. \$\endgroup\$ – Jonathan Allan Feb 6 '17 at 20:39
  • \$\begingroup\$ @JonathanAllan i've misused the term composite there, I meant 'non-prime' - regardless, I probably won't post this anyway and Peter pointed out it's basically a dupe. \$\endgroup\$ – FlipTack Feb 6 '17 at 22:02
0
\$\begingroup\$

Fraction Frenzy!

Task:

Your task is to generate the list of reciprocals of the Fraction Frenzy function (FF(n)) given a positive integer n.

Introduction:

Before I can introduce the FF function, I have to first explain Egyptian fractions.

Egyptian fractions are a way of expressing fractions as the sum of distinct unit fractions - so one way to express the fraction 5/8 is 1/2 + 1/8. It is not other fraction sums like

1/4 + 1/4 + 1/8
1/2 + 1/16 + 1/16

because not all of their fractions are distinct (1/4 is repeated in the first example, and 1/16 in the second).


The FF (Fraction Frenzy) function is described like so:

FF(1) is the Egyptian fraction 1/2 + 1/3 + 1/5 + 1/-30.

FF(2) is equal to FF(1) "multiplied" by itself (FF(1) "squared"):

  (1/2 + 1/3 + 1/5 + 1/-30)(1/2 + 1/3 + 1/5 + 1/-30)
= 1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900

This is not a fully reduced Egyptian fraction yet, because there are "repeats" in fractions. To reduce them, the following procedure is done:

  1. Sum all "like" unit fractions together.
  2. Reduce the sums to their simplest forms - so for example, if a sum from step 1 is 2/6, that can be reduced to 1/3.
  3. Repeat 1 and 2 until all reciprocals are distinct.
  4. If there is a pair of one positive and one negative fraction that have an equal absolute value, remove both of them (e.g. 1/-5 and 1/5 must both be removed)
  5. If fractions are not unit and cannot be reduced further, split it up into unit fractions with a equal denominator, and keep one fraction as it is. With the other ones, multiply them by (1/2 + 1/3 + 1/5 + 1/-30).
  6. Repeat until the final fraction sum is a valid Egyptian fraction.

This is the reduction of FF(2):

  1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900
= 1/4 + 2/6 + 1/9 + 2/10 + 2/15 + 1/25 + 2/-60 + 2/-90 + 2/-150 + 1/900 (step 1)
= 1/4 + 1/3 + 1/9 + 1/5 + 2/15 + 1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900   (step 2)
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/15(1/2 + 1/3 + 1/5 + 1/-30) +        (step 5)
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/30 + 1/45 + 1/75 + 1/-450 +
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/25 + 1/-450 + 1/900                  (step 4)

For all n (except for 1), FF(n) is defined by "squaring" FF(n-1).

Input and Output:

Given an integer n, you must output a list all of the reciprocals of FF(n), sorted in ascending order:

1 -> [2, 3, 5, -30]
2 -> [3, 4, 5, 9, 15, 25, -450, 900]

You are allowed to use a string with any delimiter, or your language's interpretation of a list.

Specs:

  • You must output the results of the FF(n) function exactly as specified above.
  • You are guaranteed that the input will be a positive integer - it will never be below zero, and it will never be a decimal (or fraction).
\$\endgroup\$
  • \$\begingroup\$ ^vote, I'm trying to see if there's a non-recursive method, because currently it's O(n^2) according to the problem specs. \$\endgroup\$ – user42649 Feb 4 '17 at 0:52
  • \$\begingroup\$ I think step 2 ("Reduce the sums to their simplest forms") needs to be more carefully specified. What is the simplest form of a given fraction? \$\endgroup\$ – Peter Taylor Feb 4 '17 at 21:22
0
\$\begingroup\$

Goal

Take 3 inputs, and output truey or falsey depending on whether or not they make an multiplication/division fact family. (2 * 4 = 8, 4 * 2 = 8, 8 / 2 = 4, 8 / 4 = 2) Order does not matter, as long as in some way the three numbers make an fact family. Repeated numbers are allowed.

Truey Inputs

2 4 8 
100 20 5 
7 7 49

Falsey Inputs

7 8 9
12 3 0
512 600 73

Rules
The values should be passed to the program as parameters or variables. Expect that only positive integers, and only 3 of them, will be passed to the program. You may write either a full program or a function, which either prints or returns the result. This is code-golf, so the shortest answer in bytes wins. Standard loopholes are forbidden.

\$\endgroup\$
  • 1
    \$\begingroup\$ This is a duplicate of an existing challenge (the reason why it was closed on main) \$\endgroup\$ – Kritixi Lithos Feb 6 '17 at 18:51
  • 2
    \$\begingroup\$ Were you going to change this to multiplication/division families? \$\endgroup\$ – ETHproductions Feb 6 '17 at 18:51
  • \$\begingroup\$ Changed it up. I also removed my first one from the main. \$\endgroup\$ – Feldspar15523 Feb 6 '17 at 19:51
  • \$\begingroup\$ Will the input numbers always be nonnegative integers? \$\endgroup\$ – Greg Martin Feb 7 '17 at 0:43
  • \$\begingroup\$ Edited Question \$\endgroup\$ – Feldspar15523 Feb 7 '17 at 0:46
  • \$\begingroup\$ IMO changing + to * and /2 to sqrt doesn't make this a different question and it's still a dupe. \$\endgroup\$ – Peter Taylor Feb 7 '17 at 9:53
0
\$\begingroup\$

ACME (Let's Encrypt) client

A list of ACME clients already looks a bit like a PPCG leaderboard, but I don't see the typical esolang roster there. Let's Augment.

The task is in minimum number of bytes get a valid certificate for specified domain (assuming running from a directory that is accessible from web server of this domain. Or just also embedding a web server.).

\$\endgroup\$
  • \$\begingroup\$ Shall usage of openssl (libary or binary) be allowed or it should be a "hard mode" puzzle? \$\endgroup\$ – Vi. Feb 7 '17 at 2:21
  • \$\begingroup\$ What does "assuming running from a directory that is accessible from web server of this domain" mean? That we can assume Apache / nginx / lighttpd / whatever is set up to execute our script? \$\endgroup\$ – Peter Taylor Feb 7 '17 at 9:51
  • \$\begingroup\$ @PeterTaylor, No. The script contacts ACME server, gets challenge, writes it to current directory. Then ACME server downloads the file (using pre-existing web server configured for this directory) and replies with a signed certificate, which we should save or print. \$\endgroup\$ – Vi. Feb 7 '17 at 11:56
  • \$\begingroup\$ Follow-up questions: 1. Which version of ACME? 2. Which parts must be supported? 3. What will the inputs to the client be? I'm sure that detailed reading of the ACME spec will throw up more questions. \$\endgroup\$ – Peter Taylor Feb 7 '17 at 12:49
  • \$\begingroup\$ 1. -> To discretion of the answerer, 2. -> HTTP challenge. Some minimal mode to get the cert. 3. -> Domain name. \$\endgroup\$ – Vi. Feb 7 '17 at 13:46
0
\$\begingroup\$

What I'm Planning to Post:

Print the number of bytes (not characters, bytes) in the program, without hardcoding the number (i.e. code like print(8) is not allowed).

If the code is added to (e.g. with a comment) it should change automatically without needing to change anything else.

Example (un-golfed) program in Python 3:

file = open(__file__)
data = file.read()
print(data)
file.close()

This is so the shortest answer in bytes wins.

What I Want to Check/Know:

  1. Does this count as ?
  2. Has this already been done? To what extent do the rules of a 'Duplicate' question apply here? (I have done some searching...)
  3. What should my challenge title be? I cannot think of any fitting ones.
  4. Should I include the example (un-golfed) program in my post, or does that make it too easy?
\$\endgroup\$
  • \$\begingroup\$ Thanks for posting in the Sandbox first. Why is hard-coding banned? If the code is added to, hardcoding may or may not help, so I don't see much point in banning this. Also, your code is wrong; that's a false-quine, not the program length. \$\endgroup\$ – wizzwizz4 Feb 9 '17 at 19:22
  • \$\begingroup\$ Sorry. I meant to put a len() in there too. Hard-coding is banned because in many esolangs, a single byte will just output the simple integer 1 (or similar). \$\endgroup\$ – retnikt Feb 9 '17 at 19:26
  • \$\begingroup\$ But if you edit the program to add comments, that program will stop working. \$\endgroup\$ – wizzwizz4 Feb 9 '17 at 19:30
  • \$\begingroup\$ Welcome to PPCG! Thanks for using the sandbox. I swear we've had a challenge similar to this, but I can't seem to find it. I'll keep looking. \$\endgroup\$ – AdmBorkBork Feb 9 '17 at 19:31
  • \$\begingroup\$ This wouldn't be a kolmogorov-complexity. That tag is for outputting some constant, predefined string. Including an example implementation is fine, it's fairly common practice, but usually it contains a very naive or brute-force algorithm for the problem that wouldn't actually make a good solution (even when golfed). \$\endgroup\$ – Business Cat Feb 9 '17 at 20:15
  • \$\begingroup\$ Yes, it has been done: codegolf.stackexchange.com/q/27079/194 \$\endgroup\$ – Peter Taylor Feb 10 '17 at 11:08
0
\$\begingroup\$

Wifi Puzzle! Crack the router [code-golf] [networking]

SITUATION

Consider that you have three wifi routers in your home , all with different SSIDs and none of them are dualband. You have invited a mischievous friend to your home who had changed the password of each router, without letting you know about it. Now to annoy you more he has set up a programming challenge.

THE CHALLENGE

Your friend has created three .txt files containing a set of passwords with only one correct among them. (i.e. each .txt file contains a correct password while all other are wrong ones. Also one .txt file contains only one correct password) and the .txt files do not specify which one may contain the correct password for a certain router (i.e. you cannot be sure that file1.txt(let us assume it is one of those .txt files) contains the password for router1( say any one of those routers). Now your friend has kept them in a certain directory( say E:\Wifi) and asked you to create a programme or function that would pick up a file and take input from it, try to connect to a random Access point ( out of the three routers) and find which password fits to which router.

Sample Input

Let us consider a file, file1.txt( or any other name you like) be like this

A12e77799U5
Pdc555089rtf
Ds442Y779#1
1&2*fe$996Yt
Uty66%92Gu4

Note that each password contains a capital letter, numbers, special characters, (of a standard keyboard) and each file contains only five unique passwords. Also all the .txt files are in the same directory and there are no subdirectories in the directory concerned. Also each .txt file contains at least one correct password.

Sample Output

Your programme or function must keep a log of its activity in a separate file log.txt which you may put in the same directory concerned or in a different directory. The log file must show which router has been cracked with which password and also the file containing it.

Example: Say that router1 ( SSID of a router) has been cracked by the password A12e77799U5 from file1.txt so the output of the log.txt must be

router1 password A12e77799U5
File: file1.txt

Also you must be sure that all the output goes into the log.txt not seperate files each time a router is cracked. You can create a programme or a function in any programming language.

Keep In Mind

  1. This is code-golf so the shortest answer wins.

  2. Standard loopholes apply as usual.

Discussion I feel to ask this question but the foremost problem I face is how can others test their code. Also strict I/o rules (like the log.txt I mentioned ) are not appreciated here. So please help me out!

\$\endgroup\$
  • 1
    \$\begingroup\$ So, you want us to access the network settings programmatically? Even if we disregard the difficulties in testing it, this is not a golfing challenge, but rather a challenge in convincing our OSes to let us fiddle with the settings, and then figuring out how. \$\endgroup\$ – John Dvorak Feb 12 '17 at 19:25
  • \$\begingroup\$ So is there any category I can put it in, I mean any tags. \$\endgroup\$ – jyoti proy Feb 12 '17 at 20:04
0
\$\begingroup\$

Portable bitmap checkerboard pattern

Your task is to create a checkerboard pattern and store it in a PBM.

Size of the checkerboard is passed in STDIN as two numbers. Output is written to STDOUT.

Test case:

Input:
5
5

Output:
P1
5 5
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

This is so the shortest code wins

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

Roman Dates

The Romans measured dates based on three days every month:
The Kalends, or the 1st
The Nones, which was usually on the 5th,
and the Ides, which was usually on the 13th.

In March, May, July, and October the Ides and Nones fall two days later, on the 7th and 15th.

Months

There are two forms of the months that matter for this challenge:
Ablative:

  1. Ianuariis
  2. Februriis
  3. Martiis
  4. Aprilibus
  5. Maiis
  6. Iuniis
  7. Iuliis
  8. Augustis
  9. Septembribus
  10. Octobribus
  11. Novembribus
  12. Decembribus

And Accusative:

  1. Ianuarias
  2. Februarias
  3. Martias
  4. Apriles
  5. Maias
  6. Iunias
  7. Iulias
  8. Augustas
  9. Septembres
  10. Octobres
  11. Novembres
  12. Decembres

Calculation of dates

On the day of one of them, they used the ablative of the day (Kalendis, nonis, or Idibus) combined with the ablative of the month (e.g. Idibus martiis)

One day before one of them they used pridie with the accusative of the day (Kalendas, Nonas, and Idus) and month (e.g. pridie nones septembres)

The Romans calculated the date as how many days until the next one of these, counting inclusively. They used a.d. and the number of days until the next one in lowercase roman numerals, and then the day and month in accusative (e.g. a.d. xxii Kalendas Iulias)

Years

The years are counted since the Founding of the city of Rome in 753 B.C.E., with A.U.C. appended to the end of it.

http://novaroma.org/nr/Roman_dates

The challenge is, give an input of a day, month, and year in any preferred format, to return a string given the Roman date.

As this is code-golf, the code with the shortest bytes wins, and the standard loopholes are disallowed.

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

Milking the cows

When I was a kid, we used to play a card game called "Milking the cows". I have no idea why it was called that, as it had nothing to do with said activity, but whatever. For months we would play furiously, seeing who was best at this game.

It wasn't until years later that I realized the game is completely deterministic. All my hours of practice turned out to have been pointless. But now it does make for an interesting code-golf.

Rules of the game

There are two players. Each is dealt half of a standard pack of shuffled cards. Every round, both players draw the top two cards from their respective decks and compare values. The highest scoring pair wins, and that player adds all captured cards to his stack of cards (at the bottom). In case of a draw, both players draw one additional card and compare again (If this is again a draw, another card is drawn, etc)

The game continues with both sides drawing cards until one player is unable to draw another card, at which point they lose and their opponent wins the game.

Card values are equal to the printed number for number cards, Aces are 11 points and J/Q/K are all 10.

The challenge

Given an input string of 52 characters representing the cards (without suit, since it doesn't matter in this game), deal the first 26 to player 1, the rest to player 2, and then determine who wins that match of Milking the cows.

The characters sent are 2,3,4,5,6,7,8,9,T,J,Q,K,A for the numbers, Ten, Jack, Queen, King and Ace. It can be assumed that the input string is correct and contains exactly 4 of each character.

The top of the stack is on the right side; the bottom of the stack is on the left side. Cards are always drawn or put back on the bottom one at a time

When a round is won, cards are added to the bottom of the winner's stack, starting with the opponent's cards and then the own cards, in the order they were drawn.

When the winner is determined, output the number of the player that won. It is possible (but phenomenally unlikely) for the game to end in a draw, because both players are unable to draw a card. In this case, output 0.

Example of a round:

Player 1's stack: QTKJ42336K59QKJ77T8J953485

Player 2's stack: JTK676ATQ8A576429Q2A948A23

Player 1 draws: 5, 8

Player 2 draws: 3, 2

Player 1 wins the round (13 points vs 5)

Player 1's new stack: 8523QTKJ42336K59QKJ77T8J9534

Player 2's new stack: JTK676ATQ8A576429Q2A948A

Testcases:

69K9A9QJ8TT33A88KQ685J97AQK224Q2726T73547K6J554J4AT3 -> 2
98JK947A5K283A5A2TAJ6K278T4TQT73674Q956JK94Q68QJ3352 -> 2
9T87J2K38KJT846558A2Q4A95395T67936A7Q2J4TQAK623JKQ74 -> 1
J67835828K48KA45TQ546JQ479TA2JT2Q933K27JT69KA9735QA6 -> 1
23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQKA -> 0

Scoring

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

\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! Thanks for using the sandbox. Can you elaborate a bit on what makes this much different than Determine the winner of a game of War? Is it just the fact that the top two cards are compared instead of only the top card? \$\endgroup\$ – AdmBorkBork Feb 14 '17 at 15:37
  • \$\begingroup\$ Ah, they're very similar indeed - I didn't know this game had different names in other languages. The biggest difference is probably checking for ties (which almost never happens) but I'm not sure if it's worth a new challenge. \$\endgroup\$ – Erik Feb 14 '17 at 15:40
0
\$\begingroup\$

Convert to polynomial base numbers


Background

Base Representation

Bases may be written with the following generalization (let concatenation just represent adjacency in digits; 10 = ab when a = 1, b = 0):

abcdex = ax^4 + bx^3 + cx^2 + dx^1 + ex^0

Essentially, we can write in any base we want such that the last digit is base to the power 0, penultimate digit is base to the power 1, etc. When we make the base a variable (x), we can represent a polynomial with a number.

Representation Overflow

Let's take our example before with abcdex. What happens when our representation for numbers (base 10 for our case) becomes too large to represent with a single character? Why, we use the tilda (~) on both sides of the value.

Thus, if we had the conditions a = 9, b = 32, c = 2, d = 43, e = 10 and were restricted to writing with base 10 representations for each value, our number may be represented as 9~32~2~43~~10~x.

Minimized Polynomials

For this challenge, I will occasionally refer to "Minimized Polynomials". When I say this, I mean that there will be no spaces in the polynomial string, terms with coefficients of zero will not be shown, and polynomials will be written in terms of greatest term first.

For example, the following is not a minimized polynomial:

x^2 + x^0 + 5 * x^4 + 0x^1

The following is the first example's minimized form:

5x^4+1x^2+1x^0

The Task

Given a valid minimized polynomial string input n, write a function or program which returns or prints the polynomial base representation of the value in base 10, allowing for representation overflow.

Examples

Let f be the function described in the task:

>>> f("1x^4+1x^3+1x^2+1x^1+1x^0")
1111

>>> f("6x^3+1x^1+5x^0")
6015

>>> f("20x^4+4x^3+1x^1")
~20~4010

>>> f("300x^6+30x^4+40x^3+2x^2+1x^0")
~300~0~30~~40~201
\$\endgroup\$
  • \$\begingroup\$ The introduction seems backwards to me. I think that what it's trying to express is that by representing numbers in base b you can show a bijection between the ring of natural numbers N and the ring of polynomials over the integers modulo b, (Z/bZ)[x], but that's not what it really communicates. In particular, "we can represent a polynomial with a number" seems to be talking about an injection Z[x] -> N (or maybe Z[x] -> Z), and while they do exist they're more complicated than anything described in this question. \$\endgroup\$ – Peter Taylor Feb 15 '17 at 16:55
  • \$\begingroup\$ In fact, the section on overflow explains why the ideas in the introduction break down. Once the coefficients cease to be elements of 0..b-1 base conversion gives aliasing. The workaround of introducing tildes means that what you have is no longer a base-b number, so the title is wrong. \$\endgroup\$ – Peter Taylor Feb 15 '17 at 16:58
  • \$\begingroup\$ @PeterTaylor I have no idea what your first comment is saying. Is your second comment suggesting that I rename this to "Convert minimized polynomial to shorthand polynomial" or similar? \$\endgroup\$ – Addison Crump Feb 15 '17 at 18:17
  • 1
    \$\begingroup\$ Really the whole stuff about base conversion is a red herring: the task consists in parsing a polynomial, filling in the zero coefficients, and then rendering them with conditional wrapping in tildes. \$\endgroup\$ – Peter Taylor Feb 15 '17 at 21:45
0
\$\begingroup\$

Multiplication puzzle using digits 1-9

The puzzle is to use the digits 1-9 inclusive, exactly once, to fill in the blanks such that:

_ _ _ _ * 3 = _ _ _ _ _

Your task is to create the shortest program that finds all solutions to the equation.

\$\endgroup\$
  • \$\begingroup\$ Is this exactly 4 characters * 3 = 5 characters? or is this any amount * 3 = any amount? \$\endgroup\$ – ATaco Feb 16 '17 at 0:12
  • \$\begingroup\$ Thanks for your comment. It's a 4 digit int multiplied by 3 = a 5 digit int \$\endgroup\$ – harryscholes Feb 16 '17 at 8:38
  • \$\begingroup\$ You should give the output list for reference. Submissions can hardcode an output, so if there's few solutions, you should change the problem so that there's many. \$\endgroup\$ – xnor Feb 16 '17 at 11:13
  • \$\begingroup\$ There are two solutions. It's not clear what output format is expected, but if 5823 5832 is acceptable output then hardcoding that is likely to be much shorter than any approach which uses calculation. \$\endgroup\$ – Peter Taylor Feb 16 '17 at 11:20
  • \$\begingroup\$ Should I edit the rules to say that the solutions can't be hardcoded and that the program must output both the 4 and 5 digit numbers? \$\endgroup\$ – harryscholes Feb 16 '17 at 14:15
  • \$\begingroup\$ You could for example change the hardcoded 3 to a number N which should be received as input. This way hardcoding the output becomes much less desirable. EDIT: Actually, I don't know if this puzzle also has solutions for other values of N \$\endgroup\$ – Leo Feb 16 '17 at 14:21
  • \$\begingroup\$ @Leo, yes, and it has loads for N=8. That's a great suggestion. \$\endgroup\$ – Peter Taylor Feb 16 '17 at 14:50
0
\$\begingroup\$

Mathematical Creativity

At our workplace we are so creative that sometimes we decide that today the number 2=9, 0=231 or 67=5... just for the sake of it. So for that day everyone in the workplace must consider that fact.

Your task is to write a full program or function that takes as input today's value of the decided number, which operation to perform and output the result, of course the new number's value affects also the result.

Input:

  1. Only positive integers >= 0and <= 1000000.
  2. The math operations to perform are only sum +, subtraction - or multiplication *.
  3. The input is taken from standard input in any reasonable format for example: [N V X + Y], N,V,X,+,Y, NVX+Y, ("N","V","X","+","Y"), ['N','V','X','+','Y'], etc.
  4. First parameter N is the choosen number.
  5. Second parameter V is new value of N.
  6. Third parameter X is the first number of the math operation.
  7. Fourth parameter is the math operation to perfom, can be only +, -, *.
  8. Fifth parameter Y is the second number of the math operation.

Explained example:

  1. Input 5,27,252,+,3.
  2. All the 5's becomes 27 so 254+3 -> 2272+3=2275 but the result is 2275, it contains 5 so it becomes 22727.
  3. No recursive substitution or infinite loop is needed. The substitution must be performed only once on X,Y and on the result.

Example inputs / outputs:

Input              > Output
----------------------------------------------
5,27,252,+,3       > 2272+3=22727 
45,0,237456,-,4567 > 23706-067=23639
9,7,349,*,7        > 347*7=2427
121,1,1212121,+,0  > 121+0=1
5,55,555,+,5555    > 555555+55555555=556111110
10,5,11000,*,10    > 1500*5=7500
1,2,3,+,4          > 3+4=7
4,4,3,+,4          > 3+4=7

Rules

  1. The number substitution must be performed only once on the first two numbers X,Y and only once on the final result. No recursive substitution or infinite loops are needed.
  2. The output must contain the full math operation, not only the final result, for example: 2272+3=22727.
  3. This is so the shortest code wins.
  4. Standard loopholes are forbidden.

Sandbox questions:

  1. Is this a duplicate of another question? I thought it would already exist but couldn't find any challenge by searching. If you know of it please let me know.
  2. Is the input enough clear or is it possible to improve in some way?
  3. Is the challenge clear?
  4. Tags:
  5. Suggestion for title?
\$\endgroup\$
  • \$\begingroup\$ Should the substitution be performed only once, or once for each occurrence, or recursively until no occurrence remains? Consider, for example, 121,1,1212121,+,0. Then you should also specify what happens with infinite loops. Compare with this proposal and my comment there. \$\endgroup\$ – Zgarb Feb 14 '17 at 14:32
  • 1
    \$\begingroup\$ What will the output be for input 5,55,555,+,5555? \$\endgroup\$ – Kritixi Lithos Feb 14 '17 at 14:32
  • \$\begingroup\$ @Zgarb thanks for pointing that out, only one-time substitution is needed on the first numbers and the result, no recursivity or loops. I added your example in the test cases. \$\endgroup\$ – Mario Feb 14 '17 at 14:46
  • \$\begingroup\$ @KritixiLithos I added your suggested example in the test cases. \$\endgroup\$ – Mario Feb 14 '17 at 14:47
0
\$\begingroup\$

Associativity Conversion

Operators that aren't associative usually come with some implicit associativity which let you omit parentheses in some expressions for readability. E.g. for a left-associative operator $, the following parentheses are assumed:

a $ b $ c $ d ≡ ((a $ b) $ c) $ d

But for a right-associative operator, the implied parentheses are these:

a $ b $ c $ d ≡ a $ (b $ (c $ d))

For this challenge, we will use an "invisible" operator (that is, we'll simply write abcd for ((ab)c)d or a(b(cd))). Your task is to take some valid expression of that operator as input, where the operator will be assumed to be left-associative. You should then output an equivalent expression, where the operator is assumed to be right-associative.

Example

Consider the input:

a(bc)(d(efg))

First, let's insert all parentheses that are implied by the operator's left-associativity:

(a(bc))(d((ef)g))

Now we want to rewrite this in a right-associative fashion. Therefore, we drop all parentheses start at the right end of a subexpression:

(abc)d(ef)g

We cannot remove any further parentheses because that would change the implied parentheses.

ToDo

small print and test cases

\$\endgroup\$
  • \$\begingroup\$ I'm not sure quite how to correct "Therefore, we drop all parentheses start at the right end of a subexpression". To make it parse it would suffice to change start to starting, but doesn't every parenthesis start at the right end of a subexpression? Perhaps it would be simpler to just add a tree diagram instead of adding parentheses? \$\endgroup\$ – Peter Taylor Feb 21 '17 at 22:51
  • \$\begingroup\$ @PeterTaylor I guess I meant "starting at the right end of the surrounding subexpression" but that's not much clearer. I'll think about it. \$\endgroup\$ – Martin Ender Feb 23 '17 at 16:05
0
\$\begingroup\$

Starry Starry Night

This challenge needs a lot of work in my opinion, especially refining rules on input-output, I want to leave it as open as possible, while excluding unfair methods such as pre-drawn graphs etc.

some parts of this are currently extremely vague, please ask any questions you believe might be important.

i'll be adding some graphics in to help explain what the challenge is about at a glance though.


Does anyone else sometimes looks up at the stars and ponder the great mathematical questions of our time, Does P=NP if you just want to check a bus timetable, can a 'try/catch' block solve the halting problem, and how far would that star need to move to form an equilateral triangle..


given an array of 6 numbers, consisting of 3 arrays containing two numbers between 0-255 each, i.e.

[[35,185],[141,8],[192,223]]

return the change required to be made to a single point, to have the three points form an equilateral triangle.

Input-

  • Can be taken as 6 distinct integers, an array of arrays, a single array, or a set of three objects with x/y as named/default properties,
    • these input formats are loose and whatever best suits your language should be used, within reason (i.e. - mathematica cannot use a pre-drawn graph as input)
  • no two points will be on the same x/y, and 0 will never appear as any single x or y co-ordinate

Output-

  • Only one out of the three co-ordinates can be modified, the other two must remain unchanged
  • Can be given graphically on a grid, a returned 'modified' version of the original input, or as an output of the values changed (i.e. 40->55;30->99)
  • you're looking up at the sky, your numbers can easily be off by a bit, the returned values are only required to be accurate to the whole number, rounding up or down is allowed
  • you do not have to achieve the smallest distance, or smallest/largest resulting triangle, any mathematically equilateral triangle will be correct

Examples:(still have to actually calculate these) [[20,113],[63,17],[40,161]] [[43,119],[183,197],[103,86]] [[144,216],[108,203],[113,199]] [[197,131],[217,7],[13,77]] [[100,60],[26,107],[130,241]] [[209,61],[208,98],[47,94]] [[48,78],[179,135],[52,119]] [[93,148],[124,226],[137,118]] [[65,21],[168,167],[221,56]] [[89,118],[48,181],[29,98]]

\$\endgroup\$
  • \$\begingroup\$ When you say "rounding is not strict, and can be 1 number either side of a resulting decimal value" does that mean that the output can be a whole number obtained by rounding up or down? \$\endgroup\$ – Peter Taylor Feb 21 '17 at 12:28
  • \$\begingroup\$ @PeterTaylor that's correct, i'll clarify it a bit further, would the returned values are only required to be accurate to the whole number, rounding up or down is allowed be a bit more specific? \$\endgroup\$ – colsw Feb 21 '17 at 14:38
  • \$\begingroup\$ Yes, that's fine. The really ambiguous part was "1 number", where it wasn't clear how many decimal places were expected. \$\endgroup\$ – Peter Taylor Feb 21 '17 at 14:43
0
\$\begingroup\$

Triangular Numbers

Compute the nth triangular number. Triangular numbers are the number of things in a size x triangle (n(n+1)/2).

Testcases:

0 0
1 1
2 3
3 6
7 28
34 595

IO in any allowed form, standard loopholes apply.

\$\endgroup\$
  • 1
    \$\begingroup\$ This would make for an interesting challenge, but the question is highly unlikely to receive many upvotes without more explanation (clearer spec, test-cases, the definition of the triangular numbers, etc. The definition is important because we require that challenges should require as little knowledge/research to solve as possible) \$\endgroup\$ – ETHproductions Feb 23 '17 at 23:45
  • 1
    \$\begingroup\$ Also, this is a subset of Polygonal Numbers! (though that may not matter as there may be different golfy approaches in various languages, and also that challenge wasn't taken very well and has few answers) \$\endgroup\$ – ETHproductions Feb 23 '17 at 23:47
0
\$\begingroup\$

Ultimatum Game

You and a (not so) friendly bot have a chance to play a game. There is 100 dollars on the table. One person, suggests a split, and the other can accept the split, or force each individual to accept absolutely nothing. You will alternate being able to give the ultimatum for a substantially large number (1000) rounds. This process will proceed in a round robin fashion till every bot has played all the others exactly once. Your score in this manner, will just be the total amount of money you collect.

Now your job is to write a bot that will play this game. You will be provided with needed information as command line arguments.

A sample invocation will look like this if you are giving the ultimatum. When you receive an invocation like this, you would be the one propsing a split.

foolanguage myBot.foo 4 ultimatum 1 reject 10 reject 20 reject 25 accept 

Or, like this if you are the one considering the ultimatum. You will be tasked with either accepting the split, or rejecting it (both bots get 0).

foolanguage myBot.foo 4 accepting 1 reject 10 reject 20 reject 25 accept 1

The first number represents the number of rounds played (n). The second will be a string either "Ultimatum" or accept/ reject. Next will follow 2n+1 strings. The first 2n will be offers and what the choice was. The last string will be the current offer.


Entering

You will provide a command stem and a unique bot name. So the sample bot can be called fooBot, and the command stem (after which arguments are appended) looks like "foolanguage myBot.foo"

Your bot will then output either the number it will offer, or (if they are the one who has to consider the offer), ("a" for accept/ "r" for reject) within 50 ms.

Your bot must be be able to make both choices (accept or reject). No locking in to just one choice.

Also, your bot must be deterministic (prng's may be seeded with a private seed. If you wish to do this, insert a dummy seed, and change it right before the competition) please publish the hash to ensure you don't tweak it in light of other submissions.

In the spirit of fair competition, no access to the file system (or OS calls). I will allow the option to write to a maximum of one text file which can have a maximum size of 8 megabytes. Solutions will be tested within a virtual machine imaged with the latest version of linux on my home desktop which has an Intel i7-4770 quad core 3.4 gHZ cpu.

\$\endgroup\$
  • \$\begingroup\$ I believe we already have had a prisoners dilemma KOTH... \$\endgroup\$ – fəˈnɛtɪk Feb 25 '17 at 21:34
  • \$\begingroup\$ @LliwTelracs I do believe the strategy here is entirely different, and brings up some interesting effects. Most notably, the asymmetry of the situation, and the information which you have. \$\endgroup\$ – Rohan Jhunjhunwala Feb 25 '17 at 21:55
  • 1
    \$\begingroup\$ 1. I suggest rewriting the input spec to pass via stdin instead of the command line. Some shells have command line length limits: e.g. on most versions of Windows you'll only be able to get up to about 820 rounds with the current format. Using stdin would also allow newlines, which would make the format easier for humans to read and understand. Also, what does the accepting in the second example mean? 2. I presume that the score is the total amount of money you make over all rounds and all games, but this should be made explicit. \$\endgroup\$ – Peter Taylor Feb 26 '17 at 8:52
  • \$\begingroup\$ I fear this challenge would be dominated by bots offering a 99/1 split and accepting any offer of at least 1 dollar, with no consideration for the history \$\endgroup\$ – Leo Feb 26 '17 at 13:57
  • 1
    \$\begingroup\$ @Leo I plan on creating a few sample bots, which will mimic human behavior. For example, one bot might reject offers less than 25. Another, might grew more and more likely to reject offers based on the average money allocated. Another might only offer (and accept) splits of 50/50 (or better). This way, good solutions will cater to such bots. \$\endgroup\$ – Rohan Jhunjhunwala Feb 26 '17 at 14:07
  • \$\begingroup\$ I was going to write a 50/50 bot, so I would be sad if that's already taken by a sample bot - unless the samples are clearly only for development and not participating in the final contest. \$\endgroup\$ – Peter Taylor Feb 27 '17 at 9:26
  • \$\begingroup\$ @PeterTaylor sure, I could make it that way, sample bots are only for developement \$\endgroup\$ – Rohan Jhunjhunwala Feb 27 '17 at 11:50
0
\$\begingroup\$

Board Game Breaking - The Front Nine W.I.P.

Eventually I will make a post here for each of the challenges. This post is for discussing them as a series. If you have an idea for a good board game breaker, please share!

Introduction

Board Game Breaking is a series of challenges that harness computing power in order to 'break' a game (i.e. ensure no one will play with you). Each challenge will revolve around creating a tool that analyzes the board game in a way that will give you some advantage. There are nine challenges total.

BGB #1 - Number Rings

  • Input: Int
  • Output: Likelihood of creating that int with 3d6 & +-*/

Number Rings

BGB #2 - Can't Stop!

  • Input: 1-3 Ints
  • Output: Likehood 2 (of 4) d6 will add up to one of the inputs

Can't Stop

BGB #3 - Axis & Allies

  • Input: # of units on each side
  • Output: Probability of winning the fight

Axis & Allies

BGB #4 - Labrynth

  • Input: Image
  • Output: Image re-arranged in labrynth-like way to make gradient

Labrynth

BGB #5 - Scrabble

  • Input: Word list
  • Output: Word with most subwords

Scrabble

BGB #6 - ??

BGB #7 - ??

BGB #8 - ??

BGB #9 - ??

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

Penrose Triangle Codegolf

The Penrose triangle, also known as the Penrose tribar, or the impossible tribar, is an impossible object. - Source

The goal in this challenge is to display a Penrose triangle in the fewest bytes possible.

Rules:

  1. You must display the Penrose Triangle digitally after generating it.

Good luck and have fun!

\$\endgroup\$
  • \$\begingroup\$ Rule 2 is unnecessary because it applies by default. Rule 1 is a disaster which is guaranteed to prompt arguments over which minimalist ASCII art answers actually represent a Penrose triangle. \$\endgroup\$ – Peter Taylor Feb 27 '17 at 9:24
  • \$\begingroup\$ @PeterTaylor I guess that makes sense. \$\endgroup\$ – arodebaugh Feb 27 '17 at 11:28
0
\$\begingroup\$

BGB #1 - Number Rings

Goal: Take an int, output the probability of creating that int with 3d6 & +-*/.

Number Rings

Introduction

Check here

Background

Number Rings (or Sector 18) is a board game where up to 4 players take turns rolling a set of 3 six-sided dice. Then then using +-*/ to combine all three of those numbers to get a number, x. They then place (or remove) a ring on a x peg. First player to have a ring on each of his pegs, wins. That is the basic idea of how the game works.

For any number a, I want to know the probability that I will be able to create a with a random roll.

Specification

  • Input
    • One integer, i, such that 0<i<19
    • The input is flexible
  • Output
    • The probability of being able to create i with a random roll
    • At least 5 digits of accuracy
    • Ex: 0.12345. .12345, 12.345
    • Or exact rational number
    • Ex: 145/1023
    • Leading/Trailing whitespace is acceptable
  • Scoring
    • Shortest program/function in bytes wins

Test Cases

ToDo

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

BGB #2 - Can't Stop!

Goal: Take 3 ints, output the probability 2 of 4d6 will sum to one of the ints.

Can't Stop

Introduction

Check here

Background

Can't Stop is a board game. There are columns for the numbers 2 through 12, each having a number of rungs that must be climbed into to win the column. On a player's turn, they receive 3 white pieces and 4d6. They roll the dice, sum two of the values and either move a placed white piece up a rung or place a white piece in a column. First player to win 3 columns, wins the game.

For any numbers, a or a,b or a,b,c, I want to know the probability that I will roll at least two numbers that sum to a, b or c

Specification

  • Input
    • One to three integers between 2 and 12 inclusive
    • Taking 3 integers that aren't necessarily distinct is also acceptable
    • The input is flexible
  • Output
    • The probability of being able to create one of the inputs with a random roll
    • At least 5 digits of accuracy
    • Ex: 0.12345, .12345, 12.345
    • Or exact rational number
    • Ex: 145/1023
    • Leading/Trailing whitespace is acceptable
  • Scoring
    • Shortest program/function in bytes wins

Test Cases

ToDo

\$\endgroup\$
  • \$\begingroup\$ What about output as exact rational number? Is input flexible enough to say that there are always three numbers but they don't have to be distinct? \$\endgroup\$ – Peter Taylor Feb 27 '17 at 0:07
  • \$\begingroup\$ @PeterTaylor Great questions! Yes to both. I modified the challenge to make that clear. \$\endgroup\$ – NonlinearFruit Feb 27 '17 at 0:28
0
\$\begingroup\$

Unschedule my tasks

Intro

I have a scheduler that uses priority scheduling on my PC so there are several tasks with a definite priority. All that i still remember is that every task runs cyclically forever with an also definite period. I can see which tasks are running from t=0 to now, but i need to know the priority and the period time of every task.

Input

The input is a string with the length n showing the last n timestamps. We give the tasks uppercase letters from A...Z, where the amount of different tasks k is given as 0<k<27. If one tasks is chosen, it will need one time stamp long to finish and will start after it's period time T again. Example:

not given:
task A: priority=2, T=7
task B: priority=1, T=2
task C: priority=3, T=5

results in:
A      A      A      A      A      A      A
B B B B B B B B B B B B B B B B B B B B B B
C    C    C    C    C    C    C    C    C
_____________________________________________
BABCBCBAB BCB BABCB BABCBCB BABCB BABCB BCBA

The last line will be your input and the goal is to get every task with the corresponding priority and period time.

Output

So for the input

BABCBCBAB BCB BABCB BABCBCB BABCB BABCB BCBA

You should output

A 2 7
B 1 2
C 3 5

The output should have the format [task name] [priority] [period time] with one task per line.

Rules

  1. All tasks will always start at t=0
  2. If multiple tasks are ready to run, the one with the lower priority will run first, the other one will move one slot to the right
  3. The priority of one task is always the same, so no dynamic priorities will be used
  4. The processor will never have to run at 100%, or as formula: 1/TA + 1/TB + ... + 1/Tk < 1. In the example it's 1/7 + 1/2 + 1/5 = 0.84 < 1
  5. If there are multiple solutions, output only one of them
  6. The input string will show every task at least 3 times

Test cases

in:
A  A  A  A
out:
A 1 3

in:
CBA   CBA   CBA   CBA   CBA   CBA   CBA   CBA
out:
A 3 6
B 2 6
C 1 6

in: 
//A      A      A      A      A      A
//B   B   B   B   B   B   B   B   B   B
//C    C    C    C    C    C    C    C
//D             D             D
//E        E        E        E        E
  ABCDBCEABEC B ACBDE BAC BC EABCDB  ABCE
out:
A 1 7
B 2 4
C 3 5
D 4 14
E 5 9

Thoughts

Still thinking about turning the question around. Just turning input and output around but i like this way more because i think it's more challenging.

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

Effective street lighting


You are the operator of a town's street lamps. Each road has one or more lamps. When it's night, every part of the road must be lit, which means that either the lamp above it, or both lamps next to it must be on. Your job is to light each street in the most energy-efficient way. The problem is, each lamp has its own power consumption.

Your task:

  • Take an input consisting of the consumption of each lamp in a single street;

  • Output the minimal consumption of the street so that all spaces are lit;

  • And have your program calculate this in a reasonable time (will be specified) for at least 50000 lamps with a maximum consumption of under 1000.

Notes:

  • Input can be taken in any simple list format (e.g. newline-separated; space-separated; as an array)

  • There will be at least one lamp

  • Each lamp's consumption will be a positive integer

  • An alternative statement of the condition for a valid subset of lamps is that the first and last lamp must be lit, and no two consecutive lamps may be unlit

  • The output is a single integer (and will fit in a 32-bit signed integer type)

  • Trailing spaces and newlines are allowed in output


Test cases:

10 -> 10

15 20 -> 35

10 20 40 30 30 40 -> 100

534 954 444 154 431 818 550 486 294 449 247 766 216 400 924 728 821 845 724 807 585 555 379 939 591 601 263 76 976 567 -> 7646

12 357 925 826 727 565 444 897 474 546 564 306 931 293 503 895 320 79 790 241 441 301 423 290 390 556 529 797 123 292 692 653 648 336 480 95 619 923 710 93 188 992 118 120 5 339 733 324 417 242 284 857 542 706 866 651 262 395 448 103 686 858 756 54 195 954 866 813 877 295 625 784 287 461 903 291 799 636 334 216 878 617 791 139 323 657 789 303 770 956 406 176 814 880 229 727 834 813 260 711 108 884 495 394 64 117 404 862 472 737 796 69 354 587 207 676 963 715 697 733 671 103 908 204 982 855 931 535 668 909 247 775 793 460 888 575 296 292 437 767 747 951 835 101 538 42 495 220 756 192 672 146 14 580 350 714 155 999 250 822 908 215 317 420 674 923 994 969 933 150 455 680 101 290 780 357 332 993 577 806 185 249 671 916 547 21 631 701 738 880 243 646 95 278 66 487 201 778 176 852 927 630 532 746 920 31 103 970 24 398 495 926 365 166 843 912 186 474 332 642 73 293 288 167 570 72 653 489 849 547 341 776 178 591 241 98 340 344 786 363 741 281 9 825 447 570 456 351 44 787 993 116 799 281 1 88 353 372 577 920 919 636 697 97 946 937 912 286 999 698 368 460 978 95 285 425 664 740 495 707 246 488 541 763 487 260 851 558 631 147 479 550 782 894 365 447 550 277 452 550 974 819 10 672 913 13 815 296 471 310 721 435 516 262 199 4 240 50 561 870 196 40 140 696 652 504 862 203 500 314 752 193 133 480 864 764 211 399 60 681 708 499 834 225 479 33 946 718 800 226 307 714 984 446 411 636 669 273 838 887 305 590 80 437 788 663 919 998 780 697 398 488 196 233 431 674 983 96 392 784 322 698 217 306 863 346 941 251 337 780 138 641 89 935 796 877 598 715 594 378 131 992 585 326 943 734 718 926 830 828 429 870 246 365 176 109 710 835 359 48 615 215 688 423 150 485 19 467 918 612 844 50 323 148 94 984 601 531 630 431 359 59 20 323 142 195 150 852 748 227 899 83 441 306 505 591 509 523 58 147 853 620 914 895 487 8 879 88 257 509 237 335 287 256 657 428 450 807 280 916 34 897 998 475 922 503 784 431 744 841 577 317 180 210 212 666 936 91 753 193 319 989 527 605 245 903 751 413 710 750 330 462 647 328 655 288 550 439 719 294 998 15 610 179 943 821 844 879 631 598 72 949 587 318 273 551 221 24 963 649 773 12 111 140 340 766 427 889 923 864 901 922 598 512 101 541 52 944 139 401 542 210 69 848 527 60 399 466 802 81 115 294 93 944 433 151 710 579 40 633 162 659 555 478 171 374 737 941 319 875 61 579 804 130 146 50 189 263 516 709 344 349 4 155 293 436 305 721 733 63 74 614 721 347 92 611 721 548 271 758 423 331 337 227 179 483 277 87 745 511 795 807 859 798 961 153 953 984 592 686 47 665 300 487 13 111 98 452 658 368 210 799 417 546 27 596 747 22 682 493 532 477 300 391 994 980 262 947 964 854 633 730 519 652 217 250 481 314 701 139 400 910 937 535 457 682 131 204 703 531 415 235 727 434 345 721 414 606 668 97 460 20 826 698 671 43 947 152 75 649 9 193 559 665 728 16 347 577 938 769 109 72 722 835 505 67 556 637 673 942 453 851 961 279 549 633 41 497 503 833 146 231 745 704 895 473 439 960 768 96 729 876 167 452 430 672 237 704 28 909 646 480 761 608 478 310 959 237 806 181 70 670 411 533 375 25 6 532 985 493 627 433 369 793 603 518 465 840 222 212 749 868 691 229 195 169 539 154 405 64 334 194 734 464 726 827 488 451 359 473 943 985 625 31 778 228 548 962 68 489 174 536 357 583 764 551 471 22 423 875 804 475 787 257 938 233 84 427 402 161 618 345 146 243 94 642 190 361 604 975 849 496 230 924 80 994 194 550 734 616 144 257 91 650 232 748 882 315 893 284 194 511 347 339 473 159 981 381 519 304 356 368 519 586 11 317 299 204 585 751 538 447 727 348 97 958 96 697 274 988 699 467 499 764 525 690 923 225 71 161 247 146 248 765 731 258 82 748 462 666 499 999 114 226 347 928 185 161 345 177 149 762 362 367 527 605 57 169 829 846 329 77 991 576 560 441 553 642 189 15 27 687 732 858 632 80 506 816 240 850 711 108 612 73 474 857 678 249 26 226 813 355 302 523 649 581 963 202 223 152 934 967 558 667 826 190 465 332 724 423 900 435 530 512 226 722 89 622 690 114 848 503 187 868 27 555 449 989 756 390 860 410 358 418 77 184 326 260 234 50 682 852 484 931 83 428 653 171 51 343 285 898 565 190 485 310 744 934 299 220 324 877 629 400 295 424 302 339 683 535 388 84 387 590 15 189 19 387 359 69 448 643 685 13 833 170 322 296 822 340 515 147 935 862 265 949 286 567 288 687 820 676 490 926 984 504 115 3 609 473 789 58 835 474 788 387 363 829 682 185 887 916 50 822 778 315 771 783 600 60 470 420 454 678 346 438 183 460 160 791 933 948 567 768 142 356 155 504 185 555 407 72 471 176 612 250 209 384 33 808 162 221 228 615 899 574 53 800 752 212 310 685 879 877 172 21 233 45 243 136 600 368 925 71 543 537 39 751 920 789 278 82 11 506 415 628 798 187 147 550 117 456 954 995 52 844 16 3 889 976 856 208 345 781 278 887 319 317 358 -> 245300

Standard rules apply.

[Sandbox note: I'd be grateful for any help on this challenge. It looks trivial - that's what I think caused the negative feedback. Any help or notice accepted! (ungolfed Java program)]

\$\endgroup\$
  • 1
    \$\begingroup\$ There are quite a few minor improvements which could be made in the explanation: I'll edit in a rewrite proposal, which you can revert if you don't like it. As for being trivial: it is sufficiently trivial that I personally wouldn't upvote it on main (basically it's folding min, and the first version I wrote in CJam worked first time and is probably as short as it gets in CJam - your example Java code is far more complicated than it needs to be), but there are plenty of questions which are more trivial. \$\endgroup\$ – Peter Taylor Dec 20 '16 at 11:41
  • 1
    \$\begingroup\$ For "reasonable time", I think 1s would be reasonable in most languages, and I don't think anyone's likely to attempt the challenge in a language in which it wouldn't be reasonable (because working with arrays in those languages is not fun). \$\endgroup\$ – Peter Taylor Dec 20 '16 at 11:51
  • \$\begingroup\$ @PeterTaylor Firstly, thanks for the edit; I might edit again later though. As to your comments: I had designed my Java code example to give me results for 1'000'000-lamp streets, and also somewhat complicated the code before posting it here. Finally, 1s for 50000 lamps seems too much for me, but I don't think I'll put a time limitation into the final challenge. TL;DR: thanks for the help! \$\endgroup\$ – RudolfJelin Dec 20 '16 at 14:34
  • 1
    \$\begingroup\$ 1s for ten million lamps is generous in languages like C and Java (I get 50ms for ten million in C#), but less so for languages which run on multiple layers of interpreters. I like having a time limit, because it pushes people to think about their approach rather than brute-forcing (which is usually shorter but takes time exponential in the size of the input), but the point is to cut out exponential time solutions rather than to make the constant in linear-time solutions significant. \$\endgroup\$ – Peter Taylor Dec 20 '16 at 15:01
  • \$\begingroup\$ @PeterTaylor I'll consider that, thanks for informing. \$\endgroup\$ – RudolfJelin Dec 20 '16 at 15:55
0
\$\begingroup\$

Schedule my tasks

Intro

Inverse challenge to Unschedule my tasks.

I don't have a scheduler that uses priority scheduling on my PC but i want one. I have several tasks which all start at t=0 and each has a priority and a period time. So your task is to schedule my tasks.

Input

The input is a string including the different tasks, the priority and the period time of each task. We give the tasks uppercase letters from A...Z, where the amount of different tasks k is given as 0<k<27. If one tasks is chosen, it will need one time stamp long to finish and will start after it's period time T again. The input has the format [task name] [priority] [period time] with one task per line. Example:

A 2 7
B 1 2
C 3 5

Output

So for the input

A 2 7
B 1 2
C 3 5

you should output (only the last line):

A      A      A      A      A      A      A
B B B B B B B B B B B B B B B B B B B B B B
C    C    C    C    C    C    C    C    C
_____________________________________________
BABCBCBAB BCB BABCB BABCBCB BABCB BABCB BCBA

Rules

  1. All tasks will always start at t=0
  2. If multiple tasks are ready to run, the one with the lower priority will run first, the other one will move one slot to the right
  3. The priority of one task is always the same, so no dynamic priorities will be used
  4. The processor will never have to run at 100%, or as formula: 1/TA + 1/TB + ... + 1/Tk < 1. In the example it's 1/7 + 1/2 + 1/5 = 0.84 < 1
  5. If there are multiple solutions, output only one of them
  6. The output string has to show every task at least 3 times, but the the output has to be finite
  7. Priority and period time are unsigned integers in the range 0<x<50

Test cases

in:
A 1 3
out:
A  A  A  A

in:
A 3 6
C 1 6
B 2 6
out:
CBA   CBA   CBA   CBA   CBA   CBA   CBA   CBA

in:
A 1 7
B 2 4
C 3 5
D 4 14
E 5 9
out: 
//A      A      A      A      A      A
//B   B   B   B   B   B   B   B   B   B
//C    C    C    C    C    C    C    C
//D             D             D
//E        E        E        E        E
  ABCDBCEABEC B ACBDE BAC BC EABCDB  ABCE
\$\endgroup\$
0
\$\begingroup\$

You Jelly?

In this code challenge you are here to explain Jelly code for us simple-minded plebeians. To simplify things we are working in a restricted subset of Jelly.

Details

The input will be a Jelly leading constant chain matching the regex `/([01H+] )+/. For full explanation, see the Jelly tutorial, but as a quick summary each symbol in Jelly represents a function with an arity of 0 (is a nilad), 1 (a monad) or 2 (a dyad). A chain is a sequence of symbols. A leading constant chain is a chain whose first element is a nilad and is followed by any number of subsequences that are any of a monad, a dyad followed by a nilad or a nilad followed by a dyad. Jelly is parsed left to right.

As implied by the regex restriction, the source consists of four symbols: 0, a nilad whose value is the integer 0; 1, a nilad whose value is the integer 1; H, a monad whose value is the function x -> x / 2; or +, a dyad whose value is the function x, y -> x + y.

A leading constant chain over the above symbols is evaluated into an equivalent infix formula by the following rules (where $d represents 1 or 2).

eval("$d $chain") = eval_i("$chain", "$d")
eval_i(""           , expr) = expr
eval_i("+ $d $chain", expr) = eval_i("$chain", "($expr + $d)")
eval_i("$d + $chain", expr) = eval_i("$chain", "($d + $expr)")
eval_i("H $chain"   , expr) = eval_i("$chain", "($d / 2)")

Your task is to take a Jelly program under the following restrictions (only the three symbols above used, always separated by exactly a single space and forming a leading constant chain) and to output a string representing a traditional infix-notation representation of the input. The output of your solution may be equivalent the specified output up to whitespace and PEMDAS rules (i.e. parentheses may be dropped when it does not change the meaning).

Examples

Jelly Program ->      Infix Notation
1             ->                   1
0 H           ->             (0 / 2)
1 0 +         ->             (0 + 1)
1 + 0         ->             (1 + 0)
0 H 1 +       ->       (1 + (0 / 2))
1 1 + H       ->       ((1 + 1) / 2)
1 0 + + 0     ->       ((0 + 1) + 0)
1 0 + H + 0   -> (((0 + 1) / 2) + 0)

Judging

This is code-golf, so lowest byte count wins. Standard loopholes are disallowed. Standard input-output formats (function-or-program) are in play.

\$\endgroup\$
  • \$\begingroup\$ "You Jelly?" is not >= 15 characters, unfortunately \$\endgroup\$ – MildlyMilquetoast Mar 1 '17 at 5:02
  • \$\begingroup\$ @MistahFiggins oh drat :P. I created this challenge entirely for the title... \$\endgroup\$ – walpen Mar 1 '17 at 5:14
  • 1
    \$\begingroup\$ "Are you Jelly?" is 14... maybe a sneaky space or question mark \$\endgroup\$ – MildlyMilquetoast Mar 1 '17 at 5:23

You must log in to answer this question.

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