461
\$\begingroup\$

What is the Sandbox?

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

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

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

\$\endgroup\$
  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43

2621 Answers 2621

0
\$\begingroup\$

Peano's quine

Your task is to write two programs in the same programming language.

The first program is simply a quine, in the following called "zero quine".

The second program, called succesdor program, is a program that gets a program text as input, and outputs another program text, according to the following rules:

  • The input text is either the zero quine, or code that is (or could be) the output of another run of the successor program.

  • The output is again a quine in the same language.

  • The zero quine, generated quines and successor program fulfil Peano's axioms. In particular:

    1. The successor function does never output the zero quine, no matter what the input is.

    2. The successor function produces different output when acting on different valid input.

In other words, the zero quine and the successor function together allow to generate an unbounded number of quines, one for each natural number.

The score is the total number of bytes of the zero quine and the successor program together.

Note that while there are several challenges that have programs returning longer versions of itself when run, I didn't find any that has a program transforming a proper quine into another proper quine.

Tags:

\$\endgroup\$
  • 2
    \$\begingroup\$ This is extremely similar to quine loops. It just needs a quine which has a literal (int or string) it ignores and a program which respectively increments it / appends a character to it. \$\endgroup\$ – Peter Taylor Nov 4 '16 at 8:26
0
\$\begingroup\$

Match the BF output

Your task is, when given a BF program as input and 256 1's on the line after the BF program, match the amount of 1's equal to the value of the pointer when the program halts.

For a BF tutorial, see here.

Example programs:

+++
(255 1's)

(The above program should match 3 1's.)

++[>+++>+++<<-]>
(255 1's)

(The above program should match 6 1's.)

Specs:

  • The tape in question is 10 long, with wrapping.
  • There is wrapping for the individual values: if it goes over 256, it goes back to 0.
  • There is no , or . in the BF code.
  • You are guaranteed that the code will terminate.
  • You may use any flavour you want.
  • You may match 1's in any position, as long as you match the correct amount of 1's.

This is , so shortest code in bytes wins!

Meta stuff:

  • How hard would this be to pull off? Is it even possible?
  • Anything I could improve with explanations?
\$\endgroup\$
  • 1
    \$\begingroup\$ 1. I think it should be "the value of the memory cell under the pointer" rather than "the value of the pointer". 2. This is clearly impossible using regular expressions, but it is possible using Perl 5's regexes, which are Turing-complete. However, at that point you're really just using Perl wrapped in regex notation, so it's arguably a dupe of codegolf.stackexchange.com/q/84/194 \$\endgroup\$ – Peter Taylor Nov 8 '16 at 7:30
  • \$\begingroup\$ @PeterTaylor Your second claim is false. With a wrap around BF becomes a finite state machine. Thus even it's halting problem is solvable by a push down automaton (regex). It may be extremely hard but this problem is most certainly solvable. \$\endgroup\$ – Wheat Wizard Nov 8 '16 at 17:04
  • 1
    \$\begingroup\$ @WheatWizard, although my initial reaction was to agree with you, on further reflection I'm not entirely convinced. The halting problem for a finite state machine is trivial: they always halt. Since a BF program can enter an infinite loop, it's therefore not an FSM. It's true that any given program has a finite number of states, but the state includes the program counter and so the ecosystem as a whole can have an unbounded number of states. Consider that in execution we can jump back along the program string an arbitrary distance: how can a pushdown automaton remember the contents of a loop? \$\endgroup\$ – Peter Taylor Nov 8 '16 at 20:48
  • \$\begingroup\$ @PeterTaylor iirc finite state machines can loop infinitely however any loop must be periodic. I don't know why you claim finite state machines cannot loop. Toroidal Brainfuck fits every definition of a FSM I can find at the moment. It has a finite number of states and a well defined mapping of each state to another. I also don't understand what you mean when you say "Program counter" if you are referring to the instruction pointer it is certainly finite. Could you clarify this? I don't mean to be argumentative, but I do disagree with you. If I am incorrect I am sorry for wasting your time. \$\endgroup\$ – Wheat Wizard Nov 8 '16 at 23:36
  • \$\begingroup\$ @PeterTaylor If it helps, the input program is guaranteed to halt. Would it be easier to decide if there are a limited number of "moves" (i.e. 30,000 moves, 1 move = any +-><)? \$\endgroup\$ – clismique Nov 9 '16 at 5:03
  • \$\begingroup\$ @WheatWizard, the point with FSMs and the halting problem is that each state transition occurs with one character of the input, each character of the input is processed only once, so therefore the execution time is bounded by the length of the input. On the main point, I'm not saying that you're wrong: just that I'm not convinced. Perhaps the thing to do is to edit the question to rule out "cheating" by calling out to a general-purpose programming language and then see whether anyone finds a solution. \$\endgroup\$ – Peter Taylor Nov 9 '16 at 7:36
  • \$\begingroup\$ Limiting the runtime would certainly make it doable, because then the values which the program counter (or instruction pointer, they're synonymous) can reach are bounded, and so the total number of states is bounded by the number of memory states times the number of moves. It's not a practical bound, but in theoretical terms it's certainly good enough. \$\endgroup\$ – Peter Taylor Nov 9 '16 at 7:37
  • \$\begingroup\$ @PeterTaylor So I'm getting the "this is impossibly hard" gist - but is it on the same level as "Tetris in GoL"? I want to make a challenge that's difficult, but not THAT difficult. \$\endgroup\$ – clismique Nov 9 '16 at 9:59
  • \$\begingroup\$ I just realized that vanilla regex (without lookarounds) is a finite state machine and not a push down automaton. I think PeterTaylor is correct in assessing this as impossible. \$\endgroup\$ – Wheat Wizard Nov 9 '16 at 14:15
0
\$\begingroup\$

Find the highest product in a grid

The following problem was inspired by Problem 8 at Project Euler.

Write a program that takes a 2-dimensional block of digits and a number on a newline ("n") as it's input. Output value of the product of the n adjacent (read "in a straight line") digits in the that have the greatest product. Error cases don't need to be covered (eg. the grid is not rectangular, n is missing, n is bigger then the width/height as the block, etc.). Diagonal numbers are also adjacent.

Examples:

1932       
4836       
8490  -->  288
3          

53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881  -->  5832
16427171479924442928230863465674813919123162824586
4

43289
90283
03248  -->  error (print whatever)
34290
22

397432008949201741720 --> 72
2

Note: possible inputs below are equivalent:

2830
0309
8011 
4

2 8 3 0
0 3 0 9
8 0 1 1 
4

{{2, 8, 3, 0},
{0, 3, 0, 9},
{8, 0, 1, 1}}
4

And so on, it's not strict.

It's , so the shortest answer in bytes wins!


\$\endgroup\$
  • \$\begingroup\$ @TimmyD 2-8-3-9 :P Thanks for the notice, fixed now! \$\endgroup\$ – RudolfJelin Nov 9 '16 at 19:23
  • 3
    \$\begingroup\$ PPCG as a whole isn't a fan of strict input formats. In particular, function (which are allowed by default) should probably be able to take a matrix and a separate integer as arguments. \$\endgroup\$ – Dennis Nov 10 '16 at 1:20
  • \$\begingroup\$ @Dennis Thanks for notifying me, I didn't see that issue since I'm new to this site. I edited my proposal a bit also. \$\endgroup\$ – RudolfJelin Nov 10 '16 at 14:31
0
\$\begingroup\$

Absolutely correct !

I have been given some homework, in which my Math teacher wants me to figure out what expression is represented in the graphs she gave me. Because it is long and painful to do every single one of them by hand, I want to automate it a bit.

The challenge

Given a graph as an input, output the equation represented, in human-readable format. That is, something like that:

y=-|x-3|+5

More generaly, the expression will always be of the form

y=±|x+a|+b

Where you have to replace a and b by their value. The function has to be simplified to its maximum (i.e. can not contain +0, -0, or +|x|);

The input

The input is given in ASCII.

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

This represents the equation y=|x|. The graph is not always centered, and can be of any width and height.

/, \ are straight lines. A and V are verteces. - and | are the axes, and + is their intersection (if not covered by an other character).

Unit

A unit is two characters. for example, -- is one unit on the horizontal axis.

|
|

Is one unit on the vertical axis.

Tests

A test suite is available here. A line of #s is used to separate input from output. Output goes first, for clarity.

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

How Big is the Hyperbolic Round Table of Camelot?

There is a hyperbolic rogue-like game called HyperRogue, based on the truncated order-7 triangular tiling. (Each vertex is surrounded by two hexagons and one heptagon.) There is a place in this game called Camelot, where the Round Table sits. In the middle of the table is the Holy Grail. The table starts with a radius of 28, but each Holy Grail you collect increases the radius by 2. So my question is: given the number of Holy Grails collected, what is the area of the Round Table?

Assumptions:

  • The Holy Grail starts on a heptagon.
  • The heptagon the Holy Grail is on is the circle of radius 0.
  • A circle with radius n+1 comprises the circle of radius n and all the cells touching the circle of radius n.

Test Cases:

0 Holy Grails = 31659398 Tiles
1 Holy Grail = 93888285 Tiles
2 Holy Grails = 278432568 Tiles

Winning Criterion:

Shortest code wins!

\$\endgroup\$
  • 2
    \$\begingroup\$ This challenge is very unclear as it is right now. The end of the first part sounds like you are asking for A = (28 + n*2)^2 + pi, but instead of an area a number of tiles is given. To make it clear what exactly you are asking, you should add some graphical representation of the tiling, the circles ect. \$\endgroup\$ – Laikoni Nov 12 '16 at 23:15
  • \$\begingroup\$ @Laikoni I don't know how to add pictures, or format anything, actually. I'm trying to ask for calculating the area of a hyperbolic circle. Here's the image I want to add illustrating the geometry: en.wikipedia.org/wiki/File:H2_tiling_237-6.png \$\endgroup\$ – Oliver Daugherty-Long Nov 13 '16 at 3:30
  • 1
    \$\begingroup\$ I added some formatting. If you edit your question (and are not on mobile) in the top bar some formatting buttons appear. At the right of this bar is a ?-icon which provides further formatting help. \$\endgroup\$ – Laikoni Nov 13 '16 at 9:27
  • \$\begingroup\$ @Laikoni Thanks! I am on mobile, unfortunately. \$\endgroup\$ – Oliver Daugherty-Long Nov 14 '16 at 0:13
0
\$\begingroup\$

Pay Best Card in Euchre

Input:

Firstly
An array of three cards representing the cards played by each player formatted like

[JD][10H][9S]

Representing

Jack of Diamonds, 10 of Hearts, and Nine of Spades.

As you always sit across from your team-mate in Euchre, the second element represents your team mate's play. Here, the 10H.

Secondly
A Single Char, String, etc representing the trump suit formatted like

S, D, C, H

representing

Spades, Diamonds, Clubs, Hearts

Thirdly an array of four cards representing your hand formatted like

[KD][JC][QH][AS]

representing

King of Diamonds, Jack of Clubs, Queen of Hearts, Ace of Spades

Objective:

Given the three inputs, output the best possible card to add to the cards that have been played such that it meets the following criteria:

  1. It takes the hand if it can, if not output the least valuable card
  2. It takes the hand if it can, however it will not trump your team mate unless it is unavoidable
  3. If it can take the hand, it does so by using the least valuable card. (If you have an ace and a queen that can win the hand, you play the queen).

Output format like [JD]

Formatting

A - Ace
K - King
Q - Queen
J - Jack
10 - Ten
9 - Nine

H - Hearts
D - Diamonds
S - Spades
C - Clubs

10H, 9D, JD, QH, AD, 9C, 10C

Examples

In: [QD][KD][9C], "C", [AH][JH][QH][9H]

Out: 9H

Reason: As clubs are trump, the 9C is winning the hand, we are unable to take the hand so we should discard our lowest card, here the 9H

In: [QD][KD][AD], "H", [AH][JH][QH][9H]

Out: 9H

Reason: As Hearts are trump, the Ace of Diamonds is currently winning the hand, we are able to trump the hand so we should use our lowest card, here the 9H

In: [QD][KD][10D], "H", [AD][JH][QH][9D]

Out: 9D

Reason: As diamonds are trump and we are currently winning the hand, we should play the 9D because our partner currently is winning the hand, so we want to play the 9D over the AD

In: [QH][KH][JH], "D", [AD][JD][QH][9D]

Out: QH

Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower but cannot trump him because QH was led and we must follow suit, the QH

In: [QH][KH][JH], "D", [AD][JD][QC][9D]

Out: JD

Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower and since we have no Diamonds we can trump over him with the JD

Euchre Card Strengths

If Hearts is trump:

JH
JD
AH
KH
QH
10H
9H

See the Euchre Rules if you are unfamiliar with the strength of different cards in Euchre

Since this is Code-Golf the shortest code wins!

Good Luck and have fun!

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

Python Kolmogorov Complexity Golfer

Python is actually pretty good at some Kolmogorov Complexity challenges (compared to other non-golfing languages), from string multiplication being extremely short, to defining variables requiring no types.

Your challenge is to make a program that shortens Python code for Kolmogorov Complexity challenges. You can use anything, not just the usual functions that people typically use.

Your score is the sum of all the bytes for each of the ten test cases, and the winner is the submission with the lowest score.

Test Cases

  1. We're no strangers to code golf, you know the rules, and so do I
  2. It's my Birthday :D (Size 5)
  3. 1, 2, Fizz, 4, Buzz
  4. Code Golf Christmas Edition: How to print out a Christmas tree of height N (Size 5)
  5. “99 Bottles of Beer”
  6. Build me a brick wall!
  7. Quack the Angry Duck
  8. Make the Mexican Wave
  9. Print a Tabula Recta!
  10. Print a 10 by 10 grid of asterisks

I don't know about the rules for each challenge, but for this one, you may print extra spaces after each line and extra newlines at the end of the text.

Note

I don't know how to tag this.

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

Enumerate all the binary matrices

Your task is to write a pair of programs or functions. The first should take a single nonnegative integer, and return some matrix where all elements are 0 or 1 (or true/false). The second should take a matrix of the same form, and return a nonnegative integer.

The two programs should form a bijection, so that every possible matrix is mapped to exactly one nonnegative integer, and every integer to the corresponding matrix. The matrix with no elements must be included, but we consider all matrices with no elements as identical (i.e, there is no 0x3 matrix.)

To clarify, the dimensions of the matrix is not a separate input. You must work out a way to represent all possible dimensions. For instance, you could start off enumerating them like this:

0 <-> []
1 <-> [0]
2 <-> [1]
3 <-> [0;0]
4 <-> [0;1]
5 <-> [1;0]
6 <-> [1;1]
7 <-> [0,0]
8 <-> [0,1]
9 <-> [1,0]
10 <-> [1,1]

But you can also enumerate them in some different order, as long as all matrices of all dimensions can be reached eventually.

You may output and input the integer as a bigint if your language supports that, or as an unbounded string or array if it doesn't. It should however not be limited to a machine word size.

You may output the matrix in any format you choose, as long as the elements of the matrix, and the rows/columns of the matrix are clearly distinguishable.

Whatever output formats you choose, the other program must accept input in the same format. Your functions or programs may opt to print the result rather than return it.

Standard loopholes are forbidden. This is code golf, so the shortest answer wins.

\$\endgroup\$
  • 1
    \$\begingroup\$ 1. It would be helpful for the title to be more explicit that the size of the matrix isn't an input: my initial reaction was that this was yet another "Count from 1 to 2^x" question, and I had to read it carefully to overcome that reaction. 2. Please clarify the situation with empty matrices. Should the matrices include 0 x 1, 2 x 0, etc. dimensions? And if so, how can that be represented unambiguously in input? \$\endgroup\$ – Peter Taylor Nov 16 '16 at 14:34
0
\$\begingroup\$

Challenge

You are the owner of a local supermarket, and your cashier doesn't seem to do the work you told him/her to do. He/She is never on time, returns too much change and doesn't really show optimism at the workplace. So you, as the space saving, but ruthless owner opt to replace him/her.

Rules

The programm should initially take 2 numbers as input, the first beeing the price, and the second the amount you are paying. If you are paying enough it should output the change in 100,50,20,10,5,2,1 notes, always maximizing the amount of high notes. If you aren't, you may output anything indicating a wrong input.

Examples

cashier 100 500
4 100
0  50
0  20
0  10
0   5
0   2
0   1

cashier 600 500
0

Scoring

This is code-golf, so the shortest byte amount wins :) Good luck!

\$\endgroup\$
  • \$\begingroup\$ Does the output format matter, or are we also allowed to have a different output format as long as we know how much 100 bills, 50 bills, etc. are used (like "4x100,0x50,0x20,0x10,0x5,0x2,0x1") ? Also, what if the price and amount paid is exactly the same? \$\endgroup\$ – Kevin Cruijssen Nov 16 '16 at 15:29
  • \$\begingroup\$ related (if not duplicated) \$\endgroup\$ – Rod Nov 16 '16 at 15:30
  • \$\begingroup\$ @KevinCruijssen the output format is fine. inputting the same amount paid as price results in "no chage" but the output shoudl still be 0x100... \$\endgroup\$ – PlatinTato Nov 16 '16 at 15:31
  • \$\begingroup\$ @Rod ah ok :/ didnt find anything in the direcition mine was going. i guess the title made it less findable :/ \$\endgroup\$ – PlatinTato Nov 16 '16 at 15:33
0
\$\begingroup\$

Fold the number!

Given a number n, fold the number as follows: (ex. 30)

First, convert it to binary.

11110

Add one 0 to the start if it has an odd number of digits.

011110

Now, take the second half of the number, reverse it, and put it under. For example, abcd would turn into ab dc (where is a newline):

011
011

Add one 0 to each line if it has an odd number of digits.

0011
0011

Now take the back of the whole thing and put it on the bottom, reversed:

00
00
11
11

Keep doing this until there is only one column, and read this from top to bottom.

00110011

Convert to decimal.

51

Remember, this is , so the code with the smallest number of bytes wins.

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

Postman's Sorting

You are a postman, and you have to walk down a street, delivering letters. Odd-numbered houses are on the left, and even-numbered houses are on the right.

If you had to end up back at the beginning of the street, it would be easy: simply deliver the odd letters in ascending order and the even letters in descending order.

Instead, you need to finish at the end of the street. But you can't simply deliver the letters in ascending house number order, because you would have to cross the street so often. You need to optimise the order to minimise the number of street crossings.

Given a set of positive integers as input, your program or function should output an ordered array giving the optimal delivery sequence. You need to consider the houses in pairs: 1,2; 3,4; 5,6 etc. There are a number of cases:

  • If you have no letters for a pair of houses, you simply ignore them.
  • If you have letters for only one of a pair of houses, you have no choice, you must visit that house.
  • If you have letters for both houses in a pair, then you want to visit the house on the same side as the house you just visited first, then cross and visit the other house.

Example: If you have letters for houses 6, 2 and 5, then you want to deliver them in the order 2, 6, 5, so as to avoid crossing the street a second time.

[Further test cases as needed to clarify comments arising while the question is in the Sandbox.]

This is , so the shortest program wins!

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

Procedurally Generate a Dungeon

It's time to make the new Rogue!

Given no input, output a (randomly) procedurally generated dungeon with a start and an end. It must be possible to get from the start of the dungeon to the end.

Elements may include: (but are not limited to)

  • Key
  • Lock (requires key to pass)
  • Boss
  • Miniboss
  • Test
  • Reward
  • Multi-key
  • Multi-lock (requires n multi-keys to pass)
  • Nothing
  • Boolean switch - switch can toggle when inside this room
  • Boolean gate A - only opens when switch is off
  • Boolean gate B - only opens when switch is on

The output format does not matter as long as:

  • The types of room is present
  • The 2D spacial connection is present

Sandbox Notes:

  • Is this idea somewhat supported?
  • At the moment this is very unclear (at least to me). What should I add to make it more obvious what it is programs should do?
  • Creativity - the bane of the objective winning criteria. I hope to at least make it obvious whether an answer is valid.
  • Too broad? I hope not because I tried to make all dungeons solvable.
  • Simple answers shouldn't be upvoted and answers that output nice dungeons should be.
  • Should answers have to include the critical path? That might ramp up the complexity and isn't really required apart from making sure it's valid.
\$\endgroup\$
0
\$\begingroup\$

Generate fake PGP keys

Input

  • public or private; indicates if the header and footer should say PUBLIC or PRIVATE
  • ; - a delimiter
  • Version string
  • ; - a delimiter
  • Comment string

An example input would be: public;Keybase OpenPGP v1.0.0;https://keybase.io/crypto

Output format

-----BEGIN PGP {PUBLIC|PRIVATE} KEY BLOCK-----
Version: {VERSION_STRING}
Comment: {COMMENT_STRING}
                // newline
{24 lines of alphanumeric + `/+`, 64 chars each}
{one 36 char line of alphanumeric + `/+`}
={four chars of alphanumeric + `/+`}
-----END PGP {PUBLIC|PRIVATE} KEY BLOCK-----

Rules

  • Your program must generate a new fake key every time it is run; and be randomly distributed
\$\endgroup\$
  • \$\begingroup\$ The input shouldn't be too rigid. I would recommend having 3 separate inputs (i.e. putting all into a single string is an option rather than an requirement). Public/private should be a truthy/falsy value. Also what would the version and comment strings be? I think zero or more printable ASCII should be appropriate. \$\endgroup\$ – Link Ng Nov 26 '16 at 11:39
0
\$\begingroup\$

Give those numbers some space!

The numbers have had it. They're through being put in order all the time. They're all sick of their neighbors, and want to be moved as far away as possible. Your goal is to help them be happy!

The 'happiness' of a number is represented by the difference between it and it's next neighbor. For example, an ordered sequence of 0 through 9 looks like this:

0 1 2 3 4 5 6 7 8 9
 v v v v v v v v v
 1 1 1 1 1 1 1 1 1 = 9

A pretty unhappy sequence. But with a little work, we can fix that!

0 2 4 6 8 1 3 5 7 9
 v v v v v v v v v
 2 2 2 2 7 2 2 2 2 = 23

In this example, we've shuffled the numbers around a little, for a total happiness of 23. Better, but I'm sure we can make them even happier!

0 9 1 8 2 7 3 6 4 5
 v v v v v v v v v
 9 8 7 6 5 4 3 2 1 = 45

This is the maximum happiness for this sequence. Perfect!

Our only problem is that there is a lengthy review before they can be moved around. Due to this, your code has to be as short as possible to speed up the process.

Input

Your program or function will take a list of positive integers in any reasonable format (list, array, string, etc). The list is in ascending order.

Output

Output is going to be a list of integers in any reasonable format, representing the sequence of numbers arranged for maximum happiness.

"1 2 3 4 5 6 7 8 9 0"   -- A string is acceptable, as long as the numbers are separated by a character. 
"6@5@4@3@2@1@7@8@9@0"   -- Any non-numeric character is acceptable as a separator, including newlines.
[0,1,2,3,4,5,6,7,8,9] -- The list represented as an array
"0123456789"             -- Not acceptable, no way to tell which numbers are which.

{I'm trying to open up the challenge to many different ways of solving, feel free to offer suggestions}

\$\endgroup\$
  • \$\begingroup\$ The maximum happiness for this sequence is 45, and the challenge, as stated, will be to print "0918273645 45" in as few bytes as possible. You might want to change the challenge to accept an arbitrary list as input, though I suspect the maximum happiness will likely be found by sorting the list, then alternating the lowest and highest remaining items in the list. \$\endgroup\$ – Gabriel Benamy Nov 23 '16 at 17:47
  • \$\begingroup\$ @GabrielBenamy I thought about that, which is why I disallowed hard-coding. Maybe I should put that somewhere clearer. \$\endgroup\$ – Xanderhall Nov 23 '16 at 17:49
  • \$\begingroup\$ You should probably just say "input and output can be in any reasonable format", rather than trying to list the formats that would be useful. (For example, many esoteric languages that don't have built-in lists, integers, etc. need lists to be represented as small pieces of code within the language.) \$\endgroup\$ – user62131 Nov 23 '16 at 18:13
  • \$\begingroup\$ @ais523 I wanted to be more specific with the output than the input, because I didn't want '091827364545' to be valid. I didn't think that would be too restricting. \$\endgroup\$ – Xanderhall Nov 23 '16 at 18:19
  • \$\begingroup\$ I'd suggest requiring the output to be the arranged numbers, or requiring the output to be the happiness level, or letting answerers choose which they would like to output. For me, requiring both takes away some of the fun, because outputting multiple values is clumsy in many languages. \$\endgroup\$ – ETHproductions Nov 23 '16 at 18:23
0
\$\begingroup\$

Calculate the chi-squared test statistic


Introduction

A chi-squared test is a statistical test used to determine the extent of any association between two categorical varaiables. In this challenge, you will calculate the value of the chi-squared test statistic given a contingency table.

Method

Say that we have two variables A and B, which are from a single population. A can take values from the categories p, q, and r, while b can take values from the categories x, y, and z. A sample is now taken from the population, and the frequencies of the elements of this sample that fall into each category are observed. This can be used to construct a contingency table:

         A
     x   y   z
  p [10, 12,  3]
B q [45,  0,  9]
  r [65, 32, 34]

For example, the table shows that 10 elements fall into p and x, and that no elements fall into q and y.

Next, we calculate the expected frequencies, assuming that A and B have no association. This is performed by applying the following to each entry in the contingency table, where f_e is the expected frequency:

Expected frequency

In this case, this yields:

[14.285714285714286, 5.238095238095238,  5.476190476190476 ]
[30.857142857142858, 11.314285714285715, 11.82857142857143 ]
[74.85714285714286,  27.447619047619046, 28.695238095238096]

Next, we calculate the contributions to the test statistic by applying the following to each entry, where f_0 is the orignal observed frequency:

Contribution to the test statistic

In this case, this yields:

[1.285714285714286,  8.72900432900433,   1.1196687370600416]
[6.482142857142857,  11.314285714285715, 0.6763975155279506]
[1.2979825517993466, 0.7550444466475007, 0.9806678994199733]

Finally the value of the test statistic is found by summing all the elements of the contributions table, which gives:

32.640908336601996

Sandbox

To do

  • Input/output, specification etc
  • Test cases (Pyth program for test cases)
\$\endgroup\$
0
\$\begingroup\$

A Numpad's Knight Numbers Extended Edition

This challenge is an extension of the one linked above by Calvin, and inspired by a comment by Darrel Hoffman.

My computer has a numpad which is significantly more expansive than Calvin's. For reference, it looks like this:

🔒/ * -
7 8 9 +
4 5 6 +
1 2 3 ↵
0 0 . ↵

🔒 denotes numlock, ↵ denotes enter.

Once again, we have a chess knight hopping around on a numpad. The objective of your program will be to determine which numbers can be generated by placing a knight on any* of these keys and letting him move around. Note that although there is only one 0 key, it's two wide so 5->0->3 is possible but 4->0->3 is not, and the numlock will toggle the numpad on or off, in practice this only allows a jump from 5 to 9.

'*' and '+' are unused and should never be pressed, other than that you can start your knight on any key. The knight may not press ↵ during number entry, but most end there.

Your program will for input receive a number (possibly negative, possibly containing a single decimal point . OR single fraction sign /).

Test cases:

Truthy:
0, 2, 5, 6, 9
-6049
3059 (note the use of `numlock`)
5.16
-61.5
4/6
-6/40
55 (you can jump on 5 or 9 more than once in a row with 🔒...)
Falsy:
66 (... But other numbers can't reach 🔒)
8 (Not within range of ↵ key)
96 (The knight can't move like that)
405 (It's probably easier to think of the 0s as being separate keys)

Input will always be a valid integer, decimal float, or fraction.

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

Linify

If you perform this algorithm but leave out some of the lines, you can produce recognizable pictures.

An example via Linify.me - as they explain,

Linify uses a greedy randomized algorithm. First, the darkest pixel is found. Then a number of random lines are drawn through that point, and the pixel values along each line are added together. The line with the darkest average is chosen, and the value of that line is subtracted from the image. Then the whole process is started over again for however many lines we are drawing. By the nature of the algorithm, the optimal line drawing configuration is probably not achieved, but performance is far superior to the naive method of checking every line.

The concept for this site came from a Reddit thread.

Challenge

Reduce (this input photo) to a linification using N pins on the outside circle. Each line of the file should be a comma separated list of the pin number and the other pins to draw lines to.

Scoring

(formula using code length and output quality using some sort of comparison software...)

(maybe that comparison algorithm is itself a challenge)

(maybe this linify challenge should be in black and white?)

The Mathematica Clause: You may import graphics and math libraries for your platform older than this post, and the code required to import them does not apply toward your byte count.

\$\endgroup\$
  • \$\begingroup\$ The algorithm needs some clarification. 1. What line-drawing algorithm to use? Anti-aliasing? Bresenham? 2. What is the "value of that line"? The average? Or does it mean that all pixels in the line are set to black? 3. If not in black and white, what formula should be used for the brightness? 4. Since it selects a line through the darkest point and then subtracts along that line, it seems that the darkest point should get darker still and all of the lines should pass through the same point, but that's not true of the demo images. Why not? \$\endgroup\$ – Peter Taylor Dec 2 '16 at 23:10
  • \$\begingroup\$ 1. Agreed that will need to be pinned down. 2. All pixels in the line are set to one color. 3. I don't know, so b&w is becoming more probable. 4. If you create your own via linify's front page there are both additive and subtractive methods. The example I provided probably did not use default settings. \$\endgroup\$ – wyldstallyns Dec 2 '16 at 23:43
  • \$\begingroup\$ Related: thevelop.nl/blog/2016-12-25/ThreadTone \$\endgroup\$ – wyldstallyns Dec 25 '16 at 22:58
0
\$\begingroup\$

Quine Creator

Consider a program (or function or code snippet) that accepts a single string argument and returns a string result. Here's an example, which I will call Program 1, of a program that duplicates its input:

@echo %* %*

We could write a Program 2 that would take the source code of the original program and substitute a hard-coded string, so that the resulting source code would take no input and produce a fixed result. If we passed it Program 1 and "Hello, world!", it would produce a program that always outputs "Hello, world!" in duplicate:

@echo Hello, world! Hello, world!

Moving on, consider Program 3 which has the effect of Program 2 with the same string for both the source code and the hard-coded string, so for input of Program 1 this would result in something like this:

@echo @echo %* @echo %*

All that remains is to invoke Program 3 with its own source code as its input. Program 3 will then create a program that invokes Program 3 with the source code of Program 3 as its input. In other words, a quine!

Please provide the source to Program 3.

This is , so the shortest resulting wins.

\$\endgroup\$
  • \$\begingroup\$ What are the requirements for an answer to be valid? In the "loose" end, you could require only that the answer produces a quine when given its own source as input. In the "strict" end, you could require that the answer can be given an arbitrary program P as input, and it should return a new program that has the same effect as running P on its own source code. The former may be more loose that you'd like, and the latter is very difficult unless one can restrict the set of input programs in some way. \$\endgroup\$ – Zgarb Dec 5 '16 at 12:26
  • \$\begingroup\$ Also, somewhat related. \$\endgroup\$ – Zgarb Dec 5 '16 at 12:29
  • \$\begingroup\$ @Zgarb What sort of restrictions? At the very least I suppose I could make it clear that the answer only needs to accept a program P that accepts input in the same way as the answer does. \$\endgroup\$ – Neil Dec 5 '16 at 13:37
  • \$\begingroup\$ On a second thought, the strict version is probably not that hard in most languages, since you can restrict the input and output methods. \$\endgroup\$ – Zgarb Dec 5 '16 at 13:50
  • \$\begingroup\$ I don't think the example you give in the question actually works to generate a quine because it doesn't escape properly. (This technique certainly can produce a quine, but the escaping needs careful thought.) Also, I think the correct middleground to find is "write a program which takes a string as argument, and returns a program that executes the program represented by that string by giving it that string as input". The escaping is explicit here, and it's a task that should be possible in most languages. \$\endgroup\$ – user62131 Dec 6 '16 at 10:54
  • \$\begingroup\$ @ais523 Ah, you're expecting @echo @echo %%* @echo %%*? \$\endgroup\$ – Neil Dec 6 '16 at 16:09
  • \$\begingroup\$ Not quite. The two echos have to be different; the first has to produce the argument itself, the second has to produce an escaped version of the argument. It's hard to do in bash, so here's a version in Python: lambda i: print(i + "(" + repr(i) + ")"). Giving this function its own string representation as an argument does indeed result in a quine (I just checked that); note that i and repr(i) are different, because the first needs to become code in the output program, the second needs to become a string literal. \$\endgroup\$ – user62131 Dec 6 '16 at 17:13
  • \$\begingroup\$ @ais523 Sure, applying Program 3 to itself should do that, but I'm not providing an example of Program 3 applied to itself, only an example of Program 3 applied to Program 1. \$\endgroup\$ – Neil Dec 6 '16 at 19:29
0
\$\begingroup\$

I tried searching for this, thinking it was a duplicate. I was unable to find anything (hard to know what to search for), so let me know if it is.

The Challenge

We all know how to apply bitwise not to a binary number. It simply flips all the bits, so 10010 becomes 01101. For this challenge, we will be creating a definition for a digitwise not, applying the same concept to base 10.

Digitwise Not

For this challenge, digitwise not is defined as follows. Line up the digits 0-9. Because 0 and 9 are endpoints of this list, they are considered "opposite", so digitwiseNot(0) == 9, and digitwiseNot(9) == 0. The same concept applies when you go one element into the list from both ends, meaning 1 and 8 are opposite, as are 2 and 7, etc. Full list:

0 <=> 9 
1 <=> 8 
2 <=> 7 
3 <=> 6 
4 <=> 5 
5 <=> 4 
6 <=> 3 
7 <=> 2 
8 <=> 1 
9 <=> 0

For multi-digit numbers, you apply the operation separately for each digit. For example, digitwiseNot(1234) is 8765 because 1 -> 8, 2 -> 7, 3 -> 6, and 4 -> 5.

Rules

  • Take only a single input, representing an integer greater than or equal to 0 in whatever format is best for your language (stdin or function parameter, integer or string, etc)
  • Produces a single output, which is the digitwise not of the input (can be returned from function or printed to stdout)
  • Can be either a full program or just a function.
\$\endgroup\$
  • \$\begingroup\$ Looks nice, but I don't think there will be many interesting answers, because you just have to calculate 9...9 (with the same number of 9 as there are digits in the input number) minus the input number. E.g. digitwiseNot(1234) = 9999 - 1234 = 8765. But of course it's a valid and well specified challenge. Maybe you should give an example for an input number with a leading 0(or exclude such cases): Is 012 = 12 -> 87 or 012 -> 987? \$\endgroup\$ – nimi Dec 7 '16 at 19:59
  • \$\begingroup\$ The normal name for this operation is "complement"; that might help your search (and should definitely be mentioned in the title or body of the question, so that it comes up on other people's searches). The question doesn't seem to be a duplicate. It's pretty easy, but I don't see a reason to disallow it (the main issue is that it's likely to get disproportionately many answers and upvotes, which is always annoying because it gives a bad impression of what the site's about on HNQ, but that's not really a fault of the question). \$\endgroup\$ – user62131 Jan 7 '17 at 9:26
0
\$\begingroup\$

Christmas Present Viewing

You're stacking Christmas presents, and you'd like to make sure that the pile will be aesthetically pleasing from whichever side you view it, without having to actually go through all the hard work of stacking them.

Write a program that takes the size of the present stacks in the pile, and outputs what the pile will look like from all four corners.

Each present is an opaque cube that looks like this:

  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+

If you have two presents next to each other, for example, it would look like this, because the nearer present occludes part of the further one:

  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+

Two presents with a single space gap between them would look like this:

  +----+    +----+
 /    /|   /    /|
+----+ |  +----+ |
|    | +  |    | + 
|    |/   |    |/
+----+    +----+

Input

A two-dimensional rectangular set of integers greater than or equal to 0, representing the heights of stacks of presents in the pile, and an integer determining which corner to view it from.

For example:

01  1
10

would indicate two stacks 1 present high, that are diagonally adjacent, viewed from the corner you have assigned index 1.

You may have the corners be 0-indexed or 1-indexed and you may have them occur in any order, as long as a different corner is used for each of {0,1,2,3} or {1,2,3,4}.

Output

An ASCII image, showing the stack from the selected corner. Parts of the presents that would be occluded by part of a present in front of them should not be shown.

  • You may optionally begin and end lines with up to ten trailing spaces.
  • You may optionally begin and end your output with up to seven additional newlines.

[Sandbox note: This is so that there can be up to one present width and depth around the drawn area. This question is supposed to be about drawing the boxes with occlusion, not working out how wide the drawing should be.]

For example, for the input given earlier, the output should look like (all four corners are given; your code need only return one at a time):

         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+


  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+


         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+


  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+

Scoring

This is , so the shortest code wins. Standard loopholes are forbidden.

Tests

1
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+


010
101
010
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+    


11
  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+
    +----+
   /    /|
  +----+ |
 /    /| +
+----+ |/
|    | +
|    |/
+----+
  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+
    +----+
   /    /|
  +----+ |
 /    /| +
+----+ |/
|    | +
|    |/
+----+


01
10
         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+
  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+
         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+
  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+


2
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+


101
121
010


       +----+
    +-/    /| +----+
   / +----+ |/    /|
  +--|    | +----+ |
 /   |    |/    /| +
+----+----+----+ |/
|   /    /|    | +
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+


         +----+
      +-/    /|-+
     / +----+ |/|
    +--|    | +----+
    |  |    |/    /|
  +----+----+----+ |
 /    /    /|    | +
+----+----+ |    |/
|    |    | +----+
|    |    |/
+----+----+
         +----+
        /    /|-+
       +----+ |/|
    +--|    | +----+ 
   /   |    |/    /|
  +----+----+----+ |
 /    /|   /    /| +
+----+ |  +----+ |/
|    | +--|    | + 
|    |/   |    |/
+----+    +----+
       +----+
      /    /|-+----+
     +----+ |/    /|
  +--|    | +----+ |
 /   |    |/|    | +
+----+----+----+ |/
|   /    /    /|-+
|  +----+----+ |
+--|    |    | +
   |    |    |/
   +----+----+
\$\endgroup\$
0
\$\begingroup\$

Ordinal Representation

A trick in code golfing, especially when digit usage in a source is restricted, is to use the ordinal values of characters to reach numbers. Instead of finding a representation for a single number, you will be finding an algorithm to represent any number in terms of ordinal values.

Challenge

Given an integer N from stdin, print its representation as a sum, diference, and/or product of the fewest terms taken from the range [32, 47] + [58, 126] (symbolic non-numeric characters). Parentheses are not allowed, and standard order of operations is used. There are often multiple minimal representations possible, but any one of them is acceptable.

0 < N < 231

Score ranking in order of importance:

  1. Shortest representation by number of terms
  2. Shortest code by bytes

Examples

47
/

14
=-/

2016
 *?     //Spaces may be represented as is.

1999
$*/-E

8675
U*d+K

10001
d*e-d
\$\endgroup\$
0
\$\begingroup\$

Start another process in a endless loop

Your task is to start a process (no thread!) which doesn't end, but the main program mustn't end after starting the other process. You have accomplished the task, if I can see TWO processes of your program after executing it, waiting 5 secs, and then doing rather "ps -aux" or starting the Task Manager on Windows.

This will be a challenge, the answer with the shortest code would win.

\$\endgroup\$
  • \$\begingroup\$ So write a fork bomb with a 4-second sleep? \$\endgroup\$ – Peter Taylor Dec 12 '16 at 12:19
  • \$\begingroup\$ This is pretty unclear as written. Which programs are in the various processes involved? How many are involved (two, or more than two)? Which are waiting, and which are running? \$\endgroup\$ – user62131 Dec 13 '16 at 1:10
0
\$\begingroup\$

It's a prime time to metagolf!

Puzzprimes

A puzzprime is a puzzle in which you have to use primes to create a number.

Say the number is 24 - one way to create 24 (using only primes) is:

3*2*2*2 (eq. 1)

Another way is:

5*7-11 (eq. 2)

The "efficiency" of answers is calculated like so:

Let's say we take eq. 1, which is

3*2*2*2

There are 3 operators in there, and the primes used are (in decreasing order of prime size) 1*3, 3*2.

We can convert this to a polynomial using the cardinals of each of the primes:

1*3, 3*2 -> x^2 + 3x

We replace x with the amount of operators, and we get our final answer:

3^2 + 3*3 = 18 (eq. 1)

For eq. 2, the efficiency score is this:

1*11 + 1*7 + 1*5 -> x^5 + x^4 + x^3
x = 2 (operators), 2^5 + 2^4 + 2^3 = 56

The aim of a puzzprime is to score as low a score as possible.

You are allowed to use the following operators:

  • basic mathematical operators (+-*/)
  • factorial (!)
    • only normal factorials.
  • ceiling and floor (c() and f() respectively)
  • square root (s())
    • no square roots of negative numbers.
  • concatenation (2 3 -> 23)
    • each concatenation counts as an operator: 2 3 4 -> 234 is 2 operators.

Task

Your task is to generate solutions for puzzprimes for the first 200 composite numbers above 100,000 - your final score will be the sum of all 200 scores for each number, and the lowest score wins.

Specs and Rules:

  • You must complete one puzzprime in 1 hour on a modern laptop.
  • Your program must return the same value for a puzzprime every time the program is run.
  • Your program must work for all puzzprimes, not just the test cases.
  • You must provide your answer in this format:

    {language}, {score}
    {code}
    

    (Provide your answer without braces)

  • You are not allowed to hardcode any answers for the most optimal solution.

Meta:

  • Is the scoring system good enough?
  • Any clarifications in the explanation? Is there anything I need to patch up?
  • Is this a dupe?
\$\endgroup\$
  • \$\begingroup\$ Have you written a brute-force implementation to see how interesting it is? I suspect that with a few exceptions for small primes the general optimal value will be p + (p + ... + p) / p + (p - p) * ppp....p with occasional variants such as p + (pp + p) / p + (p - p) * ppp....p for prime gap 12. \$\endgroup\$ – Peter Taylor Dec 12 '16 at 12:18
0
\$\begingroup\$

Create a script that, when run from a console, will display the text already in the console, prior to running.

Challenge

  • How will the winner of the challenge will be determined?

    The golf with the shortest length (in bytes) will win.

Example Input and Output

Input: (Shown is Windows)

Microsoft Windows [Version 10.0.14393]
(c) 2016 Microsoft Corporation. All rights reserved.

C:\Users\CSS>dir
 Volume in drive C has no label.
 Volume Serial Number is B0A1-E768

 Directory of C:\Users\CSS

11/30/2016  07:18 PM    <DIR>          .
11/30/2016  07:18 PM    <DIR>          ..
12/01/2016  04:45 PM    <DIR>          .android
10/25/2016  12:41 PM    <DIR>          .atom
11/29/2016  05:52 PM    <DIR>          .dnx
10/27/2016  09:34 PM               148 .gitconfig
11/28/2016  03:02 PM    <DIR>          .MemuHyperv
11/29/2016  05:55 PM    <DIR>          .nuget
12/01/2016  04:42 PM    <DIR>          .oracle_jre_usage
10/26/2016  11:37 PM    <DIR>          .ssh
12/04/2016  06:20 PM    <DIR>          .VirtualBox
11/29/2016  12:56 PM    <DIR>          .vscode
11/28/2016  03:53 PM             8,528 2016-11-28-20-44-28.000-VBoxSVC.exe-2608.log
11/28/2016  05:09 PM    <DIR>          Andy
11/23/2016  10:01 AM    <DIR>          Contacts
12/11/2016  11:16 PM    <DIR>          Desktop
11/30/2016  07:35 PM    <DIR>          Documents
12/11/2016  01:43 AM    <DIR>          Downloads
11/23/2016  10:01 AM    <DIR>          Favorites
11/22/2016  07:23 PM               409 fciv.err
11/22/2016  07:21 PM               266 hi
11/23/2016  10:01 AM    <DIR>          Links
11/22/2016  04:28 PM                15 me.txt
11/28/2016  03:08 PM    <DIR>          Music
10/25/2016  12:44 AM    <DIR>          OneDrive
12/09/2016  05:57 PM    <DIR>          Pictures
11/23/2016  10:01 AM    <DIR>          Saved Games
11/24/2016  08:56 PM               151 search.bat
11/23/2016  10:01 AM    <DIR>          Searches
11/07/2016  11:00 AM                11 t.bat
11/24/2016  08:55 PM                93 update.bat
11/28/2016  03:08 PM    <DIR>          Videos
               8 File(s)          9,621 bytes
              24 Dir(s)  152,887,300,096 bytes free

C:\Users\CSS>

Output:

The script must display something like the text above, in the sense that it must display exactly what was in the console before the script was called.

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

Transpile Brainfuck

Brainfuck is a very basic esolang with only 8 commands, please visit the esolangs link if you do not know the language's specification. Your job will be to transpile brainfuck into your language.

For input, your code will recieve a string of brainfuck. You can assume that all [ and ] will be matched properly, but the code may contain nops (characters not part of the spec).

Output should be a program written in the same language as your program which is functionally identicall to the passed brainfuck program.

Your brainfuck implementation should have 300000, and support integers from 0 to 127. Going off the tape should wrap to the other side, and going over 127/below 0 shoudl overflow or underflow. The generated program should generate no errors. Outputting a cell with . should output that number's character in ASCII, not the decimal representation of that number.

This is , so fewest bytes wins.

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

Addmod, Mulmod, Powmod


Addmod

Imagine defining the modulo operation in terms of repeated addition or subtraction, so that a mod b is found by starting with a and repeatedly adding or subtracting b until the answer is in the range [0, b).

Call this operation addmod (which is equivalent to just mod), and similarly define mulmod and powmod, where the definitions are the same apart from replacing "addition or subtraction" with "multiplication or division" and "raising to the bth power or taking the bth root".

Mulmod

a mulmod b is found by starting with a and repeatedly multiplying or dividing by b until the answer is in the range [1, b). Note the range here is not [0, b) as that would allow multiplying or dividing a number within the range without leaving the range.

Powmod

a powmod b is found by starting with a and repeatedly raising to the power of b or 1/b until the answer is in the range ( um, I'll think about this ).

For powers that give more than one result, always take the one that is positive and real.

Input

There are three input values:

  • "Dividend" (a in "a mod b").
  • "Divisor" (b in "a mod b").
  • Function indicator. This can be one of:
    1. 0 for addmod, 1 for mulmod, 2 for powmod.
    2. 1 for addmod, 2 for mulmod, 3 for powmod.

Here "number" is not necessarily a base 10 representation, but must support non-integer input.

You may take the inputs in any defined order, or as a container holding them in any defined order.

Input ranges

  • addmod: a is in (-65536, 65536), b is in (0, 65536).
  • mulmod: a is in [0, 65536), b is in (1, 65536).
  • powmod: a is in (0, 65536), b is in (1, 65536).

Where [ and ] are inclusive, and ( and ) are exclusive.

Output

A number corresponding to a mod b using the appropriate variation of mod (addmod, mulmod or powmod).

Test cases

[ To be added ]

Graphs?

\$\endgroup\$
  • \$\begingroup\$ Just for the record, I'm still in favour of limiting this to mulmod. :) \$\endgroup\$ – Martin Ender Dec 14 '16 at 8:23
  • \$\begingroup\$ @MartinEnder I haven't ruled that out. I'm letting them all grow in parallel before deciding whether to prune. \$\endgroup\$ – trichoplax Dec 14 '16 at 13:04
0
\$\begingroup\$

Graphical Stars

Meta: this is currently pretty rough so I could get some ideas down quick. I'm also probably not using the right terminology as I'm not very familiar with graphs and graph theory. Looking for feedback.

example star

Take an input integer 50 <= n <= 300 and construct a circular graph of n points. Randomly connect them with n/2 chords. Some points will likely have more than one edge - that's fine. Then, take a regular 5-pointed star of the same diameter as the circle, and use it as a stencil. Output the inner part of the star either to the screen or an image file.

\$\endgroup\$
  • \$\begingroup\$ You might want to find/make a better picture for this. The current one isn't a regular star. \$\endgroup\$ – Geobits Dec 13 '16 at 21:46
  • \$\begingroup\$ You could also change it from "n points, with n/2 connected" to "n chords", which I think might give a better aesthetic. \$\endgroup\$ – Geobits Dec 13 '16 at 21:47
  • \$\begingroup\$ @Geobits The star was taken from the header of an email Timmy got. n chords means n edges, right? Chords are generally for circles. \$\endgroup\$ – Pavel Dec 13 '16 at 21:49
  • \$\begingroup\$ @Pavel I know where it came from, but while it's good for inspiration, it's misleading if that's the only one presented. \$\endgroup\$ – Geobits Dec 13 '16 at 21:51
  • \$\begingroup\$ @Geobits Dang, you're right - the edges aren't quite straight across. I'll need to construct a different image. Thanks! \$\endgroup\$ – AdmBorkBork Dec 13 '16 at 21:55
  • \$\begingroup\$ "Output the inner part of the star either to the screen or an image file." So should the outline of the star not be output? \$\endgroup\$ – Martin Ender Dec 14 '16 at 8:22
  • \$\begingroup\$ @MartinEnder I see how that wording is confusing. When I have got my updated star, I'll edit that section appropriately. Thanks! \$\endgroup\$ – AdmBorkBork Dec 14 '16 at 13:25
0
\$\begingroup\$

Radiation hardening meta-program (Cops)

Nuclear winter is coming, so you feel the need to radiation harden every program you've ever made in order to preserve your sanity during the fallout. Unfortunately, time is short, so you have to pick and choose which functionality to support.

Write a program that can take any valid program in the same language as input. Your program must then output a radiation hardened program that should do the same thing. Note that verifying that two programs are functionally equivalent is a form of the halting problem.

A counterexample will be a valid input program where the output will not be a correct, radiation-hardened version of the input. It is the job of the robber to find any such valid counterexample, showing that your meta-program is not a complete solution.


Radiation hardening meta-program (Robbers)

Nuclear winter is coming, and your buddy has gone insane. He claims he has a program that will save his sanity and preserve his life's work. You need to prove him wrong, because that's on your bucket list and time is short.

Find a valid program in the same language as the meta-program that, when given as input, the meta-program does not produce a correct, radiation-hardened version as output.

\$\endgroup\$
  • \$\begingroup\$ I think it is possible, as there are standard formats for radiation hardened programs in most 2D languages. The scoring method seems reasonable. +1 \$\endgroup\$ – FlipTack Dec 14 '16 at 18:10
  • \$\begingroup\$ @Flp.Tkc The thing is that the program might be rather large to accomplish this task, and then hardening it with itself might take a long time to run. And then, how do we test programs? \$\endgroup\$ – mbomb007 Dec 14 '16 at 18:49
  • \$\begingroup\$ @Flp.Tkc those standard formats often assume that the workload program itself can be expressed as a linear program. plus, 2D languages also will almost always have some weird features that can make any program very brittle with respect to any kind of modification (like reading the source code). \$\endgroup\$ – Martin Ender Dec 14 '16 at 18:57
  • 1
    \$\begingroup\$ @mbomb007 The main problem I see with this challenge is verifying the correctness of solutions. \$\endgroup\$ – Martin Ender Dec 14 '16 at 18:58
  • \$\begingroup\$ @MartinEnder Same. If someone submitted a solution, it might be really long, and the output could be many times as long as the input. Then you have to determine what inputs to test, and verify each output. \$\endgroup\$ – mbomb007 Dec 14 '16 at 19:04
  • \$\begingroup\$ Perhaps we could go about it sort of like a KOTH. Write a controller that supports a bunch of languages, and it has a bunch of programs for each language that it will test and verify for a given submission, as well as running the submission on itself. I think the results would be worth it. \$\endgroup\$ – mbomb007 Dec 14 '16 at 19:05
  • \$\begingroup\$ @mbomb007 Then you'll get solutions that will work exactly for these tests. \$\endgroup\$ – Martin Ender Dec 14 '16 at 19:07
  • \$\begingroup\$ @MartinEnder So? If someone can find a counterexample, then the answer is invalidated. \$\endgroup\$ – mbomb007 Dec 14 '16 at 19:10
  • \$\begingroup\$ Then I don't see how this helps with verifying the correctness of answers. \$\endgroup\$ – Martin Ender Dec 14 '16 at 19:10
  • \$\begingroup\$ Let us continue this discussion in chat. \$\endgroup\$ – mbomb007 Dec 14 '16 at 19:11
  • \$\begingroup\$ You need a requirement that the language is a programming language. (Otherwise, it can trivially be solved using a "language" in which all programs are cat.) \$\endgroup\$ – user62131 Dec 14 '16 at 21:13
  • \$\begingroup\$ @ais523 That's really a default. \$\endgroup\$ – mbomb007 Dec 14 '16 at 21:19
  • 1
    \$\begingroup\$ @mbomb007: There are multiple contradictory Meta posts about it. Until we can get our act together and come to a conclusion on it, it's best for challenges to say explicitly when it's relevant. \$\endgroup\$ – user62131 Dec 14 '16 at 21:25
  • \$\begingroup\$ Nah. If it's not within the spirit of the challenge, it'll be pretty obvious and deleted soon after. \$\endgroup\$ – mbomb007 Dec 14 '16 at 21:31
0
\$\begingroup\$

Anagrammatic quine

Your task is to create a program which is a quine, with the added challenge that all permutations of characters of the program still generate the same output as the first program.

So, for example, if your program is

abc

this program must output

abc

exactly, with optional leading or trailing newlines.

Any permutations of the program's characters, so

acb
bac
bca
cab
cba

must also output abc.

Rules:

  • You must have at least 2 distinct characters in your program.
  • No comments.
\$\endgroup\$
  • \$\begingroup\$ I doubt this is possible for quines longer than one or possibly two characters? \$\endgroup\$ – Stewie Griffin Dec 18 '16 at 9:51
  • \$\begingroup\$ @StewieGriffin It's always impossible until Dennis shows up and does a less than 20-byte Jelly solution. Then it's possible. TBH, I have no idea how this is going to turn out - perhaps it's going to be like a "Tetris in GoL" question? \$\endgroup\$ – clismique Dec 18 '16 at 9:57
  • \$\begingroup\$ Less than 20, sure... more than 2 (distinct) characters; I'd be very surprised. It would mean all combination of those characters must be a quine. \$\endgroup\$ – Stewie Griffin Dec 18 '16 at 10:14
  • \$\begingroup\$ @StewieGriffin In the current situation, acb outputs abc, not acb (so it's not a quine in itself). Would it be easier or harder if I make it a quine instead of a single output? \$\endgroup\$ – clismique Dec 18 '16 at 10:24
  • \$\begingroup\$ @Qwerp-Derp depends on what you want the challenge to be. Now it's like almost impossible (though I already have a solution lol, thanks esolangs.org) ; but saying 'all permutations must be quines too' make it even harder I think. \$\endgroup\$ – V. Courtois Jul 18 '17 at 14:01
0
\$\begingroup\$

Interweaved quine

Your task is to create a program that, when run, returns itself as output (this is known as a quine). However, this quine must, when it is copied n times, returns the quine, but with each of its characters duplicated in place n times.

If your original program is Derp:

Derp -> Derp (must return itself as output to be a quine)

DerpDerp -> DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -> DDDeeerrrppp
etc. etc.

Rules and Specs:

  • You are allowed to have leading and/or trailing newlines in your program.
  • Your program must contain at least two distinct characters (which implies that your code must be at least 2 bytes long).
  • Standard quine rules apply.
\$\endgroup\$
  • \$\begingroup\$ What happens if the program is copied -1 times (ie layed out in reverse)? \$\endgroup\$ – Kritixi Lithos Dec 21 '16 at 10:52
  • \$\begingroup\$ @KritixiLithos It doesn't really matter, it could do whatever it wants. \$\endgroup\$ – clismique Dec 21 '16 at 11:13
  • 1
    \$\begingroup\$ The first sentence also seems unnecessarily complicated, especially for people who don't know what a quine is. How about something like "Your task is to write program which prints its own source code (a quine). However, when the program's source code is repeated N times, it should print its code with each character repeated N times instead." The examples could also be condensed into a single code block, which would allow you to add one or two more examples for clarity without using lots of vertical space. \$\endgroup\$ – Martin Ender Dec 21 '16 at 13:47
  • \$\begingroup\$ You should say n is guaranteed to be a positive integer larger than (or equal to) 1 \$\endgroup\$ – FlipTack Dec 24 '16 at 20:07

You must log in to answer this question.

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